int main(void) {{
- printf ("{fmt}", {cast} {f}());
+ printf ("{fmt}", {cast} {fname}());
return 0;
- }}'''.format(**fargs)
+ }}'''
res = self.run(code, env, extra_args=extra_args, dependencies=dependencies)
if not res.compiled:
- m = 'Could not get return value of {}()'
- raise mesonlib.EnvironmentException(m.format(fname))
+ raise mesonlib.EnvironmentException(f'Could not get return value of {fname}()')
if rtype == 'string':
return res.stdout
elif rtype == 'int':
try:
return int(res.stdout.strip())
except ValueError:
- m = 'Return value of {}() is not an int'
- raise mesonlib.EnvironmentException(m.format(fname))
+ raise mesonlib.EnvironmentException(f'Return value of {fname}() is not an int')
+ assert False, 'Unreachable'
@staticmethod
- def _no_prototype_templ():
+ def _no_prototype_templ() -> T.Tuple[str, str]:
"""
Try to find the function without a prototype from a header by defining
our own dummy prototype and trying to link with the C library (and
@@ -643,7 +752,7 @@
return head, main
@staticmethod
- def _have_prototype_templ():
+ def _have_prototype_templ() -> T.Tuple[str, str]:
"""
Returns a head-er and main() call that uses the headers listed by the
user for the function prototype while checking if a function exists.
@@ -658,13 +767,16 @@
# is not run so we don't care what the return value is.
main = '''\nint main(void) {{
void *a = (void*) &{func};
- long b = (long) a;
+ long long b = (long long) a;
return (int) b;
}}'''
return head, main
- def has_function(self, funcname, prefix, env, *, extra_args=None, dependencies=None):
- """
+ def has_function(self, funcname: str, prefix: str, env: 'Environment', *,
+ extra_args: T.Optional[T.List[str]] = None,
+ dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+ """Determine if a function exists.
+
First, this function looks for the symbol in the default libraries
provided by the compiler (stdlib + a few others usually). If that
fails, it checks if any of the headers specified in the prefix provide
@@ -682,9 +794,13 @@
if val is not None:
if isinstance(val, bool):
return val, False
- raise mesonlib.EnvironmentException('Cross variable {0} is not a boolean.'.format(varname))
+ raise mesonlib.EnvironmentException(f'Cross variable {varname} is not a boolean.')
- fargs = {'prefix': prefix, 'func': funcname}
+ # TODO: we really need a protocol for this,
+ #
+ # class StrProto(typing.Protocol):
+ # def __str__(self) -> str: ...
+ fargs = {'prefix': prefix, 'func': funcname} # type: T.Dict[str, T.Union[str, bool, int]]
# glibc defines functions that are not available on Linux as stubs that
# fail with ENOSYS (such as e.g. lchmod). In this case we want to fail
@@ -727,56 +843,64 @@
# need to look for them differently. On nice compilers like clang, we
# can just directly use the __has_builtin() macro.
fargs['no_includes'] = '#include' not in prefix
+ is_builtin = funcname.startswith('__builtin_')
+ fargs['is_builtin'] = is_builtin
+ fargs['__builtin_'] = '' if is_builtin else '__builtin_'
t = '''{prefix}
int main(void) {{
+
+ /* With some toolchains (MSYS2/mingw for example) the compiler
+ * provides various builtins which are not really implemented and
+ * fall back to the stdlib where they aren't provided and fail at
+ * build/link time. In case the user provides a header, including
+ * the header didn't lead to the function being defined, and the
+ * function we are checking isn't a builtin itself we assume the
+ * builtin is not functional and we just error out. */
+ #if !{no_includes:d} && !defined({func}) && !{is_builtin:d}
+ #error "No definition for {__builtin_}{func} found in the prefix"
+ #endif
+
#ifdef __has_builtin
- #if !__has_builtin(__builtin_{func})
- #error "__builtin_{func} not found"
+ #if !__has_builtin({__builtin_}{func})
+ #error "{__builtin_}{func} not found"
#endif
#elif ! defined({func})
- /* Check for __builtin_{func} only if no includes were added to the
- * prefix above, which means no definition of {func} can be found.
- * We would always check for this, but we get false positives on
- * MSYS2 if we do. Their toolchain is broken, but we can at least
- * give them a workaround. */
- #if {no_includes:d}
- __builtin_{func};
- #else
- #error "No definition for __builtin_{func} found in the prefix"
- #endif
+ {__builtin_}{func};
#endif
return 0;
}}'''
return self.links(t.format(**fargs), env, extra_args=extra_args,
dependencies=dependencies)
- def has_members(self, typename, membernames, prefix, env, *, extra_args=None, dependencies=None):
+ def has_members(self, typename: str, membernames: T.List[str],
+ prefix: str, env: 'Environment', *,
+ extra_args: T.Union[None, T.List[str], T.Callable[[CompileCheckMode], T.List[str]]] = None,
+ dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
if extra_args is None:
extra_args = []
- fargs = {'prefix': prefix, 'type': typename, 'name': 'foo'}
# Create code that accesses all members
members = ''
for member in membernames:
- members += '{}.{};\n'.format(fargs['name'], member)
- fargs['members'] = members
- t = '''{prefix}
+ members += f'foo.{member};\n'
+ t = f'''{prefix}
void bar(void) {{
- {type} {name};
+ {typename} foo;
{members}
- }};'''
- return self.compiles(t.format(**fargs), env, extra_args=extra_args,
+ }}'''
+ return self.compiles(t, env, extra_args=extra_args,
dependencies=dependencies)
- def has_type(self, typename, prefix, env, extra_args, dependencies=None):
- fargs = {'prefix': prefix, 'type': typename}
- t = '''{prefix}
+ def has_type(self, typename: str, prefix: str, env: 'Environment',
+ extra_args: T.Union[T.List[str], T.Callable[[CompileCheckMode], T.List[str]]], *,
+ dependencies: T.Optional[T.List['Dependency']] = None) -> T.Tuple[bool, bool]:
+ t = f'''{prefix}
void bar(void) {{
- sizeof({type});
- }};'''
- return self.compiles(t.format(**fargs), env, extra_args=extra_args,
+ sizeof({typename});
+ }}'''
+ return self.compiles(t, env, extra_args=extra_args,
dependencies=dependencies)
- def symbols_have_underscore_prefix(self, env):
+ def symbols_have_underscore_prefix(self, env: 'Environment') -> bool:
'''
Check if the compiler prefixes an underscore to global C symbols
'''
@@ -789,15 +913,13 @@
}
#endif
'''
- args = self.get_compiler_check_args()
+ args = self.get_compiler_check_args(CompileCheckMode.COMPILE)
n = 'symbols_have_underscore_prefix'
with self._build_wrapper(code, env, extra_args=args, mode='compile', want_output=True, temp_dir=env.scratch_dir) as p:
if p.returncode != 0:
- m = 'BUG: Unable to compile {!r} check: {}'
- raise RuntimeError(m.format(n, p.stdo))
+ raise RuntimeError(f'BUG: Unable to compile {n!r} check: {p.stdout}')
if not os.path.isfile(p.output_name):
- m = 'BUG: Can\'t find compiled test code for {!r} check'
- raise RuntimeError(m.format(n))
+ raise RuntimeError(f'BUG: Can\'t find compiled test code for {n!r} check')
with open(p.output_name, 'rb') as o:
for line in o:
# Check if the underscore form of the symbol is somewhere
@@ -809,10 +931,10 @@
elif symbol_name in line:
mlog.debug("Symbols have underscore prefix: NO")
return False
- raise RuntimeError('BUG: {!r} check failed unexpectedly'.format(n))
+ raise RuntimeError(f'BUG: {n!r} check failed unexpectedly')
- def _get_patterns(self, env, prefixes, suffixes, shared=False):
- patterns = []
+ def _get_patterns(self, env: 'Environment', prefixes: T.List[str], suffixes: T.List[str], shared: bool = False) -> T.List[str]:
+ patterns = [] # type: T.List[str]
for p in prefixes:
for s in suffixes:
patterns.append(p + '{}.' + s)
@@ -828,7 +950,7 @@
patterns.append(p + '{}.so.[0-9]*.[0-9]*')
return patterns
- def get_library_naming(self, env, libtype: LibType, strict=False):
+ def get_library_naming(self, env: 'Environment', libtype: LibType, strict: bool = False) -> T.Tuple[str, ...]:
'''
Get library prefixes and suffixes for the target platform ordered by
priority
@@ -875,8 +997,8 @@
return tuple(patterns)
@staticmethod
- def _sort_shlibs_openbsd(libs):
- filtered = []
+ def _sort_shlibs_openbsd(libs: T.List[str]) -> T.List[str]:
+ filtered = [] # type: T.List[str]
for lib in libs:
# Validate file as a shared library of type libfoo.so.X.Y
ret = lib.rsplit('.so.', maxsplit=1)
@@ -891,7 +1013,7 @@
return sorted(filtered, key=float_cmp, reverse=True)
@classmethod
- def _get_trials_from_pattern(cls, pattern, directory, libname):
+ def _get_trials_from_pattern(cls, pattern: str, directory: str, libname: str) -> T.List[Path]:
f = Path(directory) / pattern.format(libname)
# Globbing for OpenBSD
if '*' in pattern:
@@ -901,7 +1023,7 @@
return [f]
@staticmethod
- def _get_file_from_list(env, files: T.List[str]) -> Path:
+ def _get_file_from_list(env: 'Environment', paths: T.List[Path]) -> Path:
'''
We just check whether the library exists. We can't do a link check
because the library might have unresolved symbols that require other
@@ -909,31 +1031,29 @@
architecture.
'''
# If not building on macOS for Darwin, do a simple file check
- files = [Path(f) for f in files]
if not env.machines.host.is_darwin() or not env.machines.build.is_darwin():
- for f in files:
- if f.is_file():
- return f
+ for p in paths:
+ if p.is_file():
+ return p
# Run `lipo` and check if the library supports the arch we want
- for f in files:
- if not f.is_file():
+ for p in paths:
+ if not p.is_file():
continue
- archs = mesonlib.darwin_get_object_archs(f)
+ archs = mesonlib.darwin_get_object_archs(str(p))
if archs and env.machines.host.cpu_family in archs:
- return f
+ return p
else:
- mlog.debug('Rejected {}, supports {} but need {}'
- .format(f, archs, env.machines.host.cpu_family))
+ mlog.debug(f'Rejected {p}, supports {archs} but need {env.machines.host.cpu_family}')
return None
@functools.lru_cache()
- def output_is_64bit(self, env):
+ def output_is_64bit(self, env: 'Environment') -> bool:
'''
returns true if the output produced is 64-bit, false if 32-bit
'''
return self.sizeof('void *', '', env) == 8
- def find_library_real(self, libname, env, extra_dirs, code, libtype: LibType):
+ def _find_library_real(self, libname: str, env: 'Environment', extra_dirs: T.List[str], code: str, libtype: LibType) -> T.Optional[T.List[str]]:
# First try if we can just add the library as -l.
# Gcc + co seem to prefer builtin lib dirs to -L dirs.
# Only try to find std libs if no extra dirs specified.
@@ -942,7 +1062,7 @@
if ((not extra_dirs and libtype is LibType.PREFER_SHARED) or
libname in self.internal_libs):
cargs = ['-l' + libname]
- largs = self.get_allow_undefined_link_args()
+ largs = self.get_linker_always_args() + self.get_allow_undefined_link_args()
extra_args = cargs + self.linker_to_compiler_args(largs)
if self.links(code, env, extra_args=extra_args, disable_cache=True)[0]:
@@ -966,16 +1086,17 @@
# Search in the specified dirs, and then in the system libraries
for d in itertools.chain(extra_dirs, self.get_library_dirs(env, elf_class)):
for p in patterns:
- trial = self._get_trials_from_pattern(p, d, libname)
- if not trial:
+ trials = self._get_trials_from_pattern(p, d, libname)
+ if not trials:
continue
- trial = self._get_file_from_list(env, trial)
+ trial = self._get_file_from_list(env, trials)
if not trial:
continue
return [trial.as_posix()]
return None
- def find_library_impl(self, libname, env, extra_dirs, code, libtype: LibType):
+ def _find_library_impl(self, libname: str, env: 'Environment', extra_dirs: T.List[str],
+ code: str, libtype: LibType) -> T.Optional[T.List[str]]:
# These libraries are either built-in or invalid
if libname in self.ignore_libs:
return []
@@ -983,24 +1104,26 @@
extra_dirs = [extra_dirs]
key = (tuple(self.exelist), libname, tuple(extra_dirs), code, libtype)
if key not in self.find_library_cache:
- value = self.find_library_real(libname, env, extra_dirs, code, libtype)
+ value = self._find_library_real(libname, env, extra_dirs, code, libtype)
self.find_library_cache[key] = value
else:
value = self.find_library_cache[key]
if value is None:
return None
- return value[:]
+ return value.copy()
- def find_library(self, libname, env, extra_dirs, libtype: LibType = LibType.PREFER_SHARED):
- code = 'int main(void) { return 0; }'
- return self.find_library_impl(libname, env, extra_dirs, code, libtype)
+ def find_library(self, libname: str, env: 'Environment', extra_dirs: T.List[str],
+ libtype: LibType = LibType.PREFER_SHARED) -> T.Optional[T.List[str]]:
+ code = 'int main(void) { return 0; }\n'
+ return self._find_library_impl(libname, env, extra_dirs, code, libtype)
- def find_framework_paths(self, env):
+ def find_framework_paths(self, env: 'Environment') -> T.List[str]:
'''
These are usually /Library/Frameworks and /System/Library/Frameworks,
unless you select a particular macOS SDK with the -isysroot flag.
You can also add to this by setting -F in CFLAGS.
'''
+ # TODO: this really needs to be *AppleClang*, not just any clang.
if self.id != 'clang':
raise mesonlib.MesonException('Cannot find framework path with non-clang compiler')
# Construct the compiler command-line
@@ -1012,7 +1135,7 @@
os_env = os.environ.copy()
os_env['LC_ALL'] = 'C'
_, _, stde = mesonlib.Popen_safe(commands, env=os_env, stdin=subprocess.PIPE)
- paths = []
+ paths = [] # T.List[str]
for line in stde.split('\n'):
if '(framework directory)' not in line:
continue
@@ -1021,7 +1144,7 @@
paths.append(line[:-21].strip())
return paths
- def find_framework_real(self, name, env, extra_dirs, allow_system):
+ def _find_framework_real(self, name: str, env: 'Environment', extra_dirs: T.List[str], allow_system: bool) -> T.Optional[T.List[str]]:
code = 'int main(void) { return 0; }'
link_args = []
for d in extra_dirs:
@@ -1032,80 +1155,88 @@
link_args += ['-framework', name]
if self.links(code, env, extra_args=(extra_args + link_args), disable_cache=True)[0]:
return link_args
+ return None
- def find_framework_impl(self, name, env, extra_dirs, allow_system):
+ def _find_framework_impl(self, name: str, env: 'Environment', extra_dirs: T.List[str],
+ allow_system: bool) -> T.Optional[T.List[str]]:
if isinstance(extra_dirs, str):
extra_dirs = [extra_dirs]
key = (tuple(self.exelist), name, tuple(extra_dirs), allow_system)
if key in self.find_framework_cache:
value = self.find_framework_cache[key]
else:
- value = self.find_framework_real(name, env, extra_dirs, allow_system)
+ value = self._find_framework_real(name, env, extra_dirs, allow_system)
self.find_framework_cache[key] = value
if value is None:
return None
- return value[:]
+ return value.copy()
- def find_framework(self, name, env, extra_dirs, allow_system=True):
+ def find_framework(self, name: str, env: 'Environment', extra_dirs: T.List[str],
+ allow_system: bool = True) -> T.Optional[T.List[str]]:
'''
Finds the framework with the specified name, and returns link args for
the same or returns None when the framework is not found.
'''
- if self.id != 'clang':
- raise mesonlib.MesonException('Cannot find frameworks with non-clang compiler')
- return self.find_framework_impl(name, env, extra_dirs, allow_system)
+ # TODO: should probably check for macOS?
+ return self._find_framework_impl(name, env, extra_dirs, allow_system)
def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+ # TODO: does this belong here or in GnuLike or maybe PosixLike?
return []
def get_crt_link_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+ # TODO: does this belong here or in GnuLike or maybe PosixLike?
return []
- def thread_flags(self, env):
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ # TODO: does this belong here or in GnuLike or maybe PosixLike?
host_m = env.machines[self.for_machine]
if host_m.is_haiku() or host_m.is_darwin():
return []
return ['-pthread']
- def thread_link_flags(self, env: 'Environment') -> T.List[str]:
- return self.linker.thread_flags(env)
+ def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]:
+ return args.copy()
- def linker_to_compiler_args(self, args):
- return args
-
- def has_arguments(self, args, env, code, mode):
+ def has_arguments(self, args: T.List[str], env: 'Environment', code: str,
+ mode: str) -> T.Tuple[bool, bool]:
return self.compiles(code, env, extra_args=args, mode=mode)
- def has_multi_arguments(self, args, env):
- for arg in args[:]:
+ def _has_multi_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
+ new_args = [] # type: T.List[str]
+ for arg in args:
# some compilers, e.g. GCC, don't warn for unsupported warning-disable
# flags, so when we are testing a flag like "-Wno-forgotten-towel", also
# check the equivalent enable flag too "-Wforgotten-towel"
if arg.startswith('-Wno-'):
- args.append('-W' + arg[5:])
+ new_args.append('-W' + arg[5:])
if arg.startswith('-Wl,'):
- mlog.warning('{} looks like a linker argument, '
+ mlog.warning(f'{arg} looks like a linker argument, '
'but has_argument and other similar methods only '
'support checking compiler arguments. Using them '
'to check linker arguments are never supported, '
'and results are likely to be wrong regardless of '
'the compiler you are using. has_link_argument or '
- 'other similar method can be used instead.'
- .format(arg))
- code = 'int i;\n'
- return self.has_arguments(args, env, code, mode='compile')
+ 'other similar method can be used instead.')
+ new_args.append(arg)
+ return self.has_arguments(new_args, env, code, mode='compile')
+
+ def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+ return self._has_multi_arguments(args, env, 'extern int i;\nint i;\n')
- def has_multi_link_arguments(self, args, env):
+ def _has_multi_link_arguments(self, args: T.List[str], env: 'Environment', code: str) -> T.Tuple[bool, bool]:
# First time we check for link flags we need to first check if we have
# --fatal-warnings, otherwise some linker checks could give some
# false positive.
args = self.linker.fatal_warnings() + args
args = self.linker_to_compiler_args(args)
- code = 'int main(void) { return 0; }'
return self.has_arguments(args, env, code, mode='link')
+ def has_multi_link_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+ return self._has_multi_link_arguments(args, env, 'int main(void) { return 0; }\n')
+
@staticmethod
- def concatenate_string_literals(s):
+ def _concatenate_string_literals(s: str) -> str:
pattern = re.compile(r'(?P.*([^\\]")|^")(?P([^\\"]|\\.)*)"\s+"(?P([^\\"]|\\.)*)(?P".*)')
ret = s
m = pattern.match(ret)
@@ -1114,7 +1245,13 @@
m = pattern.match(ret)
return ret
- def has_func_attribute(self, name, env):
+ def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]:
+ # Most compilers (such as GCC and Clang) only warn about unknown or
+ # ignored attributes, so force an error. Overridden in GCC and Clang
+ # mixins.
+ return ['-Werror']
+
+ def has_func_attribute(self, name: str, env: 'Environment') -> T.Tuple[bool, bool]:
# Just assume that if we're not on windows that dllimport and dllexport
# don't work
m = env.machines[self.for_machine]
@@ -1122,6 +1259,8 @@
if name in ['dllimport', 'dllexport']:
return False, False
- # Clang and GCC both return warnings if the __attribute__ is undefined,
- # so set -Werror
- return self.compiles(self.attribute_check_func(name), env, extra_args='-Werror')
+ return self.compiles(self.attribute_check_func(name), env,
+ extra_args=self.get_has_func_attribute_extra_args(name))
+
+ def get_disable_assert_args(self) -> T.List[str]:
+ return ['-DNDEBUG']
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/compcert.py meson-0.61.2/mesonbuild/compilers/mixins/compcert.py
--- meson-0.53.2/mesonbuild/compilers/mixins/compcert.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/compcert.py 2022-01-17 10:50:45.000000000 +0000
@@ -0,0 +1,131 @@
+# Copyright 2012-2019 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.
+
+"""Representations specific to the CompCert C compiler family."""
+
+import os
+import re
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ...environment import Environment
+ from ...compilers.compilers import Compiler
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
+
+ccomp_buildtype_args = {
+ 'plain': [''],
+ 'debug': ['-O0', '-g'],
+ 'debugoptimized': ['-O0', '-g'],
+ 'release': ['-03'],
+ 'minsize': ['-Os'],
+ 'custom': ['-Obranchless'],
+} # type: T.Dict[str, T.List[str]]
+
+ccomp_optimization_args = {
+ '0': ['-O0'],
+ 'g': ['-O0'],
+ '1': ['-O1'],
+ '2': ['-O2'],
+ '3': ['-O3'],
+ 's': ['-Os']
+} # type: T.Dict[str, T.List[str]]
+
+ccomp_debug_args = {
+ False: [],
+ True: ['-g']
+} # type: T.Dict[bool, T.List[str]]
+
+# As of CompCert 20.04, these arguments should be passed to the underlying gcc linker (via -WUl,)
+# There are probably (many) more, but these are those used by picolibc
+ccomp_args_to_wul = [
+ r"^-ffreestanding$",
+ r"^-r$"
+] # type: T.List[str]
+
+class CompCertCompiler(Compiler):
+
+ def __init__(self) -> None:
+ self.id = 'ccomp'
+ # Assembly
+ self.can_compile_suffixes.add('s')
+ default_warn_args = [] # type: T.List[str]
+ self.warn_args = {'0': [],
+ '1': default_warn_args,
+ '2': default_warn_args + [],
+ '3': default_warn_args + []} # type: T.Dict[str, T.List[str]]
+
+ def get_always_args(self) -> T.List[str]:
+ return []
+
+ def get_pic_args(self) -> T.List[str]:
+ # As of now, CompCert does not support PIC
+ return []
+
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ return ccomp_buildtype_args[buildtype]
+
+ def get_pch_suffix(self) -> str:
+ return 'pch'
+
+ def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+ return []
+
+ def unix_args_to_native(self, args: T.List[str]) -> T.List[str]:
+ "Always returns a copy that can be independently mutated"
+ patched_args = [] # type: T.List[str]
+ for arg in args:
+ added = 0
+ for ptrn in ccomp_args_to_wul:
+ if re.match(ptrn, arg):
+ patched_args.append('-WUl,' + arg)
+ added = 1
+ if not added:
+ patched_args.append(arg)
+ return patched_args
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ return []
+
+ def get_preprocess_only_args(self) -> T.List[str]:
+ return ['-E']
+
+ def get_compile_only_args(self) -> T.List[str]:
+ return ['-c']
+
+ def get_coverage_args(self) -> T.List[str]:
+ return []
+
+ def get_no_stdinc_args(self) -> T.List[str]:
+ return ['-nostdinc']
+
+ def get_no_stdlib_link_args(self) -> T.List[str]:
+ return ['-nostdlib']
+
+ def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+ return ccomp_optimization_args[optimization_level]
+
+ def get_debug_args(self, is_debug: bool) -> T.List[str]:
+ return ccomp_debug_args[is_debug]
+
+ def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str], build_dir: str) -> T.List[str]:
+ for idx, i in enumerate(parameter_list):
+ if i[:9] == '-I':
+ parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
+
+ return parameter_list
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/elbrus.py meson-0.61.2/mesonbuild/compilers/mixins/elbrus.py
--- meson-0.53.2/mesonbuild/compilers/mixins/elbrus.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/elbrus.py 2022-01-17 10:50:45.000000000 +0000
@@ -21,21 +21,26 @@
from .gnu import GnuLikeCompiler
from .gnu import gnu_optimization_args
-from ...mesonlib import Popen_safe
+from ...mesonlib import Popen_safe, OptionKey
if T.TYPE_CHECKING:
from ...environment import Environment
+ from ...coredata import KeyedOptionDictType
class ElbrusCompiler(GnuLikeCompiler):
# Elbrus compiler is nearly like GCC, but does not support
# PCH, LTO, sanitizers and color output as of version 1.21.x.
- def __init__(self):
+
+ def __init__(self) -> None:
super().__init__()
self.id = 'lcc'
- self.base_options = ['b_pgo', 'b_coverage',
- 'b_ndebug', 'b_staticpic',
- 'b_lundef', 'b_asneeded']
+ self.base_options = {OptionKey(o) for o in ['b_pgo', 'b_coverage', 'b_ndebug', 'b_staticpic', 'b_lundef', 'b_asneeded']}
+ default_warn_args = ['-Wall']
+ self.warn_args = {'0': [],
+ '1': default_warn_args,
+ '2': default_warn_args + ['-Wextra'],
+ '3': default_warn_args + ['-Wextra', '-Wpedantic']}
# FIXME: use _build_wrapper to call this so that linker flags from the env
# get applied
@@ -75,9 +80,19 @@
def get_optimization_args(self, optimization_level: str) -> T.List[str]:
return gnu_optimization_args[optimization_level]
+ def get_prelink_args(self, prelink_name: str, obj_list: T.List[str]) -> T.List[str]:
+ return ['-r', '-nodefaultlibs', '-nostartfiles', '-o', prelink_name] + obj_list
+
def get_pch_suffix(self) -> str:
# Actually it's not supported for now, but probably will be supported in future
return 'pch'
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', lang=self.language, machine=self.for_machine)]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
def openmp_flags(self) -> T.List[str]:
return ['-fopenmp']
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/emscripten.py meson-0.61.2/mesonbuild/compilers/mixins/emscripten.py
--- meson-0.53.2/mesonbuild/compilers/mixins/emscripten.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/emscripten.py 2021-11-02 19:58:07.000000000 +0000
@@ -17,22 +17,35 @@
import os.path
import typing as T
-from ...mesonlib import MesonException
-
-class EmscriptenMixin:
- def get_option_link_args(self, options):
- return []
-
- def get_soname_args(self, *args, **kwargs):
- raise MesonException('Emscripten does not support shared libraries.')
-
- def get_allow_undefined_link_args(self) -> T.List[str]:
- return ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=0']
+from ... import coredata
+from ... import mesonlib
+from ...mesonlib import OptionKey
+from ...mesonlib import LibType
+
+if T.TYPE_CHECKING:
+ from ...environment import Environment
+ from ...compilers.compilers import Compiler
+ from ...dependencies import Dependency
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
+
+
+def wrap_js_includes(args: T.List[str]) -> T.List[str]:
+ final_args = []
+ for i in args:
+ if i.endswith('.js') and not i.startswith('-'):
+ final_args += ['--js-library', i]
+ else:
+ final_args += [i]
+ return final_args
- def get_linker_output_args(self, output: str) -> T.List[str]:
- return ['-o', output]
+class EmscriptenMixin(Compiler):
- def _get_compile_output(self, dirname, mode):
+ def _get_compile_output(self, dirname: str, mode: str) -> str:
# In pre-processor mode, the output is sent to stdout and discarded
if mode == 'preprocess':
return None
@@ -42,5 +55,49 @@
if mode == 'link':
suffix = 'js'
else:
- suffix = 'wasm'
+ suffix = 'o'
return os.path.join(dirname, 'output.' + suffix)
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ return ['-s', 'USE_PTHREADS=1']
+
+ def thread_link_flags(self, env: 'Environment') -> T.List[str]:
+ args = ['-s', 'USE_PTHREADS=1']
+ count: int = env.coredata.options[OptionKey('thread_count', lang=self.language, machine=self.for_machine)].value
+ if count:
+ args.extend(['-s', f'PTHREAD_POOL_SIZE={count}'])
+ return args
+
+ def get_options(self) -> 'coredata.KeyedOptionDictType':
+ opts = super().get_options()
+ key = OptionKey('thread_count', machine=self.for_machine, lang=self.language)
+ opts.update({
+ key: coredata.UserIntegerOption(
+ 'Number of threads to use in web assembly, set to 0 to disable',
+ (0, None, 4), # Default was picked at random
+ ),
+ })
+
+ return opts
+
+ @classmethod
+ def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]:
+ return wrap_js_includes(super().native_args_to_unix(args))
+
+ def get_dependency_link_args(self, dep: 'Dependency') -> T.List[str]:
+ return wrap_js_includes(super().get_dependency_link_args(dep))
+
+ def find_library(self, libname: str, env: 'Environment', extra_dirs: T.List[str],
+ libtype: LibType = LibType.PREFER_SHARED) -> T.Optional[T.List[str]]:
+ if not libname.endswith('.js'):
+ return super().find_library(libname, env, extra_dirs, libtype)
+ if os.path.isabs(libname):
+ if os.path.exists(libname):
+ return [libname]
+ if len(extra_dirs) == 0:
+ raise mesonlib.EnvironmentException('Looking up Emscripten JS libraries requires either an absolute path or specifying extra_dirs.')
+ for d in extra_dirs:
+ abs_path = os.path.join(d, libname)
+ if os.path.exists(abs_path):
+ return [abs_path]
+ return None
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/gnu.py meson-0.61.2/mesonbuild/compilers/mixins/gnu.py
--- meson-0.53.2/mesonbuild/compilers/mixins/gnu.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/gnu.py 2022-01-17 10:50:45.000000000 +0000
@@ -17,6 +17,7 @@
import abc
import functools
import os
+import multiprocessing
import pathlib
import re
import subprocess
@@ -24,10 +25,18 @@
from ... import mesonlib
from ... import mlog
+from ...mesonlib import OptionKey
if T.TYPE_CHECKING:
- from ...coredata import UserOption # noqa: F401
+ from ..._typing import ImmutableListProtocol
from ...environment import Environment
+ from ..compilers import Compiler
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
# XXX: prevent circular references.
# FIXME: this really is a posix interface not a c-like interface
@@ -84,7 +93,7 @@
@functools.lru_cache(maxsize=None)
-def gnulike_default_include_dirs(compiler: T.Tuple[str], lang: str) -> T.List[str]:
+def gnulike_default_include_dirs(compiler: T.Tuple[str, ...], lang: str) -> 'ImmutableListProtocol[str]':
lang_map = {
'c': 'c',
'cpp': 'c++',
@@ -96,7 +105,7 @@
lang = lang_map[lang]
env = os.environ.copy()
env["LC_ALL"] = 'C'
- cmd = list(compiler) + ['-x{}'.format(lang), '-E', '-v', '-']
+ cmd = list(compiler) + [f'-x{lang}', '-E', '-v', '-']
p = subprocess.Popen(
cmd,
stdin=subprocess.DEVNULL,
@@ -106,7 +115,7 @@
)
stdout = p.stdout.read().decode('utf-8', errors='replace')
parse_state = 0
- paths = []
+ paths = [] # type: T.List[str]
for line in stdout.split('\n'):
line = line.strip(' \n\r\t')
if parse_state == 0:
@@ -129,7 +138,7 @@
return paths
-class GnuLikeCompiler(metaclass=abc.ABCMeta):
+class GnuLikeCompiler(Compiler, metaclass=abc.ABCMeta):
"""
GnuLikeCompiler is a common interface to all compilers implementing
the GNU-style commandline interface. This includes GCC, Clang
@@ -139,13 +148,16 @@
LINKER_PREFIX = '-Wl,'
- def __init__(self):
- self.base_options = ['b_pch', 'b_lto', 'b_pgo', 'b_sanitize', 'b_coverage',
- 'b_ndebug', 'b_staticpic', 'b_pie']
+ def __init__(self) -> None:
+ self.base_options = {
+ OptionKey(o) for o in ['b_pch', 'b_lto', 'b_pgo', 'b_coverage',
+ 'b_ndebug', 'b_staticpic', 'b_pie']}
if not (self.info.is_windows() or self.info.is_cygwin() or self.info.is_openbsd()):
- self.base_options.append('b_lundef')
+ self.base_options.add(OptionKey('b_lundef'))
if not self.info.is_windows() or self.info.is_cygwin():
- self.base_options.append('b_asneeded')
+ self.base_options.add(OptionKey('b_asneeded'))
+ if not self.info.is_hurd():
+ self.base_options.add(OptionKey('b_sanitize'))
# All GCC-like backends can do assembly
self.can_compile_suffixes.add('s')
@@ -162,14 +174,14 @@
@abc.abstractmethod
def get_optimization_args(self, optimization_level: str) -> T.List[str]:
- raise NotImplementedError("get_optimization_args not implemented")
+ pass
def get_debug_args(self, is_debug: bool) -> T.List[str]:
return clike_debug_args[is_debug]
@abc.abstractmethod
def get_pch_suffix(self) -> str:
- raise NotImplementedError("get_pch_suffix not implemented")
+ pass
def split_shlib_to_parts(self, fname: str) -> T.Tuple[str, str]:
return os.path.dirname(fname), fname
@@ -178,11 +190,11 @@
return gnulike_instruction_set_args.get(instruction_set, None)
def get_default_include_dirs(self) -> T.List[str]:
- return gnulike_default_include_dirs(tuple(self.exelist), self.language)
+ return gnulike_default_include_dirs(tuple(self.exelist), self.language).copy()
@abc.abstractmethod
def openmp_flags(self) -> T.List[str]:
- raise NotImplementedError("openmp_flags not implemented")
+ pass
def gnu_symbol_visibility_args(self, vistype: str) -> T.List[str]:
return gnu_symbol_visibility_args[vistype]
@@ -207,9 +219,7 @@
return ['-fprofile-use', '-fprofile-correction']
def get_gui_app_args(self, value: bool) -> T.List[str]:
- if self.info.is_windows() or self.info.is_cygwin():
- return ['-mwindows' if value else '-mconsole']
- return []
+ return ['-mwindows' if value else '-mconsole']
def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str], build_dir: str) -> T.List[str]:
for idx, i in enumerate(parameter_list):
@@ -221,12 +231,10 @@
@functools.lru_cache()
def _get_search_dirs(self, env: 'Environment') -> str:
extra_args = ['--print-search-dirs']
- stdo = None
with self._build_wrapper('', env, extra_args=extra_args,
dependencies=None, mode='compile',
want_output=True) as p:
- stdo = p.stdo
- return stdo
+ return p.stdout
def _split_fetch_real_dirs(self, pathstr: str) -> T.List[str]:
# We need to use the path separator used by the compiler for printing
@@ -275,7 +283,9 @@
return self._split_fetch_real_dirs(line.split('=', 1)[1])
return []
- def get_lto_compile_args(self) -> T.List[str]:
+ def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]:
+ # This provides a base for many compilers, GCC and Clang override this
+ # for their specific arguments
return ['-flto']
def sanitizer_compile_args(self, value: str) -> T.List[str]:
@@ -289,7 +299,7 @@
def get_output_args(self, target: str) -> T.List[str]:
return ['-o', target]
- def get_dependency_gen_args(self, outtarget, outfile):
+ def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
return ['-MD', '-MQ', outtarget, '-MF', outfile]
def get_compile_only_args(self) -> T.List[str]:
@@ -304,7 +314,13 @@
@classmethod
def use_linker_args(cls, linker: str) -> T.List[str]:
- return ['-fuse-ld={}'.format(linker)]
+ if linker not in {'gold', 'bfd', 'lld'}:
+ raise mesonlib.MesonException(
+ f'Unsupported linker, only bfd, gold, and lld are supported, not {linker}.')
+ return [f'-fuse-ld={linker}']
+
+ def get_coverage_args(self) -> T.List[str]:
+ return ['--coverage']
class GnuCompiler(GnuLikeCompiler):
@@ -313,11 +329,11 @@
Compilers imitating GCC (Clang/Intel) should use the GnuLikeCompiler ABC.
"""
- def __init__(self, defines: T.Dict[str, str]):
+ def __init__(self, defines: T.Optional[T.Dict[str, str]]):
super().__init__()
self.id = 'gcc'
self.defines = defines or {}
- self.base_options.append('b_colorout')
+ self.base_options.update({OptionKey('b_colorout'), OptionKey('b_lto_threads')})
def get_colorout_args(self, colortype: str) -> T.List[str]:
if mesonlib.version_compare(self.version, '>=4.9.0'):
@@ -325,6 +341,7 @@
return []
def get_warn_args(self, level: str) -> T.List[str]:
+ # Mypy doesn't understand cooperative inheritance
args = super().get_warn_args(level)
if mesonlib.version_compare(self.version, '<4.8.0') and '-Wpedantic' in args:
# -Wpedantic was added in 4.8.0
@@ -349,14 +366,33 @@
def openmp_flags(self) -> T.List[str]:
return ['-fopenmp']
- def has_arguments(self, args, env, code, mode):
+ def has_arguments(self, args: T.List[str], env: 'Environment', code: str,
+ mode: str) -> T.Tuple[bool, bool]:
# For some compiler command line arguments, the GNU compilers will
# emit a warning on stderr indicating that an option is valid for a
# another language, but still complete with exit_success
- with self._build_wrapper(code, env, args, None, mode, disable_cache=False, want_output=True) as p:
+ with self._build_wrapper(code, env, args, None, mode) as p:
result = p.returncode == 0
- if self.language in {'cpp', 'objcpp'} and 'is valid for C/ObjC' in p.stde:
+ if self.language in {'cpp', 'objcpp'} and 'is valid for C/ObjC' in p.stderr:
result = False
- if self.language in {'c', 'objc'} and 'is valid for C++/ObjC++' in p.stde:
+ if self.language in {'c', 'objc'} and 'is valid for C++/ObjC++' in p.stderr:
result = False
return result, p.cached
+
+ def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]:
+ # GCC only warns about unknown or ignored attributes, so force an
+ # error.
+ return ['-Werror=attributes']
+
+ def get_prelink_args(self, prelink_name: str, obj_list: T.List[str]) -> T.List[str]:
+ return ['-r', '-o', prelink_name] + obj_list
+
+ def get_lto_compile_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]:
+ if threads == 0:
+ if mesonlib.version_compare(self.version, '>= 10.0'):
+ return ['-flto=auto']
+ # This matches clang's behavior of using the number of cpus
+ return [f'-flto={multiprocessing.cpu_count()}']
+ elif threads > 0:
+ return [f'-flto={threads}']
+ return super().get_lto_compile_args(threads=threads)
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/intel.py meson-0.61.2/mesonbuild/compilers/mixins/intel.py
--- meson-0.53.2/mesonbuild/compilers/mixins/intel.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/intel.py 2022-01-17 10:50:45.000000000 +0000
@@ -24,12 +24,10 @@
import typing as T
from ... import mesonlib
+from ..compilers import CompileCheckMode
from .gnu import GnuLikeCompiler
from .visualstudio import VisualStudioLikeCompiler
-if T.TYPE_CHECKING:
- import subprocess # noqa: F401
-
# XXX: avoid circular dependencies
# TODO: this belongs in a posix compiler class
# NOTE: the default Intel optimization is -O2, unlike GNU which defaults to -O0.
@@ -69,15 +67,16 @@
's': ['-Os'],
}
- def __init__(self):
+ def __init__(self) -> None:
super().__init__()
# As of 19.0.0 ICC doesn't have sanitizer, color, or lto support.
#
# It does have IPO, which serves much the same purpose as LOT, but
# there is an unfortunate rule for using IPO (you can't control the
# name of the output file) which break assumptions meson makes
- self.base_options = ['b_pch', 'b_lundef', 'b_asneeded', 'b_pgo',
- 'b_coverage', 'b_ndebug', 'b_staticpic', 'b_pie']
+ self.base_options = {mesonlib.OptionKey(o) for o in [
+ 'b_pch', 'b_lundef', 'b_asneeded', 'b_pgo', 'b_coverage',
+ 'b_ndebug', 'b_staticpic', 'b_pie']}
self.id = 'intel'
self.lang_header = 'none'
@@ -97,21 +96,16 @@
else:
return ['-openmp']
- def compiles(self, *args, **kwargs) -> T.Tuple[bool, bool]:
- # This covers a case that .get('foo', []) doesn't, that extra_args is
- # defined and is None
- extra_args = kwargs.get('extra_args') or []
- kwargs['extra_args'] = [
- extra_args,
+ def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
+ extra_args = [
'-diag-error', '10006', # ignoring unknown option
'-diag-error', '10148', # Option not supported
'-diag-error', '10155', # ignoring argument required
'-diag-error', '10156', # ignoring not argument allowed
'-diag-error', '10157', # Ignoring argument of the wrong type
'-diag-error', '10158', # Argument must be separate. Can be hit by trying an option like -foo-bar=foo when -foo=bar is a valid option but -foo-bar isn't
- '-diag-error', '1292', # unknown __attribute__
]
- return super().compiles(*args, **kwargs)
+ return super().get_compiler_check_args(mode) + extra_args
def get_profile_generate_args(self) -> T.List[str]:
return ['-prof-gen=threadsafe']
@@ -125,6 +119,9 @@
def get_optimization_args(self, optimization_level: str) -> T.List[str]:
return self.OPTIM_ARGS[optimization_level]
+ def get_has_func_attribute_extra_args(self, name: str) -> T.List[str]:
+ return ['-diag-error', '1292']
+
class IntelVisualStudioLikeCompiler(VisualStudioLikeCompiler):
@@ -140,23 +137,22 @@
} # type: T.Dict[str, T.List[str]]
OPTIM_ARGS = {
- '0': ['/O0'],
- 'g': ['/O0'],
+ '0': ['/Od'],
+ 'g': ['/Od'],
'1': ['/O1'],
'2': ['/O2'],
'3': ['/O3'],
's': ['/Os'],
}
- def __init__(self, target: str):
+ def __init__(self, target: str) -> None:
super().__init__(target)
self.id = 'intel-cl'
- def compile(self, code, *, extra_args: T.Optional[T.List[str]] = None, **kwargs) -> T.Iterator['subprocess.Popen']:
- # This covers a case that .get('foo', []) doesn't, that extra_args is
- if kwargs.get('mode', 'compile') != 'link':
- extra_args = extra_args.copy() if extra_args is not None else []
- extra_args.extend([
+ def get_compiler_check_args(self, mode: CompileCheckMode) -> T.List[str]:
+ args = super().get_compiler_check_args(mode)
+ if mode is not CompileCheckMode.LINK:
+ args.extend([
'/Qdiag-error:10006', # ignoring unknown option
'/Qdiag-error:10148', # Option not supported
'/Qdiag-error:10155', # ignoring argument required
@@ -164,17 +160,14 @@
'/Qdiag-error:10157', # Ignoring argument of the wrong type
'/Qdiag-error:10158', # Argument must be separate. Can be hit by trying an option like -foo-bar=foo when -foo=bar is a valid option but -foo-bar isn't
])
- return super().compile(code, extra_args, **kwargs)
+ return args
def get_toolset_version(self) -> T.Optional[str]:
- # Avoid circular dependencies....
- from ...environment import search_version
-
# ICL provides a cl.exe that returns the version of MSVC it tries to
# emulate, so we'll get the version from that and pass it to the same
# function the real MSVC uses to calculate the toolset version.
_, _, err = mesonlib.Popen_safe(['cl.exe'])
- v1, v2, *_ = search_version(err).split('.')
+ v1, v2, *_ = mesonlib.search_version(err).split('.')
version = int(v1 + v2)
return self._calculate_toolset_version(version)
@@ -186,3 +179,6 @@
def get_optimization_args(self, optimization_level: str) -> T.List[str]:
return self.OPTIM_ARGS[optimization_level]
+
+ def get_pch_base_name(self, header: str) -> str:
+ return os.path.basename(header)
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/islinker.py meson-0.61.2/mesonbuild/compilers/mixins/islinker.py
--- meson-0.53.2/mesonbuild/compilers/mixins/islinker.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/islinker.py 2022-01-02 20:12:32.000000000 +0000
@@ -20,28 +20,23 @@
classes for those cases.
"""
-import os
import typing as T
-from ... import mesonlib
+from ...mesonlib import EnvironmentException, MesonException, is_windows
if T.TYPE_CHECKING:
- from ...coredata import OptionDictType
+ from ...coredata import KeyedOptionDictType
from ...environment import Environment
+ from ...compilers.compilers import Compiler
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
-class LinkerEnvVarsMixin:
-
- """Mixin reading LDFLAGS from the environment."""
-
- def get_linker_args_from_envvars(self) -> T.List[str]:
- flags = os.environ.get('LDFLAGS')
- if not flags:
- return []
- return mesonlib.split_args(flags)
-
-
-class BasicLinkerIsCompilerMixin:
+class BasicLinkerIsCompilerMixin(Compiler):
"""Provides a baseline of methods that a linker would implement.
@@ -53,11 +48,11 @@
def sanitizer_link_args(self, value: str) -> T.List[str]:
return []
- def get_lto_link_args(self) -> T.List[str]:
+ def get_lto_link_args(self, *, threads: int = 0, mode: str = 'default') -> T.List[str]:
return []
def can_linker_accept_rsp(self) -> bool:
- return mesonlib.is_windows()
+ return is_windows()
def get_linker_exelist(self) -> T.List[str]:
return self.exelist.copy()
@@ -71,7 +66,7 @@
def get_linker_lib_prefix(self) -> str:
return ''
- def get_option_link_args(self, options: 'OptionDictType') -> T.List[str]:
+ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
return []
def has_multi_link_args(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
@@ -83,50 +78,51 @@
def get_std_shared_lib_link_args(self) -> T.List[str]:
return []
- def get_std_shared_module_args(self, options: 'OptionDictType') -> T.List[str]:
+ def get_std_shared_module_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
return self.get_std_shared_lib_link_args()
def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
- raise mesonlib.EnvironmentException(
- 'Linker {} does not support link_whole'.format(self.id))
+ raise EnvironmentException(f'Linker {self.id} does not support link_whole')
def get_allow_undefined_link_args(self) -> T.List[str]:
- raise mesonlib.EnvironmentException(
- 'Linker {} does not support allow undefined'.format(self.id))
+ raise EnvironmentException(f'Linker {self.id} does not support allow undefined')
def get_pie_link_args(self) -> T.List[str]:
- m = 'Linker {} does not support position-independent executable'
- raise mesonlib.EnvironmentException(m.format(self.id))
+ raise EnvironmentException(f'Linker {self.id} does not support position-independent executable')
def get_undefined_link_args(self) -> T.List[str]:
return []
def get_coverage_link_args(self) -> T.List[str]:
- m = "Linker {} doesn't implement coverage data generation.".format(self.id)
- raise mesonlib.EnvironmentException(m)
+ return []
def no_undefined_link_args(self) -> T.List[str]:
return []
def bitcode_args(self) -> T.List[str]:
- raise mesonlib.MesonException("This linker doesn't support bitcode bundles")
+ raise MesonException("This linker doesn't support bitcode bundles")
- def get_soname_args(self, for_machine: 'mesonlib.MachineChoice',
- prefix: str, shlib_name: str, suffix: str, soversion: str,
- darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- raise mesonlib.MesonException("This linker doesn't support soname args")
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str,
+ darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ raise MesonException("This linker doesn't support soname args")
def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ return ([], set())
+
+ def get_asneeded_args(self) -> T.List[str]:
return []
- def get_linker_debug_crt_args(self) -> T.List[str]:
+ def get_buildtype_linker_args(self, buildtype: str) -> T.List[str]:
return []
- def get_asneeded_args(self) -> T.List[str]:
+ def get_link_debugfile_name(self, target: str) -> str:
+ return ''
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
return []
- def get_buildtype_linker_args(self, buildtype: str) -> T.List[str]:
+ def thread_link_flags(self, env: 'Environment') -> T.List[str]:
return []
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/pgi.py meson-0.61.2/mesonbuild/compilers/mixins/pgi.py
--- meson-0.53.2/mesonbuild/compilers/mixins/pgi.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/pgi.py 2022-01-17 10:50:45.000000000 +0000
@@ -19,6 +19,17 @@
from pathlib import Path
from ..compilers import clike_debug_args, clike_optimization_args
+from ...mesonlib import OptionKey
+
+if T.TYPE_CHECKING:
+ from ...environment import Environment
+ from ...compilers.compilers import Compiler
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
pgi_buildtype_args = {
'plain': [],
@@ -30,16 +41,18 @@
} # type: T.Dict[str, T.List[str]]
-class PGICompiler:
- def __init__(self):
- self.base_options = ['b_pch']
+class PGICompiler(Compiler):
+
+ def __init__(self) -> None:
+ self.base_options = {OptionKey('b_pch')}
self.id = 'pgi'
default_warn_args = ['-Minform=inform']
self.warn_args = {'0': [],
'1': default_warn_args,
'2': default_warn_args,
- '3': default_warn_args}
+ '3': default_warn_args
+ } # type: T.Dict[str, T.List[str]]
def get_module_incdir_args(self) -> T.Tuple[str]:
return ('-module', )
@@ -74,9 +87,6 @@
parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
return parameter_list
- def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
- return []
-
def get_always_args(self) -> T.List[str]:
return []
@@ -90,10 +100,10 @@
if self.language == 'cpp':
return ['--pch',
'--pch_dir', str(hdr.parent),
- '-I{}'.format(hdr.parent)]
+ f'-I{hdr.parent}']
else:
return []
- def thread_flags(self, env):
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
# PGI cannot accept -pthread, it's already threaded
return []
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/visualstudio.py meson-0.61.2/mesonbuild/compilers/mixins/visualstudio.py
--- meson-0.53.2/mesonbuild/compilers/mixins/visualstudio.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/visualstudio.py 2022-01-17 10:50:45.000000000 +0000
@@ -20,11 +20,20 @@
import os
import typing as T
+from ... import arglist
from ... import mesonlib
from ... import mlog
if T.TYPE_CHECKING:
from ...environment import Environment
+ from ...dependencies import Dependency
+ from .clike import CLikeCompiler as Compiler
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
vs32_instruction_set_args = {
'mmx': ['/arch:SSE'], # There does not seem to be a flag just for MMX
@@ -52,31 +61,22 @@
'neon': None,
} # T.Dicst[str, T.Optional[T.List[str]]]
-msvc_buildtype_args = {
- 'plain': [],
- 'debug': ["/ZI", "/Ob0", "/Od", "/RTC1"],
- 'debugoptimized': ["/Zi", "/Ob1"],
- 'release': ["/Ob2", "/Gw"],
- 'minsize': ["/Zi", "/Gw"],
- 'custom': [],
-} # type: T.Dict[str, T.List[str]]
-
msvc_optimization_args = {
- '0': [],
- 'g': ['/O0'],
+ '0': ['/Od'],
+ 'g': [], # No specific flag to optimize debugging, /Zi or /ZI will create debug information
'1': ['/O1'],
'2': ['/O2'],
- '3': ['/O2'],
- 's': ['/O1'], # Implies /Os.
+ '3': ['/O2', '/Gw'],
+ 's': ['/O1', '/Gw'],
} # type: T.Dict[str, T.List[str]]
msvc_debug_args = {
False: [],
- True: [] # Fixme!
+ True: ['/Zi']
} # type: T.Dict[bool, T.List[str]]
-class VisualStudioLikeCompiler(metaclass=abc.ABCMeta):
+class VisualStudioLikeCompiler(Compiler, metaclass=abc.ABCMeta):
"""A common interface for all compilers implementing an MSVC-style
interface.
@@ -88,10 +88,8 @@
std_warn_args = ['/W3']
std_opt_args = ['/O2']
- # XXX: this is copied in this patch only to avoid circular dependencies
- #ignore_libs = unixy_compiler_internal_libs
- ignore_libs = ('m', 'c', 'pthread', 'dl', 'rt', 'execinfo')
- internal_libs = ()
+ ignore_libs = arglist.UNIXY_COMPILER_INTERNAL_LIBS + ['execinfo']
+ internal_libs = [] # type: T.List[str]
crt_args = {
'none': [],
@@ -103,9 +101,11 @@
# /showIncludes is needed for build dependency tracking in Ninja
# See: https://ninja-build.org/manual.html#_deps
- always_args = ['/nologo', '/showIncludes']
+ # Assume UTF-8 sources by default, but self.unix_args_to_native() removes it
+ # if `/source-charset` is set too.
+ always_args = ['/nologo', '/showIncludes', '/utf-8']
warn_args = {
- '0': ['/W1'],
+ '0': [],
'1': ['/W2'],
'2': ['/W3'],
'3': ['/W4'],
@@ -114,7 +114,7 @@
INVOKES_LINKER = False
def __init__(self, target: str):
- self.base_options = ['b_pch', 'b_ndebug', 'b_vscrt'] # FIXME add lto, pgo and the like
+ self.base_options = {mesonlib.OptionKey(o) for o in ['b_pch', 'b_ndebug', 'b_vscrt']} # FIXME add lto, pgo and the like
self.target = target
self.is_64 = ('x64' in target) or ('x86_64' in target)
# do some canonicalization of target machine
@@ -122,20 +122,21 @@
self.machine = 'x64'
elif '86' in target:
self.machine = 'x86'
+ elif 'aarch64' in target:
+ self.machine = 'arm64'
+ elif 'arm' in target:
+ self.machine = 'arm'
else:
self.machine = target
+ if mesonlib.version_compare(self.version, '>=19.28.29910'): # VS 16.9.0 includes cl 19.28.29910
+ self.base_options.add(mesonlib.OptionKey('b_sanitize'))
+ assert self.linker is not None
self.linker.machine = self.machine
# Override CCompiler.get_always_args
def get_always_args(self) -> T.List[str]:
return self.always_args
- def get_buildtype_args(self, buildtype: str) -> T.List[str]:
- args = msvc_buildtype_args[buildtype]
- if self.id == 'msvc' and mesonlib.version_compare(self.version, '<18.0'):
- args = [arg for arg in args if arg != '/Gw']
- return args
-
def get_pch_suffix(self) -> str:
return 'pch'
@@ -145,10 +146,12 @@
pchname = '.'.join(chopped)
return pchname
+ def get_pch_base_name(self, header: str) -> str:
+ # This needs to be implemented by inheriting classes
+ raise NotImplementedError
+
def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
- base = os.path.basename(header)
- if self.id == 'clang-cl':
- base = header
+ base = self.get_pch_base_name(header)
pchname = self.get_pch_name(header)
return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)]
@@ -159,33 +162,35 @@
return ['/c']
def get_no_optimization_args(self) -> T.List[str]:
- return ['/Od']
+ return ['/Od', '/Oi-']
+
+ def sanitizer_compile_args(self, value: str) -> T.List[str]:
+ if value == 'none':
+ return []
+ if value != 'address':
+ raise mesonlib.MesonException('VS only supports address sanitizer at the moment.')
+ return ['/fsanitize=address']
def get_output_args(self, target: str) -> T.List[str]:
if target.endswith('.exe'):
return ['/Fe' + target]
return ['/Fo' + target]
- def get_optimization_args(self, optimization_level: str) -> T.List[str]:
- return msvc_optimization_args[optimization_level]
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ return []
def get_debug_args(self, is_debug: bool) -> T.List[str]:
return msvc_debug_args[is_debug]
- def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
- return []
+ def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+ args = msvc_optimization_args[optimization_level]
+ if mesonlib.version_compare(self.version, '<18.0'):
+ args = [arg for arg in args if arg != '/Gw']
+ return args
def linker_to_compiler_args(self, args: T.List[str]) -> T.List[str]:
return ['/link'] + args
- def get_gui_app_args(self, value: bool) -> T.List[str]:
- # the default is for the linker to guess the subsystem based on presence
- # of main or WinMain symbols, so always be explicit
- if value:
- return ['/SUBSYSTEM:WINDOWS']
- else:
- return ['/SUBSYSTEM:CONSOLE']
-
def get_pic_args(self) -> T.List[str]:
return [] # PIC is handled by the loader on Windows
@@ -200,20 +205,19 @@
objname = os.path.splitext(pchname)[0] + '.obj'
return objname, ['/Yc' + header, '/Fp' + pchname, '/Fo' + objname]
- def gen_import_library_args(self, implibname: str) -> T.List[str]:
- "The name of the outputted import library"
- return ['/IMPLIB:' + implibname]
-
def openmp_flags(self) -> T.List[str]:
return ['/openmp']
+ def openmp_link_flags(self) -> T.List[str]:
+ return []
+
# FIXME, no idea what these should be.
def thread_flags(self, env: 'Environment') -> T.List[str]:
return []
@classmethod
def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
- result = []
+ result: T.List[str] = []
for i in args:
# -mms-bitfields is specific to MinGW-GCC
# -pthread is only valid for GCC
@@ -247,6 +251,13 @@
# -pthread in link flags is only used on Linux
elif i == '-pthread':
continue
+ # cl.exe does not allow specifying both, so remove /utf-8 that we
+ # added automatically in the case the user overrides it manually.
+ elif i.startswith('/source-charset:') or i.startswith('/execution-charset:'):
+ try:
+ result.remove('/utf-8')
+ except ValueError:
+ pass
result.append(i)
return result
@@ -283,37 +294,22 @@
# Visual Studio is special. It ignores some arguments it does not
# understand and you can't tell it to error out on those.
# http://stackoverflow.com/questions/15259720/how-can-i-make-the-microsoft-c-compiler-treat-unknown-flags-as-errors-rather-t
- def has_arguments(self, args: T.List[str], env: 'Environment', code, mode: str) -> T.Tuple[bool, bool]:
+ def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: str) -> T.Tuple[bool, bool]:
warning_text = '4044' if mode == 'link' else '9002'
- if self.id == 'clang-cl' and mode != 'link':
- args = args + ['-Werror=unknown-argument']
with self._build_wrapper(code, env, extra_args=args, mode=mode) as p:
if p.returncode != 0:
return False, p.cached
- return not(warning_text in p.stde or warning_text in p.stdo), p.cached
+ return not(warning_text in p.stderr or warning_text in p.stdout), p.cached
def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.List[str]:
pdbarr = rel_obj.split('.')[:-1]
pdbarr += ['pdb']
args = ['/Fd' + '.'.join(pdbarr)]
- # When generating a PDB file with PCH, all compile commands write
- # to the same PDB file. Hence, we need to serialize the PDB
- # writes using /FS since we do parallel builds. This slows down the
- # build obviously, which is why we only do this when PCH is on.
- # This was added in Visual Studio 2013 (MSVC 18.0). Before that it was
- # always on: https://msdn.microsoft.com/en-us/library/dn502518.aspx
- if pch and self.id == 'msvc' and mesonlib.version_compare(self.version, '>=18.0'):
- args = ['/FS'] + args
return args
def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
if self.is_64:
return vs64_instruction_set_args.get(instruction_set, None)
- if self.id == 'msvc' and self.version.split('.')[0] == '16' and instruction_set == 'avx':
- # VS documentation says that this exists and should work, but
- # it does not. The headers do not contain AVX intrinsics
- # and the can not be called.
- return None
return vs32_instruction_set_args.get(instruction_set, None)
def _calculate_toolset_version(self, version: int) -> T.Optional[str]:
@@ -337,14 +333,12 @@
return '14.1' # (Visual Studio 2017)
elif version < 1930:
return '14.2' # (Visual Studio 2019)
- mlog.warning('Could not find toolset for version {!r}'.format(self.version))
+ elif version < 1940:
+ return '14.3' # (Visual Studio 2022)
+ mlog.warning(f'Could not find toolset for version {self.version!r}')
return None
def get_toolset_version(self) -> T.Optional[str]:
- if self.id == 'clang-cl':
- # I have no idea
- return '14.1'
-
# See boost/config/compiler/visualc.cpp for up to date mapping
try:
version = int(''.join(self.version.split('.')[0:2]))
@@ -360,20 +354,25 @@
def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
if crt_val in self.crt_args:
return self.crt_args[crt_val]
- assert(crt_val == 'from_buildtype')
+ assert crt_val in ['from_buildtype', 'static_from_buildtype']
+ dbg = 'mdd'
+ rel = 'md'
+ if crt_val == 'static_from_buildtype':
+ dbg = 'mtd'
+ rel = 'mt'
# Match what build type flags used to do.
if buildtype == 'plain':
return []
elif buildtype == 'debug':
- return self.crt_args['mdd']
+ return self.crt_args[dbg]
elif buildtype == 'debugoptimized':
- return self.crt_args['md']
+ return self.crt_args[rel]
elif buildtype == 'release':
- return self.crt_args['md']
+ return self.crt_args[rel]
elif buildtype == 'minsize':
- return self.crt_args['md']
+ return self.crt_args[rel]
else:
- assert(buildtype == 'custom')
+ assert buildtype == 'custom'
raise mesonlib.EnvironmentException('Requested C runtime based on buildtype, but buildtype is "custom".')
def has_func_attribute(self, name: str, env: 'Environment') -> T.Tuple[bool, bool]:
@@ -384,6 +383,75 @@
def get_argument_syntax(self) -> str:
return 'msvc'
- @classmethod
- def use_linker_args(cls, linker: str) -> T.List[str]:
- return []
+
+class MSVCCompiler(VisualStudioLikeCompiler):
+
+ """Specific to the Microsoft Compilers."""
+
+ def __init__(self, target: str):
+ super().__init__(target)
+ self.id = 'msvc'
+
+ def get_compile_debugfile_args(self, rel_obj: str, pch: bool = False) -> T.List[str]:
+ args = super().get_compile_debugfile_args(rel_obj, pch)
+ # When generating a PDB file with PCH, all compile commands write
+ # to the same PDB file. Hence, we need to serialize the PDB
+ # writes using /FS since we do parallel builds. This slows down the
+ # build obviously, which is why we only do this when PCH is on.
+ # This was added in Visual Studio 2013 (MSVC 18.0). Before that it was
+ # always on: https://msdn.microsoft.com/en-us/library/dn502518.aspx
+ if pch and mesonlib.version_compare(self.version, '>=18.0'):
+ args = ['/FS'] + args
+ return args
+
+ def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
+ if self.version.split('.')[0] == '16' and instruction_set == 'avx':
+ # VS documentation says that this exists and should work, but
+ # it does not. The headers do not contain AVX intrinsics
+ # and they can not be called.
+ return None
+ return super().get_instruction_set_args(instruction_set)
+
+ def get_pch_base_name(self, header: str) -> str:
+ return os.path.basename(header)
+
+
+class ClangClCompiler(VisualStudioLikeCompiler):
+
+ """Specific to Clang-CL."""
+
+ def __init__(self, target: str):
+ super().__init__(target)
+ self.id = 'clang-cl'
+
+ # Assembly
+ self.can_compile_suffixes.add('s')
+
+ def has_arguments(self, args: T.List[str], env: 'Environment', code: str, mode: str) -> T.Tuple[bool, bool]:
+ if mode != 'link':
+ args = args + ['-Werror=unknown-argument']
+ return super().has_arguments(args, env, code, mode)
+
+ def get_toolset_version(self) -> T.Optional[str]:
+ # XXX: what is the right thing to do here?
+ return '14.1'
+
+ def get_pch_base_name(self, header: str) -> str:
+ return header
+
+ def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+ if path == '':
+ path = '.'
+ return ['/clang:-isystem' + path] if is_system else ['-I' + path]
+
+ def get_dependency_compile_args(self, dep: 'Dependency') -> T.List[str]:
+ if dep.get_include_type() == 'system':
+ converted = []
+ for i in dep.get_compile_args():
+ if i.startswith('-isystem'):
+ converted += ['/clang:' + i]
+ else:
+ converted += [i]
+ return converted
+ else:
+ return dep.get_compile_args()
\ No newline at end of file
diff -Nru meson-0.53.2/mesonbuild/compilers/mixins/xc16.py meson-0.61.2/mesonbuild/compilers/mixins/xc16.py
--- meson-0.53.2/mesonbuild/compilers/mixins/xc16.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/mixins/xc16.py 2022-01-17 10:50:45.000000000 +0000
@@ -0,0 +1,127 @@
+# Copyright 2012-2019 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.
+
+"""Representations specific to the Microchip XC16 C compiler family."""
+
+import os
+import typing as T
+
+from ...mesonlib import EnvironmentException
+
+if T.TYPE_CHECKING:
+ from ...environment import Environment
+ from ...compilers.compilers import Compiler
+else:
+ # This is a bit clever, for mypy we pretend that these mixins descend from
+ # Compiler, so we get all of the methods and attributes defined for us, but
+ # for runtime we make them descend from object (which all classes normally
+ # do). This gives up DRYer type checking, with no runtime impact
+ Compiler = object
+
+xc16_buildtype_args = {
+ 'plain': [],
+ 'debug': [],
+ 'debugoptimized': [],
+ 'release': [],
+ 'minsize': [],
+ 'custom': [],
+} # type: T.Dict[str, T.List[str]]
+
+xc16_optimization_args = {
+ '0': ['-O0'],
+ 'g': ['-O0'],
+ '1': ['-O1'],
+ '2': ['-O2'],
+ '3': ['-O3'],
+ 's': ['-Os']
+} # type: T.Dict[str, T.List[str]]
+
+xc16_debug_args = {
+ False: [],
+ True: []
+} # type: T.Dict[bool, T.List[str]]
+
+
+class Xc16Compiler(Compiler):
+
+ def __init__(self) -> None:
+ if not self.is_cross:
+ raise EnvironmentException('xc16 supports only cross-compilation.')
+ self.id = 'xc16'
+ # Assembly
+ self.can_compile_suffixes.add('s')
+ default_warn_args = [] # type: T.List[str]
+ self.warn_args = {'0': [],
+ '1': default_warn_args,
+ '2': default_warn_args + [],
+ '3': default_warn_args + []} # type: T.Dict[str, T.List[str]]
+
+ def get_always_args(self) -> T.List[str]:
+ return []
+
+ def get_pic_args(self) -> T.List[str]:
+ # PIC support is not enabled by default for xc16,
+ # if users want to use it, they need to add the required arguments explicitly
+ return []
+
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ return xc16_buildtype_args[buildtype]
+
+ def get_pch_suffix(self) -> str:
+ return 'pch'
+
+ def get_pch_use_args(self, pch_dir: str, header: str) -> T.List[str]:
+ return []
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ return []
+
+ def get_coverage_args(self) -> T.List[str]:
+ return []
+
+ def get_no_stdinc_args(self) -> T.List[str]:
+ return ['-nostdinc']
+
+ def get_no_stdlib_link_args(self) -> T.List[str]:
+ return ['--nostdlib']
+
+ def get_optimization_args(self, optimization_level: str) -> T.List[str]:
+ return xc16_optimization_args[optimization_level]
+
+ def get_debug_args(self, is_debug: bool) -> T.List[str]:
+ return xc16_debug_args[is_debug]
+
+ @classmethod
+ def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
+ result = []
+ for i in args:
+ if i.startswith('-D'):
+ i = '-D' + i[2:]
+ if i.startswith('-I'):
+ i = '-I' + i[2:]
+ if i.startswith('-Wl,-rpath='):
+ continue
+ elif i == '--print-search-dirs':
+ continue
+ elif i.startswith('-L'):
+ continue
+ result.append(i)
+ return result
+
+ def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str], build_dir: str) -> T.List[str]:
+ for idx, i in enumerate(parameter_list):
+ if i[:9] == '-I':
+ parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
+
+ return parameter_list
diff -Nru meson-0.53.2/mesonbuild/compilers/objcpp.py meson-0.61.2/mesonbuild/compilers/objcpp.py
--- meson-0.53.2/mesonbuild/compilers/objcpp.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/objcpp.py 2021-11-02 19:58:13.000000000 +0000
@@ -12,10 +12,10 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os.path, subprocess
import typing as T
-from ..mesonlib import EnvironmentException, MachineChoice
+from .. import coredata
+from ..mesonlib import MachineChoice, OptionKey
from .mixins.clike import CLikeCompiler
from .compilers import Compiler
@@ -23,53 +23,43 @@
from .mixins.clang import ClangCompiler
if T.TYPE_CHECKING:
+ from ..programs import ExternalProgram
from ..envconfig import MachineInfo
+ from ..environment import Environment
+ from ..linkers import DynamicLinker
class ObjCPPCompiler(CLikeCompiler, Compiler):
language = 'objcpp'
- def __init__(self, exelist, version, for_machine: MachineChoice,
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
is_cross: bool, info: 'MachineInfo',
- exe_wrap: T.Optional[str], **kwargs):
- Compiler.__init__(self, exelist, version, for_machine, info, **kwargs)
- CLikeCompiler.__init__(self, is_cross, exe_wrap)
+ exe_wrap: T.Optional['ExternalProgram'],
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ Compiler.__init__(self, exelist, version, for_machine, info,
+ is_cross=is_cross, full_version=full_version,
+ linker=linker)
+ CLikeCompiler.__init__(self, exe_wrap)
@staticmethod
- def get_display_language():
+ def get_display_language() -> str:
return 'Objective-C++'
- def sanity_check(self, work_dir, environment):
- # TODO try to use sanity_check_impl instead of duplicated code
- source_name = os.path.join(work_dir, 'sanitycheckobjcpp.mm')
- binary_name = os.path.join(work_dir, 'sanitycheckobjcpp')
- extra_flags = environment.coredata.get_external_args(self.for_machine, self.language)
- if self.is_cross:
- extra_flags += self.get_compile_only_args()
- else:
- extra_flags += environment.coredata.get_external_link_args(self.for_machine, self.language)
- with open(source_name, 'w') as ofile:
- ofile.write('#import\n'
- 'class MyClass;'
- 'int main(void) { return 0; }\n')
- pc = subprocess.Popen(self.exelist + extra_flags + [source_name, '-o', binary_name])
- pc.wait()
- if pc.returncode != 0:
- raise EnvironmentException('ObjC++ compiler %s can not compile programs.' % self.name_string())
- if self.is_cross:
- # Can't check if the binaries run so we have to assume they do
- return
- pe = subprocess.Popen(binary_name)
- pe.wait()
- if pe.returncode != 0:
- raise EnvironmentException('Executables created by ObjC++ compiler %s are not runnable.' % self.name_string())
+ def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+ code = '#import\nclass MyClass;int main(void) { return 0; }\n'
+ return self._sanity_check_impl(work_dir, environment, 'sanitycheckobjcpp.mm', code)
class GnuObjCPPCompiler(GnuCompiler, ObjCPPCompiler):
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo', exe_wrapper=None,
- defines=None, **kwargs):
- ObjCPPCompiler.__init__(self, exelist, version, for_machine, is_cross, info, exe_wrapper, **kwargs)
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ ObjCPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
GnuCompiler.__init__(self, defines)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'0': [],
@@ -79,13 +69,41 @@
class ClangObjCPPCompiler(ClangCompiler, ObjCPPCompiler):
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo', exe_wrapper=None,
- **kwargs):
- ObjCPPCompiler.__init__(self, exelist, version, for_machine, is_cross, info, exe_wrapper, **kwargs)
- ClangCompiler.__init__(self)
+
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ ObjCPPCompiler.__init__(self, exelist, version, for_machine, is_cross,
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ ClangCompiler.__init__(self, defines)
default_warn_args = ['-Wall', '-Winvalid-pch', '-Wnon-virtual-dtor']
self.warn_args = {'0': [],
'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
'3': default_warn_args + ['-Wextra', '-Wpedantic']}
+
+ def get_options(self) -> 'coredata.KeyedOptionDictType':
+ opts = super().get_options()
+ opts.update({
+ OptionKey('std', machine=self.for_machine, lang='cpp'): coredata.UserComboOption(
+ 'C++ language standard to use',
+ ['none', 'c++98', 'c++11', 'c++14', 'c++17', 'gnu++98', 'gnu++11', 'gnu++14', 'gnu++17'],
+ 'none',
+ )
+ })
+ return opts
+
+ def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', machine=self.for_machine, lang='cpp')]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
+
+class AppleClangObjCPPCompiler(ClangObjCPPCompiler):
+
+ """Handle the differences between Apple's clang and vanilla clang."""
diff -Nru meson-0.53.2/mesonbuild/compilers/objc.py meson-0.61.2/mesonbuild/compilers/objc.py
--- meson-0.53.2/mesonbuild/compilers/objc.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/objc.py 2021-10-11 16:26:46.000000000 +0000
@@ -12,10 +12,10 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os.path, subprocess
import typing as T
-from ..mesonlib import EnvironmentException, MachineChoice
+from .. import coredata
+from ..mesonlib import MachineChoice, OptionKey
from .compilers import Compiler
from .mixins.clike import CLikeCompiler
@@ -23,54 +23,44 @@
from .mixins.clang import ClangCompiler
if T.TYPE_CHECKING:
+ from ..programs import ExternalProgram
from ..envconfig import MachineInfo
+ from ..environment import Environment
+ from ..linkers import DynamicLinker
class ObjCCompiler(CLikeCompiler, Compiler):
language = 'objc'
- def __init__(self, exelist, version, for_machine: MachineChoice,
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
is_cross: bool, info: 'MachineInfo',
- exe_wrap: T.Optional[str], **kwargs):
- Compiler.__init__(self, exelist, version, for_machine, info, **kwargs)
- CLikeCompiler.__init__(self, is_cross, exe_wrap)
+ exe_wrap: T.Optional['ExternalProgram'],
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
+ Compiler.__init__(self, exelist, version, for_machine, info,
+ is_cross=is_cross, full_version=full_version,
+ linker=linker)
+ CLikeCompiler.__init__(self, exe_wrap)
@staticmethod
- def get_display_language():
+ def get_display_language() -> str:
return 'Objective-C'
- def sanity_check(self, work_dir, environment):
- # TODO try to use sanity_check_impl instead of duplicated code
- source_name = os.path.join(work_dir, 'sanitycheckobjc.m')
- binary_name = os.path.join(work_dir, 'sanitycheckobjc')
- extra_flags = environment.coredata.get_external_args(self.for_machine, self.language)
- if self.is_cross:
- extra_flags += self.get_compile_only_args()
- else:
- extra_flags += environment.coredata.get_external_link_args(self.for_machine, self.language)
- with open(source_name, 'w') as ofile:
- ofile.write('#import\n'
- 'int main(void) { return 0; }\n')
- pc = subprocess.Popen(self.exelist + extra_flags + [source_name, '-o', binary_name])
- pc.wait()
- if pc.returncode != 0:
- raise EnvironmentException('ObjC compiler %s can not compile programs.' % self.name_string())
- if self.is_cross:
- # Can't check if the binaries run so we have to assume they do
- return
- pe = subprocess.Popen(binary_name)
- pe.wait()
- if pe.returncode != 0:
- raise EnvironmentException('Executables created by ObjC compiler %s are not runnable.' % self.name_string())
+ def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
+ code = '#import\nint main(void) { return 0; }\n'
+ return self._sanity_check_impl(work_dir, environment, 'sanitycheckobjc.m', code)
class GnuObjCCompiler(GnuCompiler, ObjCCompiler):
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo', exe_wrapper=None,
- defines=None, **kwargs):
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
ObjCCompiler.__init__(self, exelist, version, for_machine, is_cross,
- info, exe_wrapper, **kwargs)
+ info, exe_wrapper, linker=linker, full_version=full_version)
GnuCompiler.__init__(self, defines)
default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'0': [],
@@ -80,14 +70,39 @@
class ClangObjCCompiler(ClangCompiler, ObjCCompiler):
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo', exe_wrapper=None,
- **kwargs):
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ defines: T.Optional[T.Dict[str, str]] = None,
+ linker: T.Optional['DynamicLinker'] = None,
+ full_version: T.Optional[str] = None):
ObjCCompiler.__init__(self, exelist, version, for_machine, is_cross,
- info, exe_wrapper, **kwargs)
- ClangCompiler.__init__(self)
+ info, exe_wrapper, linker=linker, full_version=full_version)
+ ClangCompiler.__init__(self, defines)
default_warn_args = ['-Wall', '-Winvalid-pch']
self.warn_args = {'0': [],
'1': default_warn_args,
'2': default_warn_args + ['-Wextra'],
'3': default_warn_args + ['-Wextra', '-Wpedantic']}
+
+ def get_options(self) -> 'coredata.KeyedOptionDictType':
+ opts = super().get_options()
+ opts.update({
+ OptionKey('std', machine=self.for_machine, lang='c'): coredata.UserComboOption(
+ 'C language standard to use',
+ ['none', 'c89', 'c99', 'c11', 'c17', 'gnu89', 'gnu99', 'gnu11', 'gnu17'],
+ 'none',
+ )
+ })
+ return opts
+
+ def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
+ args = []
+ std = options[OptionKey('std', machine=self.for_machine, lang='c')]
+ if std.value != 'none':
+ args.append('-std=' + std.value)
+ return args
+
+class AppleClangObjCCompiler(ClangObjCCompiler):
+
+ """Handle the differences between Apple's clang and vanilla clang."""
diff -Nru meson-0.53.2/mesonbuild/compilers/rust.py meson-0.61.2/mesonbuild/compilers/rust.py
--- meson-0.53.2/mesonbuild/compilers/rust.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/rust.py 2022-01-17 10:50:45.000000000 +0000
@@ -13,57 +13,81 @@
# limitations under the License.
import subprocess, os.path
+import textwrap
import typing as T
-from ..mesonlib import EnvironmentException, MachineChoice, Popen_safe
+from .. import coredata
+from ..mesonlib import (
+ EnvironmentException, MachineChoice, MesonException, Popen_safe,
+ OptionKey,
+)
from .compilers import Compiler, rust_buildtype_args, clike_debug_args
if T.TYPE_CHECKING:
+ from ..coredata import KeyedOptionDictType
from ..envconfig import MachineInfo
from ..environment import Environment # noqa: F401
+ from ..linkers import DynamicLinker
+ from ..programs import ExternalProgram
-rust_optimization_args = {'0': [],
- 'g': ['-C', 'opt-level=0'],
- '1': ['-C', 'opt-level=1'],
- '2': ['-C', 'opt-level=2'],
- '3': ['-C', 'opt-level=3'],
- 's': ['-C', 'opt-level=s'],
- }
+
+rust_optimization_args = {
+ '0': [],
+ 'g': ['-C', 'opt-level=0'],
+ '1': ['-C', 'opt-level=1'],
+ '2': ['-C', 'opt-level=2'],
+ '3': ['-C', 'opt-level=3'],
+ 's': ['-C', 'opt-level=s'],
+} # type: T.Dict[str, T.List[str]]
class RustCompiler(Compiler):
# rustc doesn't invoke the compiler itself, it doesn't need a LINKER_PREFIX
language = 'rust'
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo', exe_wrapper=None, **kwargs):
- super().__init__(exelist, version, for_machine, info, **kwargs)
+ _WARNING_LEVELS: T.Dict[str, T.List[str]] = {
+ '0': ['-A', 'warnings'],
+ '1': [],
+ '2': [],
+ '3': ['-W', 'warnings'],
+ }
+
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ full_version: T.Optional[str] = None,
+ linker: T.Optional['DynamicLinker'] = None):
+ super().__init__(exelist, version, for_machine, info,
+ is_cross=is_cross, full_version=full_version,
+ linker=linker)
self.exe_wrapper = exe_wrapper
self.id = 'rustc'
- self.is_cross = is_cross
+ self.base_options.add(OptionKey('b_colorout'))
+ if 'link' in self.linker.id:
+ self.base_options.add(OptionKey('b_vscrt'))
- def needs_static_linker(self):
+ def needs_static_linker(self) -> bool:
return False
- def name_string(self):
- return ' '.join(self.exelist)
-
- def sanity_check(self, work_dir, environment):
+ def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
source_name = os.path.join(work_dir, 'sanity.rs')
output_name = os.path.join(work_dir, 'rusttest')
- with open(source_name, 'w') as ofile:
- ofile.write('''fn main() {
-}
-''')
+ with open(source_name, 'w', encoding='utf-8') as ofile:
+ ofile.write(textwrap.dedent(
+ '''fn main() {
+ }
+ '''))
pc = subprocess.Popen(self.exelist + ['-o', output_name, source_name],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=work_dir)
- stdo, stde = pc.communicate()
- stdo = stdo.decode('utf-8', errors='replace')
- stde = stde.decode('utf-8', errors='replace')
+ _stdo, _stde = pc.communicate()
+ assert isinstance(_stdo, bytes)
+ assert isinstance(_stde, bytes)
+ stdo = _stdo.decode('utf-8', errors='replace')
+ stde = _stde.decode('utf-8', errors='replace')
if pc.returncode != 0:
- raise EnvironmentException('Rust compiler %s can not compile programs.\n%s\n%s' % (
+ raise EnvironmentException('Rust compiler {} can not compile programs.\n{}\n{}'.format(
self.name_string(),
stdo,
stde))
@@ -71,7 +95,7 @@
if self.exe_wrapper is None:
# Can't check if the binaries run so we have to assume they do
return
- cmdlist = self.exe_wrapper + [output_name]
+ cmdlist = self.exe_wrapper.get_command() + [output_name]
else:
cmdlist = [output_name]
pe = subprocess.Popen(cmdlist, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
@@ -79,37 +103,113 @@
if pe.returncode != 0:
raise EnvironmentException('Executables created by Rust compiler %s are not runnable.' % self.name_string())
- def get_dependency_gen_args(self, outfile):
+ def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
return ['--dep-info', outfile]
- def get_buildtype_args(self, buildtype):
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
return rust_buildtype_args[buildtype]
- def get_sysroot(self):
+ def get_sysroot(self) -> str:
cmd = self.exelist + ['--print', 'sysroot']
p, stdo, stde = Popen_safe(cmd)
return stdo.split('\n')[0]
- def get_debug_args(self, is_debug):
+ def get_debug_args(self, is_debug: bool) -> T.List[str]:
return clike_debug_args[is_debug]
- def get_optimization_args(self, optimization_level):
+ def get_optimization_args(self, optimization_level: str) -> T.List[str]:
return rust_optimization_args[optimization_level]
- def compute_parameters_with_absolute_paths(self, parameter_list, build_dir):
+ def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str],
+ build_dir: str) -> T.List[str]:
for idx, i in enumerate(parameter_list):
if i[:2] == '-L':
for j in ['dependency', 'crate', 'native', 'framework', 'all']:
combined_len = len(j) + 3
- if i[:combined_len] == '-L{}='.format(j):
+ if i[:combined_len] == f'-L{j}=':
parameter_list[idx] = i[:combined_len] + os.path.normpath(os.path.join(build_dir, i[combined_len:]))
break
return parameter_list
- def get_std_exe_link_args(self):
- return []
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ return ['-o', outputname]
+
+ @classmethod
+ def use_linker_args(cls, linker: str) -> T.List[str]:
+ return ['-C', f'linker={linker}']
# Rust does not have a use_linker_args because it dispatches to a gcc-like
# C compiler for dynamic linking, as such we invoke the C compiler's
# use_linker_args method instead.
+
+ def get_options(self) -> 'KeyedOptionDictType':
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ return {
+ key: coredata.UserComboOption(
+ 'Rust edition to use',
+ ['none', '2015', '2018', '2021'],
+ 'none',
+ ),
+ }
+
+ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ args = []
+ key = OptionKey('std', machine=self.for_machine, lang=self.language)
+ std = options[key]
+ if std.value != 'none':
+ args.append('--edition=' + std.value)
+ return args
+
+ def get_crt_compile_args(self, crt_val: str, buildtype: str) -> T.List[str]:
+ # Rust handles this for us, we don't need to do anything
+ return []
+
+ def get_colorout_args(self, colortype: str) -> T.List[str]:
+ if colortype in {'always', 'never', 'auto'}:
+ return [f'--color={colortype}']
+ raise MesonException(f'Invalid color type for rust {colortype}')
+
+ def get_linker_always_args(self) -> T.List[str]:
+ args: T.List[str] = []
+ for a in super().get_linker_always_args():
+ args.extend(['-C', f'link-arg={a}'])
+ return args
+
+ def get_werror_args(self) -> T.List[str]:
+ # Use -D warnings, which makes every warning not explicitly allowed an
+ # error
+ return ['-D', 'warnings']
+
+ def get_warn_args(self, level: str) -> T.List[str]:
+ # TODO: I'm not really sure what to put here, Rustc doesn't have warning
+ return self._WARNING_LEVELS[level]
+
+ def get_no_warn_args(self) -> T.List[str]:
+ return self._WARNING_LEVELS["0"]
+
+ def get_pic_args(self) -> T.List[str]:
+ # This defaults to
+ return ['-C', 'relocation-model=pic']
+
+ def get_pie_args(self) -> T.List[str]:
+ # Rustc currently has no way to toggle this, it's controlled by whether
+ # pic is on by rustc
+ return []
+
+
+class ClippyRustCompiler(RustCompiler):
+
+ """Clippy is a linter that wraps Rustc.
+
+ This just provides us a different id
+ """
+
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo',
+ exe_wrapper: T.Optional['ExternalProgram'] = None,
+ full_version: T.Optional[str] = None,
+ linker: T.Optional['DynamicLinker'] = None):
+ super().__init__(exelist, version, for_machine, is_cross, info,
+ exe_wrapper, full_version, linker)
+ self.id = 'clippy-driver rustc'
diff -Nru meson-0.53.2/mesonbuild/compilers/swift.py meson-0.61.2/mesonbuild/compilers/swift.py
--- meson-0.53.2/mesonbuild/compilers/swift.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/swift.py 2022-01-17 10:50:45.000000000 +0000
@@ -21,89 +21,93 @@
if T.TYPE_CHECKING:
from ..envconfig import MachineInfo
+ from ..environment import Environment
+ from ..linkers import DynamicLinker
-swift_optimization_args = {'0': [],
- 'g': [],
- '1': ['-O'],
- '2': ['-O'],
- '3': ['-O'],
- 's': ['-O'],
- }
+swift_optimization_args = {
+ '0': [],
+ 'g': [],
+ '1': ['-O'],
+ '2': ['-O'],
+ '3': ['-O'],
+ 's': ['-O'],
+} # type: T.Dict[str, T.List[str]]
class SwiftCompiler(Compiler):
LINKER_PREFIX = ['-Xlinker']
language = 'swift'
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo', **kwargs):
- super().__init__(exelist, version, for_machine, info, **kwargs)
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo', full_version: T.Optional[str] = None,
+ linker: T.Optional['DynamicLinker'] = None):
+ super().__init__(exelist, version, for_machine, info,
+ is_cross=is_cross, full_version=full_version,
+ linker=linker)
self.version = version
self.id = 'llvm'
- self.is_cross = is_cross
- def name_string(self):
- return ' '.join(self.exelist)
-
- def needs_static_linker(self):
+ def needs_static_linker(self) -> bool:
return True
- def get_werror_args(self):
+ def get_werror_args(self) -> T.List[str]:
return ['--fatal-warnings']
- def get_dependency_gen_args(self, outtarget, outfile):
+ def get_dependency_gen_args(self, outtarget: str, outfile: str) -> T.List[str]:
return ['-emit-dependencies']
- def depfile_for_object(self, objfile):
+ def depfile_for_object(self, objfile: str) -> str:
return os.path.splitext(objfile)[0] + '.' + self.get_depfile_suffix()
- def get_depfile_suffix(self):
+ def get_depfile_suffix(self) -> str:
return 'd'
- def get_output_args(self, target):
+ def get_output_args(self, target: str) -> T.List[str]:
return ['-o', target]
- def get_header_import_args(self, headername):
+ def get_header_import_args(self, headername: str) -> T.List[str]:
return ['-import-objc-header', headername]
- def get_warn_args(self, level):
+ def get_warn_args(self, level: str) -> T.List[str]:
return []
- def get_buildtype_args(self, buildtype):
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
return swift_buildtype_args[buildtype]
- def get_std_exe_link_args(self):
+ def get_std_exe_link_args(self) -> T.List[str]:
return ['-emit-executable']
- def get_module_args(self, modname):
+ def get_module_args(self, modname: str) -> T.List[str]:
return ['-module-name', modname]
- def get_mod_gen_args(self):
+ def get_mod_gen_args(self) -> T.List[str]:
return ['-emit-module']
- def get_include_args(self, dirname):
- return ['-I' + dirname]
+ def get_include_args(self, path: str, is_system: bool) -> T.List[str]:
+ return ['-I' + path]
- def get_compile_only_args(self):
+ def get_compile_only_args(self) -> T.List[str]:
return ['-c']
- def compute_parameters_with_absolute_paths(self, parameter_list, build_dir):
+ def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str],
+ build_dir: str) -> T.List[str]:
for idx, i in enumerate(parameter_list):
if i[:2] == '-I' or i[:2] == '-L':
parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
return parameter_list
- def sanity_check(self, work_dir, environment):
+ def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
src = 'swifttest.swift'
source_name = os.path.join(work_dir, src)
output_name = os.path.join(work_dir, 'swifttest')
- extra_flags = environment.coredata.get_external_args(self.for_machine, self.language)
+ extra_flags: T.List[str] = []
+ extra_flags += environment.coredata.get_external_args(self.for_machine, self.language)
if self.is_cross:
extra_flags += self.get_compile_only_args()
else:
extra_flags += environment.coredata.get_external_link_args(self.for_machine, self.language)
- with open(source_name, 'w') as ofile:
+ with open(source_name, 'w', encoding='utf-8') as ofile:
ofile.write('''print("Swift compilation is working.")
''')
pc = subprocess.Popen(self.exelist + extra_flags + ['-emit-executable', '-o', output_name, src], cwd=work_dir)
@@ -116,8 +120,8 @@
if subprocess.call(output_name) != 0:
raise EnvironmentException('Executables created by Swift compiler %s are not runnable.' % self.name_string())
- def get_debug_args(self, is_debug):
+ def get_debug_args(self, is_debug: bool) -> T.List[str]:
return clike_debug_args[is_debug]
- def get_optimization_args(self, optimization_level):
+ def get_optimization_args(self, optimization_level: str) -> T.List[str]:
return swift_optimization_args[optimization_level]
diff -Nru meson-0.53.2/mesonbuild/compilers/vala.py meson-0.61.2/mesonbuild/compilers/vala.py
--- meson-0.53.2/mesonbuild/compilers/vala.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/compilers/vala.py 2022-01-17 10:50:45.000000000 +0000
@@ -16,70 +16,68 @@
import typing as T
from .. import mlog
-from ..mesonlib import EnvironmentException, MachineChoice, version_compare
+from ..mesonlib import EnvironmentException, MachineChoice, version_compare, OptionKey
-from .compilers import Compiler
+from .compilers import Compiler, LibType
if T.TYPE_CHECKING:
from ..envconfig import MachineInfo
+ from ..environment import Environment
class ValaCompiler(Compiler):
language = 'vala'
- def __init__(self, exelist, version, for_machine: MachineChoice,
- is_cross, info: 'MachineInfo'):
- super().__init__(exelist, version, for_machine, info)
+ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+ is_cross: bool, info: 'MachineInfo'):
+ super().__init__(exelist, version, for_machine, info, is_cross=is_cross)
self.version = version
- self.is_cross = is_cross
self.id = 'valac'
- self.base_options = ['b_colorout']
+ self.base_options = {OptionKey('b_colorout')}
- def name_string(self):
- return ' '.join(self.exelist)
-
- def needs_static_linker(self):
+ def needs_static_linker(self) -> bool:
return False # Because compiles into C.
- def get_optimization_args(self, optimization_level):
+ def get_optimization_args(self, optimization_level: str) -> T.List[str]:
return []
- def get_debug_args(self, is_debug):
+ def get_debug_args(self, is_debug: bool) -> T.List[str]:
return ['--debug'] if is_debug else []
- def get_output_args(self, target):
+ def get_output_args(self, target: str) -> T.List[str]:
return [] # Because compiles into C.
- def get_compile_only_args(self):
+ def get_compile_only_args(self) -> T.List[str]:
return [] # Because compiles into C.
- def get_pic_args(self):
+ def get_pic_args(self) -> T.List[str]:
return []
- def get_pie_args(self):
+ def get_pie_args(self) -> T.List[str]:
return []
- def get_pie_link_args(self):
+ def get_pie_link_args(self) -> T.List[str]:
return []
- def get_always_args(self):
+ def get_always_args(self) -> T.List[str]:
return ['-C']
- def get_warn_args(self, warning_level):
+ def get_warn_args(self, warning_level: str) -> T.List[str]:
return []
- def get_no_warn_args(self):
+ def get_no_warn_args(self) -> T.List[str]:
return ['--disable-warnings']
- def get_werror_args(self):
+ def get_werror_args(self) -> T.List[str]:
return ['--fatal-warnings']
- def get_colorout_args(self, colortype):
+ def get_colorout_args(self, colortype: str) -> T.List[str]:
if version_compare(self.version, '>=0.37.1'):
return ['--color=' + colortype]
return []
- def compute_parameters_with_absolute_paths(self, parameter_list, build_dir):
+ def compute_parameters_with_absolute_paths(self, parameter_list: T.List[str],
+ build_dir: str) -> T.List[str]:
for idx, i in enumerate(parameter_list):
if i[:9] == '--girdir=':
parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
@@ -92,32 +90,34 @@
return parameter_list
- def sanity_check(self, work_dir, environment):
+ def sanity_check(self, work_dir: str, environment: 'Environment') -> None:
code = 'class MesonSanityCheck : Object { }'
- extra_flags = environment.coredata.get_external_args(self.for_machine, self.language)
+ extra_flags: T.List[str] = []
+ extra_flags += environment.coredata.get_external_args(self.for_machine, self.language)
if self.is_cross:
extra_flags += self.get_compile_only_args()
else:
extra_flags += environment.coredata.get_external_link_args(self.for_machine, self.language)
with self.cached_compile(code, environment.coredata, extra_args=extra_flags, mode='compile') as p:
if p.returncode != 0:
- msg = 'Vala compiler {!r} can not compile programs' \
- ''.format(self.name_string())
+ msg = f'Vala compiler {self.name_string()!r} can not compile programs'
raise EnvironmentException(msg)
- def get_buildtype_args(self, buildtype):
- if buildtype == 'debug' or buildtype == 'debugoptimized' or buildtype == 'minsize':
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ if buildtype in {'debug', 'debugoptimized', 'minsize'}:
return ['--debug']
return []
- def find_library(self, libname, env, extra_dirs, *args):
+ def find_library(self, libname: str, env: 'Environment', extra_dirs: T.List[str],
+ libtype: LibType = LibType.PREFER_SHARED) -> T.Optional[T.List[str]]:
if extra_dirs and isinstance(extra_dirs, str):
extra_dirs = [extra_dirs]
# Valac always looks in the default vapi dir, so only search there if
# no extra dirs are specified.
if not extra_dirs:
code = 'class MesonFindLibrary : Object { }'
- args = env.coredata.get_external_args(self.for_machine, self.language)
+ args: T.List[str] = []
+ args += env.coredata.get_external_args(self.for_machine, self.language)
vapi_args = ['--pkg', libname]
args += vapi_args
with self.cached_compile(code, env.coredata, extra_args=args, mode='compile') as p:
@@ -128,11 +128,11 @@
vapi = os.path.join(d, libname + '.vapi')
if os.path.isfile(vapi):
return [vapi]
- mlog.debug('Searched {!r} and {!r} wasn\'t found'.format(extra_dirs, libname))
+ mlog.debug(f'Searched {extra_dirs!r} and {libname!r} wasn\'t found')
return None
- def thread_flags(self, env):
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
return []
- def thread_link_flags(self, env):
+ def thread_link_flags(self, env: 'Environment') -> T.List[str]:
return []
diff -Nru meson-0.53.2/mesonbuild/coredata.py meson-0.61.2/mesonbuild/coredata.py
--- meson-0.53.2/mesonbuild/coredata.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/coredata.py 2022-02-14 19:03:13.000000000 +0000
@@ -1,4 +1,4 @@
-# Copyright 2012-2019 The Meson development team
+# Copyright 2012-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.
@@ -12,15 +12,17 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from . import mlog
+from . import mlog, mparser
import pickle, os, uuid
import sys
from itertools import chain
from pathlib import PurePath
from collections import OrderedDict
from .mesonlib import (
- MesonException, MachineChoice, PerMachine,
- default_libdir, default_libexecdir, default_prefix, split_args
+ HoldableObject,
+ MesonException, EnvironmentException, MachineChoice, PerMachine,
+ PerMachineDefaultable, default_libdir, default_libexecdir,
+ default_prefix, split_args, OptionKey, OptionType, stringlistify,
)
from .wrap import WrapMode
import ast
@@ -32,21 +34,40 @@
if T.TYPE_CHECKING:
from . import dependencies
- from .compilers import Compiler # noqa: F401
+ from .compilers.compilers import Compiler, CompileResult
from .environment import Environment
+ from .mesonlib import OptionOverrideProxy, FileOrString
+ from .cmake.traceparser import CMakeCacheEntry
- OptionDictType = T.Dict[str, 'UserOption[T.Any]']
+ OptionDictType = T.Union[T.Dict[str, 'UserOption[T.Any]'], OptionOverrideProxy]
+ KeyedOptionDictType = T.Union[T.Dict['OptionKey', 'UserOption[T.Any]'], OptionOverrideProxy]
+ CompilerCheckCacheKey = T.Tuple[T.Tuple[str, ...], str, FileOrString, T.Tuple[str, ...], str]
+
+# Check major_versions_differ() if changing versioning scheme.
+#
+# Pip requires that RCs are named like this: '0.1.0.rc1'
+# But the corresponding Git tag needs to be '0.1.0rc1'
+version = '0.61.2'
-version = '0.53.2'
-backendlist = ['ninja', 'vs', 'vs2010', 'vs2015', 'vs2017', 'vs2019', 'xcode']
+backendlist = ['ninja', 'vs', 'vs2010', 'vs2012', 'vs2013', 'vs2015', 'vs2017', 'vs2019', 'vs2022', 'xcode']
default_yielding = False
# Can't bind this near the class method it seems, sadly.
_T = T.TypeVar('_T')
-class UserOption(T.Generic[_T]):
- def __init__(self, description, choices, yielding):
+
+class MesonVersionMismatchException(MesonException):
+ '''Build directory generated with Meson version is incompatible with current version'''
+ def __init__(self, old_version: str, current_version: str) -> None:
+ super().__init__(f'Build directory has been generated with Meson version {old_version}, '
+ f'which is incompatible with the current version {current_version}.')
+ self.old_version = old_version
+ self.current_version = current_version
+
+
+class UserOption(T.Generic[_T], HoldableObject):
+ def __init__(self, description: str, choices: T.Optional[T.Union[str, T.List[_T]]], yielding: T.Optional[bool]):
super().__init__()
self.choices = choices
self.description = description
@@ -55,8 +76,13 @@
if not isinstance(yielding, bool):
raise MesonException('Value of "yielding" must be a boolean.')
self.yielding = yielding
+ self.deprecated: T.Union[bool, T.Dict[str, str], T.List[str]] = False
+
+ def listify(self, value: T.Any) -> T.List[T.Any]:
+ return [value]
- def printable_value(self):
+ def printable_value(self) -> T.Union[str, int, bool, T.List[T.Union[str, int, bool]]]:
+ assert isinstance(self.value, (str, int, bool, list))
return self.value
# Check that the input is a valid value and return the
@@ -65,30 +91,32 @@
def validate_value(self, value: T.Any) -> _T:
raise RuntimeError('Derived option class did not override validate_value.')
- def set_value(self, newvalue):
+ def set_value(self, newvalue: T.Any) -> None:
self.value = self.validate_value(newvalue)
class UserStringOption(UserOption[str]):
- def __init__(self, description, value, choices=None, yielding=None):
- super().__init__(description, choices, yielding)
+ def __init__(self, description: str, value: T.Any, yielding: T.Optional[bool] = None):
+ super().__init__(description, None, yielding)
self.set_value(value)
- def validate_value(self, value):
+ def validate_value(self, value: T.Any) -> str:
if not isinstance(value, str):
raise MesonException('Value "%s" for string option is not a string.' % str(value))
return value
class UserBooleanOption(UserOption[bool]):
- def __init__(self, description, value, yielding=None):
+ def __init__(self, description: str, value, yielding: T.Optional[bool] = None) -> None:
super().__init__(description, [True, False], yielding)
self.set_value(value)
def __bool__(self) -> bool:
return self.value
- def validate_value(self, value) -> bool:
+ def validate_value(self, value: T.Any) -> bool:
if isinstance(value, bool):
return value
+ if not isinstance(value, str):
+ raise MesonException(f'Value {value} cannot be converted to a boolean')
if value.lower() == 'true':
return True
if value.lower() == 'false':
@@ -96,19 +124,20 @@
raise MesonException('Value %s is not boolean (true or false).' % value)
class UserIntegerOption(UserOption[int]):
- def __init__(self, description, min_value, max_value, value, yielding=None):
- super().__init__(description, [True, False], yielding)
+ def __init__(self, description: str, value: T.Any, yielding: T.Optional[bool] = None):
+ min_value, max_value, default_value = value
self.min_value = min_value
self.max_value = max_value
- self.set_value(value)
c = []
if min_value is not None:
c.append('>=' + str(min_value))
if max_value is not None:
c.append('<=' + str(max_value))
- self.choices = ', '.join(c)
+ choices = ', '.join(c)
+ super().__init__(description, choices, yielding)
+ self.set_value(default_value)
- def validate_value(self, value) -> int:
+ def validate_value(self, value: T.Any) -> int:
if isinstance(value, str):
value = self.toint(value)
if not isinstance(value, int):
@@ -119,35 +148,42 @@
raise MesonException('New value %d is more than maximum value %d.' % (value, self.max_value))
return value
- def toint(self, valuestring) -> int:
+ def toint(self, valuestring: str) -> int:
try:
return int(valuestring)
except ValueError:
raise MesonException('Value string "%s" is not convertible to an integer.' % valuestring)
-class UserUmaskOption(UserIntegerOption, UserOption[T.Union[str, int]]):
- def __init__(self, description, value, yielding=None):
- super().__init__(description, 0, 0o777, value, yielding)
+class OctalInt(int):
+ # NinjaBackend.get_user_option_args uses str() to converts it to a command line option
+ # UserUmaskOption.toint() uses int(str, 8) to convert it to an integer
+ # So we need to use oct instead of dec here if we do not want values to be misinterpreted.
+ def __str__(self):
+ return oct(int(self))
+
+class UserUmaskOption(UserIntegerOption, UserOption[T.Union[str, OctalInt]]):
+ def __init__(self, description: str, value: T.Any, yielding: T.Optional[bool] = None):
+ super().__init__(description, (0, 0o777, value), yielding)
self.choices = ['preserve', '0000-0777']
- def printable_value(self):
+ def printable_value(self) -> str:
if self.value == 'preserve':
return self.value
return format(self.value, '04o')
- def validate_value(self, value):
+ def validate_value(self, value: T.Any) -> T.Union[str, OctalInt]:
if value is None or value == 'preserve':
return 'preserve'
- return super().validate_value(value)
+ return OctalInt(super().validate_value(value))
- def toint(self, valuestring):
+ def toint(self, valuestring: T.Union[str, OctalInt]) -> int:
try:
return int(valuestring, 8)
except ValueError as e:
- raise MesonException('Invalid mode: {}'.format(e))
+ raise MesonException(f'Invalid mode: {e}')
class UserComboOption(UserOption[str]):
- def __init__(self, description, choices: T.List[str], value, yielding=None):
+ def __init__(self, description: str, choices: T.List[str], value: T.Any, yielding: T.Optional[bool] = None):
super().__init__(description, choices, yielding)
if not isinstance(self.choices, list):
raise MesonException('Combo choices must be an array.')
@@ -156,20 +192,28 @@
raise MesonException('Combo choice elements must be strings.')
self.set_value(value)
- def validate_value(self, value):
+ def validate_value(self, value: T.Any) -> str:
if value not in self.choices:
- optionsstring = ', '.join(['"%s"' % (item,) for item in self.choices])
- raise MesonException('Value "%s" for combo option is not one of the choices. Possible choices are: %s.' % (value, optionsstring))
+ if isinstance(value, bool):
+ _type = 'boolean'
+ elif isinstance(value, (int, float)):
+ _type = 'number'
+ else:
+ _type = 'string'
+ optionsstring = ', '.join([f'"{item}"' for item in self.choices])
+ raise MesonException('Value "{}" (of type "{}") for combo option "{}" is not one of the choices.'
+ ' Possible choices are (as string): {}.'.format(
+ value, _type, self.description, optionsstring))
return value
class UserArrayOption(UserOption[T.List[str]]):
- def __init__(self, description, value, split_args=False, user_input=False, allow_dups=False, **kwargs):
+ def __init__(self, description: str, value: T.Union[str, T.List[str]], split_args: bool = False, user_input: bool = False, allow_dups: bool = False, **kwargs: T.Any) -> None:
super().__init__(description, kwargs.get('choices', []), yielding=kwargs.get('yielding', None))
self.split_args = split_args
self.allow_dups = allow_dups
self.value = self.validate_value(value, user_input=user_input)
- def validate_value(self, value, user_input: bool = True) -> T.List[str]:
+ def listify(self, value: T.Union[str, T.List[str]], user_input: bool = True) -> T.List[str]:
# User input is for options defined on the command line (via -D
# options). Users can put their input in as a comma separated
# string, but for defining options in meson_options.txt the format
@@ -182,7 +226,7 @@
try:
newvalue = ast.literal_eval(value)
except ValueError:
- raise MesonException('malformed option {}'.format(value))
+ raise MesonException(f'malformed option {value}')
elif value == '':
newvalue = []
else:
@@ -193,7 +237,11 @@
elif isinstance(value, list):
newvalue = value
else:
- raise MesonException('"{}" should be a string array, but it is not'.format(newvalue))
+ raise MesonException(f'"{value}" should be a string array, but it is not')
+ return newvalue
+
+ def validate_value(self, value: T.Union[str, T.List[str]], user_input: bool = True) -> T.List[str]:
+ newvalue = self.listify(value, user_input)
if not self.allow_dups and len(set(newvalue)) != len(newvalue):
msg = 'Duplicated values in array option is deprecated. ' \
@@ -201,7 +249,7 @@
mlog.deprecation(msg)
for i in newvalue:
if not isinstance(i, str):
- raise MesonException('String array element "{0}" is not a string.'.format(str(newvalue)))
+ raise MesonException(f'String array element "{newvalue!s}" is not a string.')
if self.choices:
bad = [x for x in newvalue if x not in self.choices]
if bad:
@@ -209,33 +257,30 @@
', '.join(bad), ', '.join(self.choices)))
return newvalue
+ def extend_value(self, value: T.Union[str, T.List[str]]) -> None:
+ """Extend the value with an additional value."""
+ new = self.validate_value(value)
+ self.set_value(self.value + new)
+
class UserFeatureOption(UserComboOption):
static_choices = ['enabled', 'disabled', 'auto']
- def __init__(self, description, value, yielding=None):
+ def __init__(self, description: str, value: T.Any, yielding: T.Optional[bool] = None):
super().__init__(description, self.static_choices, value, yielding)
+ self.name: T.Optional[str] = None # TODO: Refactor options to all store their name
- def is_enabled(self):
+ def is_enabled(self) -> bool:
return self.value == 'enabled'
- def is_disabled(self):
+ def is_disabled(self) -> bool:
return self.value == 'disabled'
- def is_auto(self):
+ def is_auto(self) -> bool:
return self.value == 'auto'
-
-def load_configs(filenames: T.List[str]) -> configparser.ConfigParser:
- """Load configuration files from a named subdirectory."""
- config = configparser.ConfigParser()
- config.read(filenames)
- return config
-
-
if T.TYPE_CHECKING:
- CacheKeyType = T.Tuple[T.Tuple[T.Any, ...], ...]
- SubCacheKeyType = T.Tuple[T.Any, ...]
+ from .dependencies.detect import TV_DepID
class DependencyCacheType(enum.Enum):
@@ -259,15 +304,15 @@
def __init__(self, type_: DependencyCacheType):
self.types = [type_]
- self.__cache = {} # type: T.Dict[SubCacheKeyType, dependencies.Dependency]
+ self.__cache: T.Dict[T.Tuple[str, ...], 'dependencies.Dependency'] = {}
- def __getitem__(self, key: 'SubCacheKeyType') -> 'dependencies.Dependency':
+ def __getitem__(self, key: T.Tuple[str, ...]) -> 'dependencies.Dependency':
return self.__cache[key]
- def __setitem__(self, key: 'SubCacheKeyType', value: 'dependencies.Dependency') -> None:
+ def __setitem__(self, key: T.Tuple[str, ...], value: 'dependencies.Dependency') -> None:
self.__cache[key] = value
- def __contains__(self, key: 'SubCacheKeyType') -> bool:
+ def __contains__(self, key: T.Tuple[str, ...]) -> bool:
return key in self.__cache
def values(self) -> T.Iterable['dependencies.Dependency']:
@@ -282,30 +327,32 @@
successfully lookup by providing a simple get/put interface.
"""
- def __init__(self, builtins_per_machine: PerMachine[T.Dict[str, UserOption[T.Any]]], for_machine: MachineChoice):
- self.__cache = OrderedDict() # type: T.MutableMapping[CacheKeyType, DependencySubCache]
- self.__builtins_per_machine = builtins_per_machine
- self.__for_machine = for_machine
-
- def __calculate_subkey(self, type_: DependencyCacheType) -> T.Tuple[T.Any, ...]:
- if type_ is DependencyCacheType.PKG_CONFIG:
- return tuple(self.__builtins_per_machine[self.__for_machine]['pkg_config_path'].value)
- elif type_ is DependencyCacheType.CMAKE:
- return tuple(self.__builtins_per_machine[self.__for_machine]['cmake_prefix_path'].value)
- assert type_ is DependencyCacheType.OTHER, 'Someone forgot to update subkey calculations for a new type'
- return tuple()
+ def __init__(self, builtins: 'KeyedOptionDictType', for_machine: MachineChoice):
+ self.__cache = OrderedDict() # type: T.MutableMapping[TV_DepID, DependencySubCache]
+ self.__builtins = builtins
+ self.__pkg_conf_key = OptionKey('pkg_config_path', machine=for_machine)
+ self.__cmake_key = OptionKey('cmake_prefix_path', machine=for_machine)
+
+ def __calculate_subkey(self, type_: DependencyCacheType) -> T.Tuple[str, ...]:
+ data: T.Dict[str, T.List[str]] = {
+ DependencyCacheType.PKG_CONFIG: stringlistify(self.__builtins[self.__pkg_conf_key].value),
+ DependencyCacheType.CMAKE: stringlistify(self.__builtins[self.__cmake_key].value),
+ DependencyCacheType.OTHER: [],
+ }
+ assert type_ in data, 'Someone forgot to update subkey calculations for a new type'
+ return tuple(data[type_])
- def __iter__(self) -> T.Iterator['CacheKeyType']:
+ def __iter__(self) -> T.Iterator['TV_DepID']:
return self.keys()
- def put(self, key: 'CacheKeyType', dep: 'dependencies.Dependency') -> None:
+ def put(self, key: 'TV_DepID', dep: 'dependencies.Dependency') -> None:
t = DependencyCacheType.from_type(dep)
if key not in self.__cache:
self.__cache[key] = DependencySubCache(t)
subkey = self.__calculate_subkey(t)
self.__cache[key][subkey] = dep
- def get(self, key: 'CacheKeyType') -> T.Optional['dependencies.Dependency']:
+ def get(self, key: 'TV_DepID') -> T.Optional['dependencies.Dependency']:
"""Get a value from the cache.
If there is no cache entry then None will be returned.
@@ -327,10 +374,10 @@
for c in self.__cache.values():
yield from c.values()
- def keys(self) -> T.Iterator['CacheKeyType']:
+ def keys(self) -> T.Iterator['TV_DepID']:
return iter(self.__cache.keys())
- def items(self) -> T.Iterator[T.Tuple['CacheKeyType', T.List['dependencies.Dependency']]]:
+ def items(self) -> T.Iterator[T.Tuple['TV_DepID', T.List['dependencies.Dependency']]]:
for k, v in self.__cache.items():
vs = []
for t in v.types:
@@ -342,6 +389,34 @@
def clear(self) -> None:
self.__cache.clear()
+
+class CMakeStateCache:
+ """Class that stores internal CMake compiler states.
+
+ This cache is used to reduce the startup overhead of CMake by caching
+ all internal CMake compiler variables.
+ """
+
+ def __init__(self) -> None:
+ self.__cache: T.Dict[str, T.Dict[str, T.List[str]]] = {}
+ self.cmake_cache: T.Dict[str, 'CMakeCacheEntry'] = {}
+
+ def __iter__(self) -> T.Iterator[T.Tuple[str, T.Dict[str, T.List[str]]]]:
+ return iter(self.__cache.items())
+
+ def items(self) -> T.Iterator[T.Tuple[str, T.Dict[str, T.List[str]]]]:
+ return iter(self.__cache.items())
+
+ def update(self, language: str, variables: T.Dict[str, T.List[str]]):
+ if language not in self.__cache:
+ self.__cache[language] = {}
+ self.__cache[language].update(variables)
+
+ @property
+ def languages(self) -> T.Set[str]:
+ return set(self.__cache.keys())
+
+
# Can't bind this near the class method it seems, sadly.
_V = T.TypeVar('_V')
@@ -351,7 +426,7 @@
class CoreData:
- def __init__(self, options: argparse.Namespace, scratch_dir: str):
+ def __init__(self, options: argparse.Namespace, scratch_dir: str, meson_command: T.List[str]):
self.lang_guids = {
'default': '8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942',
'c': '8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942',
@@ -362,23 +437,33 @@
self.test_guid = str(uuid.uuid4()).upper()
self.regen_guid = str(uuid.uuid4()).upper()
self.install_guid = str(uuid.uuid4()).upper()
+ self.meson_command = meson_command
self.target_guids = {}
self.version = version
- self.init_builtins()
- self.backend_options = {} # : T.Dict[str, UserOption]
- self.user_options = {} # : T.Dict[str, UserOption]
- self.compiler_options = PerMachine({}, {})
- self.base_options = {} # : T.Dict[str, UserOption]
+ self.options: 'KeyedOptionDictType' = {}
self.cross_files = self.__load_config_files(options, scratch_dir, 'cross')
- self.compilers = PerMachine(OrderedDict(), OrderedDict())
+ self.compilers = PerMachine(OrderedDict(), OrderedDict()) # type: PerMachine[T.Dict[str, Compiler]]
+
+ # Set of subprojects that have already been initialized once, this is
+ # required to be stored and reloaded with the coredata, as we don't
+ # want to overwrite options for such subprojects.
+ self.initialized_subprojects: T.Set[str] = set()
+
+ # For host == build configuraitons these caches should be the same.
+ self.deps: PerMachine[DependencyCache] = PerMachineDefaultable.default(
+ self.is_cross_build(),
+ DependencyCache(self.options, MachineChoice.BUILD),
+ DependencyCache(self.options, MachineChoice.HOST))
+
+ self.compiler_check_cache: T.Dict['CompilerCheckCacheKey', 'CompileResult'] = OrderedDict()
+
+ # CMake cache
+ self.cmake_cache: PerMachine[CMakeStateCache] = PerMachine(CMakeStateCache(), CMakeStateCache())
- build_cache = DependencyCache(self.builtins_per_machine, MachineChoice.BUILD)
- host_cache = DependencyCache(self.builtins_per_machine, MachineChoice.BUILD)
- self.deps = PerMachine(build_cache, host_cache) # type: PerMachine[DependencyCache]
- self.compiler_check_cache = OrderedDict()
# Only to print a warning if it changes between Meson invocations.
self.config_files = self.__load_config_files(options, scratch_dir, 'native')
- self.libdir_cross_fixup()
+ self.builtin_options_libdir_cross_fixup()
+ self.init_builtins('')
@staticmethod
def __load_config_files(options: argparse.Namespace, scratch_dir: str, ftype: str) -> T.List[str]:
@@ -407,9 +492,9 @@
# in this case we've been passed some kind of pipe, copy
# the contents of that file into the meson private (scratch)
# directory so that it can be re-read when wiping/reconfiguring
- copy = os.path.join(scratch_dir, '{}.{}.ini'.format(uuid.uuid4(), ftype))
- with open(f, 'r') as rf:
- with open(copy, 'w') as wf:
+ copy = os.path.join(scratch_dir, f'{uuid.uuid4()}.{ftype}.ini')
+ with open(f, encoding='utf-8') as rf:
+ with open(copy, 'w', encoding='utf-8') as wf:
wf.write(rf.read())
real.append(copy)
@@ -435,21 +520,20 @@
if found_invalid:
mlog.log('Found invalid candidates for', ftype, 'file:', *found_invalid)
mlog.log('Could not find any valid candidate for', ftype, 'files:', *missing)
- raise MesonException('Cannot find specified {} file: {}'.format(ftype, f))
+ raise MesonException(f'Cannot find specified {ftype} file: {f}')
return real
- def libdir_cross_fixup(self):
+ def builtin_options_libdir_cross_fixup(self):
# By default set libdir to "lib" when cross compiling since
# getting the "system default" is always wrong on multiarch
# platforms as it gets a value like lib/x86_64-linux-gnu.
if self.cross_files:
- self.builtins['libdir'].value = 'lib'
+ BUILTIN_OPTIONS[OptionKey('libdir')].default = 'lib'
def sanitize_prefix(self, prefix):
prefix = os.path.expanduser(prefix)
if not os.path.isabs(prefix):
- raise MesonException('prefix value {!r} must be an absolute path'
- ''.format(prefix))
+ raise MesonException(f'prefix value {prefix!r} must be an absolute path')
if prefix.endswith('/') or prefix.endswith('\\'):
# On Windows we need to preserve the trailing slash if the
# string is of type 'C:\' because 'C:' is not an absolute path.
@@ -463,7 +547,7 @@
prefix = prefix[:-1]
return prefix
- def sanitize_dir_option_value(self, prefix, option, value):
+ def sanitize_dir_option_value(self, prefix: str, option: OptionKey, value: T.Any) -> T.Any:
'''
If the option is an installation directory option and the value is an
absolute path, check that it resides within prefix and return the value
@@ -471,83 +555,129 @@
This way everyone can do f.ex, get_option('libdir') and be sure to get
the library directory relative to prefix.
+
+ .as_posix() keeps the posix-like file separators Meson uses.
'''
- if option.endswith('dir') and os.path.isabs(value) and \
- option not in builtin_dir_noprefix_options:
+ try:
+ value = PurePath(value)
+ except TypeError:
+ return value
+ if option.name.endswith('dir') and value.is_absolute() and \
+ option not in BULITIN_DIR_NOPREFIX_OPTIONS:
# Value must be a subdir of the prefix
# commonpath will always return a path in the native format, so we
# must use pathlib.PurePath to do the same conversion before
# comparing.
- if os.path.commonpath([value, prefix]) != str(PurePath(prefix)):
- m = 'The value of the {!r} option is {!r} which must be a ' \
- 'subdir of the prefix {!r}.\nNote that if you pass a ' \
- 'relative path, it is assumed to be a subdir of prefix.'
- raise MesonException(m.format(option, value, prefix))
- # Convert path to be relative to prefix
- skip = len(prefix) + 1
- value = value[skip:]
- return value
+ msg = ('The value of the \'{!s}\' option is \'{!s}\' which must be a '
+ 'subdir of the prefix {!r}.\nNote that if you pass a '
+ 'relative path, it is assumed to be a subdir of prefix.')
+ # os.path.commonpath doesn't understand case-insensitive filesystems,
+ # but PurePath().relative_to() does.
+ try:
+ value = value.relative_to(prefix)
+ except ValueError:
+ raise MesonException(msg.format(option, value, prefix))
+ if '..' in str(value):
+ raise MesonException(msg.format(option, value, prefix))
+ return value.as_posix()
- def init_builtins(self):
+ def init_builtins(self, subproject: str) -> None:
# Create builtin options with default values
- self.builtins = {}
- for key, opt in builtin_options.items():
- self.builtins[key] = opt.init_option(key, default_prefix())
- self.builtins_per_machine = PerMachine({}, {})
+ for key, opt in BUILTIN_OPTIONS.items():
+ self.add_builtin_option(self.options, key.evolve(subproject=subproject), opt)
for for_machine in iter(MachineChoice):
- for key, opt in builtin_options_per_machine.items():
- self.builtins_per_machine[for_machine][key] = opt.init_option()
+ for key, opt in BUILTIN_OPTIONS_PER_MACHINE.items():
+ self.add_builtin_option(self.options, key.evolve(subproject=subproject, machine=for_machine), opt)
- def init_backend_options(self, backend_name):
+ @staticmethod
+ def add_builtin_option(opts_map: 'KeyedOptionDictType', key: OptionKey,
+ opt: 'BuiltinOption') -> None:
+ if key.subproject:
+ if opt.yielding:
+ # This option is global and not per-subproject
+ return
+ value = opts_map[key.as_root()].value
+ else:
+ value = None
+ opts_map[key] = opt.init_option(key, value, default_prefix())
+
+ def init_backend_options(self, backend_name: str) -> None:
if backend_name == 'ninja':
- self.backend_options['backend_max_links'] = \
- UserIntegerOption(
- 'Maximum number of linker processes to run or 0 for no '
- 'limit',
- 0, None, 0)
+ self.options[OptionKey('backend_max_links')] = UserIntegerOption(
+ 'Maximum number of linker processes to run or 0 for no '
+ 'limit',
+ (0, None, 0))
elif backend_name.startswith('vs'):
- self.backend_options['backend_startup_project'] = \
- UserStringOption(
- 'Default project to execute in Visual Studio',
- '')
-
- def get_builtin_option(self, optname):
- for opts in self._get_all_builtin_options():
- v = opts.get(optname)
- if v is None:
- continue
- if optname == 'wrap_mode':
- return WrapMode.from_string(v.value)
- return v.value
- raise RuntimeError('Tried to get unknown builtin option %s.' % optname)
-
- def _try_set_builtin_option(self, optname, value):
- for opts in self._get_all_builtin_options():
- opt = opts.get(optname)
- if opt is None:
- continue
- if optname == 'prefix':
+ self.options[OptionKey('backend_startup_project')] = UserStringOption(
+ 'Default project to execute in Visual Studio',
+ '')
+
+ def get_option(self, key: OptionKey) -> T.Union[str, int, bool, WrapMode]:
+ try:
+ v = self.options[key].value
+ if key.name == 'wrap_mode':
+ return WrapMode[v]
+ return v
+ except KeyError:
+ pass
+
+ try:
+ v = self.options[key.as_root()]
+ if v.yielding:
+ if key.name == 'wrap_mode':
+ return WrapMode[v.value]
+ return v.value
+ except KeyError:
+ pass
+
+ raise MesonException(f'Tried to get unknown builtin option {str(key)}')
+
+ def set_option(self, key: OptionKey, value) -> None:
+ if key.is_builtin():
+ if key.name == 'prefix':
value = self.sanitize_prefix(value)
else:
- prefix = self.builtins['prefix'].value
- value = self.sanitize_dir_option_value(prefix, optname, value)
- break
- else:
- return False
- opt.set_value(value)
- # Make sure that buildtype matches other settings.
- if optname == 'buildtype':
- self.set_others_from_buildtype(value)
- else:
- self.set_buildtype_from_others()
- return True
+ prefix = self.options[OptionKey('prefix')].value
+ value = self.sanitize_dir_option_value(prefix, key, value)
+
+ try:
+ opt = self.options[key]
+ except KeyError:
+ raise MesonException(f'Tried to set unknown builtin option {str(key)}')
+
+ if opt.deprecated is True:
+ mlog.deprecation(f'Option {key.name!r} is deprecated')
+ elif isinstance(opt.deprecated, list):
+ for v in opt.listify(value):
+ if v in opt.deprecated:
+ mlog.deprecation(f'Option {key.name!r} value {v!r} is deprecated')
+ elif isinstance(opt.deprecated, dict):
+ def replace(v):
+ newvalue = opt.deprecated.get(v)
+ if newvalue is not None:
+ mlog.deprecation(f'Option {key.name!r} value {v!r} is replaced by {newvalue!r}')
+ return newvalue
+ return v
+ newvalue = [replace(v) for v in opt.listify(value)]
+ value = ','.join(newvalue)
- def set_builtin_option(self, optname, value):
- res = self._try_set_builtin_option(optname, value)
- if not res:
- raise RuntimeError('Tried to set unknown builtin option %s.' % optname)
+ opt.set_value(value)
- def set_others_from_buildtype(self, value):
+ if key.name == 'buildtype':
+ self._set_others_from_buildtype(value)
+ elif key.name in {'wrap_mode', 'force_fallback_for'}:
+ # We could have the system dependency cached for a dependency that
+ # is now forced to use subproject fallback. We probably could have
+ # more fine grained cache invalidation, but better be safe.
+ self.clear_deps_cache()
+
+ def clear_deps_cache(self):
+ self.deps.host.clear()
+ self.deps.build.clear()
+
+ def get_nondefault_buildtype_args(self):
+ result = []
+ value = self.options[OptionKey('buildtype')].value
if value == 'plain':
opt = '0'
debug = False
@@ -564,240 +694,280 @@
opt = 's'
debug = True
else:
- assert(value == 'custom')
- return
- self.builtins['optimization'].set_value(opt)
- self.builtins['debug'].set_value(debug)
+ assert value == 'custom'
+ return []
+ actual_opt = self.options[OptionKey('optimization')].value
+ actual_debug = self.options[OptionKey('debug')].value
+ if actual_opt != opt:
+ result.append(('optimization', actual_opt, opt))
+ if actual_debug != debug:
+ result.append(('debug', actual_debug, debug))
+ return result
- def set_buildtype_from_others(self):
- opt = self.builtins['optimization'].value
- debug = self.builtins['debug'].value
- if opt == '0' and not debug:
- mode = 'plain'
- elif opt == '0' and debug:
- mode = 'debug'
- elif opt == '2' and debug:
- mode = 'debugoptimized'
- elif opt == '3' and not debug:
- mode = 'release'
- elif opt == 's' and debug:
- mode = 'minsize'
+ def _set_others_from_buildtype(self, value: str) -> None:
+ if value == 'plain':
+ opt = '0'
+ debug = False
+ elif value == 'debug':
+ opt = '0'
+ debug = True
+ elif value == 'debugoptimized':
+ opt = '2'
+ debug = True
+ elif value == 'release':
+ opt = '3'
+ debug = False
+ elif value == 'minsize':
+ opt = 's'
+ debug = True
else:
- mode = 'custom'
- self.builtins['buildtype'].set_value(mode)
+ assert value == 'custom'
+ return
+ self.options[OptionKey('optimization')].set_value(opt)
+ self.options[OptionKey('debug')].set_value(debug)
@staticmethod
- def get_prefixed_options_per_machine(
- options_per_machine # : PerMachine[T.Dict[str, _V]]]
- ) -> T.Iterable[T.Dict[str, _V]]:
- for for_machine in iter(MachineChoice):
- prefix = for_machine.get_prefix()
- yield {
- prefix + k: v
- for k, v in options_per_machine[for_machine].items()
- }
-
- def _get_all_nonbuiltin_options(self) -> T.Iterable[T.Dict[str, UserOption]]:
- yield self.backend_options
- yield self.user_options
- yield from self.get_prefixed_options_per_machine(self.compiler_options)
- yield self.base_options
-
- def _get_all_builtin_options(self) -> T.Dict[str, UserOption]:
- yield from self.get_prefixed_options_per_machine(self.builtins_per_machine)
- yield self.builtins
-
- def get_all_options(self) -> T.Dict[str, UserOption]:
- yield from self._get_all_nonbuiltin_options()
- yield from self._get_all_builtin_options()
-
- def validate_option_value(self, option_name, override_value):
- for opts in self.get_all_options():
- opt = opts.get(option_name)
- if opt is not None:
+ def is_per_machine_option(optname: OptionKey) -> bool:
+ if optname.name in BUILTIN_OPTIONS_PER_MACHINE:
+ return True
+ return optname.lang is not None
+
+ def validate_option_value(self, option_name: OptionKey, override_value):
+ try:
+ opt = self.options[option_name]
+ except KeyError:
+ raise MesonException(f'Tried to validate unknown option {str(option_name)}')
+ try:
+ return opt.validate_value(override_value)
+ except MesonException as e:
+ raise type(e)(('Validation failed for option %s: ' % option_name) + str(e)) \
+ .with_traceback(sys.exc_info()[2])
+
+ def get_external_args(self, for_machine: MachineChoice, lang: str) -> T.Union[str, T.List[str]]:
+ return self.options[OptionKey('args', machine=for_machine, lang=lang)].value
+
+ def get_external_link_args(self, for_machine: MachineChoice, lang: str) -> T.Union[str, T.List[str]]:
+ return self.options[OptionKey('link_args', machine=for_machine, lang=lang)].value
+
+ def update_project_options(self, options: 'KeyedOptionDictType') -> None:
+ for key, value in options.items():
+ if not key.is_project():
+ continue
+ if key not in self.options:
+ self.options[key] = value
+ continue
+
+ oldval = self.options[key]
+ if type(oldval) != type(value):
+ self.options[key] = value
+ elif oldval.choices != value.choices:
+ # If the choices have changed, use the new value, but attempt
+ # to keep the old options. If they are not valid keep the new
+ # defaults but warn.
+ self.options[key] = value
try:
- return opt.validate_value(override_value)
- except MesonException as e:
- raise type(e)(('Validation failed for option %s: ' % option_name) + str(e)) \
- .with_traceback(sys.exc_info()[2])
- raise MesonException('Tried to validate unknown option %s.' % option_name)
-
- def get_external_args(self, for_machine: MachineChoice, lang):
- return self.compiler_options[for_machine][lang + '_args'].value
-
- def get_external_link_args(self, for_machine: MachineChoice, lang):
- return self.compiler_options[for_machine][lang + '_link_args'].value
-
- def merge_user_options(self, options):
- for (name, value) in options.items():
- if name not in self.user_options:
- self.user_options[name] = value
- else:
- oldval = self.user_options[name]
- if type(oldval) != type(value):
- self.user_options[name] = value
+ value.set_value(oldval.value)
+ except MesonException:
+ mlog.warning(f'Old value(s) of {key} are no longer valid, resetting to default ({value.value}).')
- def is_cross_build(self) -> bool:
+ def is_cross_build(self, when_building_for: MachineChoice = MachineChoice.HOST) -> bool:
+ if when_building_for == MachineChoice.BUILD:
+ return False
return len(self.cross_files) > 0
- def strip_build_option_names(self, options):
- res = {}
- for k, v in options.items():
- if k.startswith('build.'):
- k = k.split('.', 1)[1]
- res[k] = v
- return res
-
- def copy_build_options_from_regular_ones(self):
- assert(not self.is_cross_build())
- for k, o in self.builtins_per_machine.host.items():
- self.builtins_per_machine.build[k].set_value(o.value)
- for k, o in self.compiler_options.host.items():
- if k in self.compiler_options.build:
- self.compiler_options.build[k].set_value(o.value)
+ def copy_build_options_from_regular_ones(self) -> None:
+ assert not self.is_cross_build()
+ for k in BUILTIN_OPTIONS_PER_MACHINE:
+ o = self.options[k]
+ self.options[k.as_build()].set_value(o.value)
+ for bk, bv in self.options.items():
+ if bk.machine is MachineChoice.BUILD:
+ hk = bk.as_host()
+ try:
+ hv = self.options[hk]
+ bv.set_value(hv.value)
+ except KeyError:
+ continue
- def set_options(self, options, *, subproject='', warn_unknown=True):
+ def set_options(self, options: T.Dict[OptionKey, T.Any], subproject: str = '') -> None:
if not self.is_cross_build():
- options = self.strip_build_option_names(options)
+ options = {k: v for k, v in options.items() if k.machine is not MachineChoice.BUILD}
# Set prefix first because it's needed to sanitize other options
- if 'prefix' in options:
- prefix = self.sanitize_prefix(options['prefix'])
- self.builtins['prefix'].set_value(prefix)
- for key in builtin_dir_noprefix_options:
+ pfk = OptionKey('prefix')
+ if pfk in options:
+ prefix = self.sanitize_prefix(options[pfk])
+ self.options[OptionKey('prefix')].set_value(prefix)
+ for key in BULITIN_DIR_NOPREFIX_OPTIONS:
if key not in options:
- self.builtins[key].set_value(builtin_options[key].prefixed_default(key, prefix))
+ self.options[key].set_value(BUILTIN_OPTIONS[key].prefixed_default(key, prefix))
- unknown_options = []
+ unknown_options: T.List[OptionKey] = []
for k, v in options.items():
- if k == 'prefix':
+ if k == pfk:
continue
- if self._try_set_builtin_option(k, v):
- continue
- for opts in self._get_all_nonbuiltin_options():
- tgt = opts.get(k)
- if tgt is None:
- continue
- tgt.set_value(v)
- break
- else:
+ elif k in self.options:
+ self.set_option(k, v)
+ elif k.machine != MachineChoice.BUILD:
unknown_options.append(k)
- if unknown_options and warn_unknown:
- unknown_options = ', '.join(sorted(unknown_options))
- sub = 'In subproject {}: '.format(subproject) if subproject else ''
- mlog.warning('{}Unknown options: "{}"'.format(sub, unknown_options))
+ if unknown_options:
+ unknown_options_str = ', '.join(sorted(str(s) for s in unknown_options))
+ sub = f'In subproject {subproject}: ' if subproject else ''
+ raise MesonException(f'{sub}Unknown options: "{unknown_options_str}"')
+
if not self.is_cross_build():
self.copy_build_options_from_regular_ones()
- def set_default_options(self, default_options, subproject, env):
- # Set defaults first from conf files (cross or native), then
- # override them as nec as necessary.
- for k, v in env.paths.host:
- if v is not None:
- env.cmd_line_options.setdefault(k, v)
-
- # Set default options as if they were passed to the command line.
- # Subprojects can only define default for user options.
- from . import optinterpreter
- for k, v in default_options.items():
- if subproject:
- if optinterpreter.is_invalid_name(k, log=False):
- continue
- k = subproject + ':' + k
- env.cmd_line_options.setdefault(k, v)
+ def set_default_options(self, default_options: T.MutableMapping[OptionKey, str], subproject: str, env: 'Environment') -> None:
+ # Preserve order: if env.options has 'buildtype' it must come after
+ # 'optimization' if it is in default_options.
+ options: T.MutableMapping[OptionKey, T.Any]
+ if not subproject:
+ options = OrderedDict(default_options)
+ options.update(env.options)
+ env.options = options
- # Create a subset of cmd_line_options, keeping only options for this
- # subproject. Also take builtin options if it's the main project.
+ # Create a subset of options, keeping only project and builtin
+ # options for this subproject.
# Language and backend specific options will be set later when adding
# languages and setting the backend (builtin options must be set first
# to know which backend we'll use).
- options = {}
+ options = OrderedDict()
- # Some options default to environment variables if they are
- # unset, set those now. These will either be overwritten
- # below, or they won't. These should only be set on the first run.
- if env.first_invocation:
- p_env = os.environ.get('PKG_CONFIG_PATH')
- if p_env:
- # PKG_CONFIG_PATH may contain duplicates, which must be
- # removed, else a duplicates-in-array-option warning arises.
- pkg_config_paths = []
- for k in p_env.split(':'):
- if k not in pkg_config_paths:
- pkg_config_paths.append(k)
- options['pkg_config_path'] = pkg_config_paths
-
- for k, v in env.cmd_line_options.items():
- if subproject:
- if not k.startswith(subproject + ':'):
- continue
- elif k not in builtin_options.keys() \
- and 'build.' + k not in builtin_options_per_machine.keys() \
- and k not in builtin_options_per_machine.keys():
- if ':' in k:
- continue
- if optinterpreter.is_invalid_name(k, log=False):
- continue
+ for k, v in chain(default_options.items(), env.options.items()):
+ # If this is a subproject, don't use other subproject options
+ if k.subproject and k.subproject != subproject:
+ continue
+ # If the option is a builtin and is yielding then it's not allowed per subproject.
+ #
+ # Always test this using the HOST machine, as many builtin options
+ # are not valid for the BUILD machine, but the yielding value does
+ # not differ between them even when they are valid for both.
+ if subproject and k.is_builtin() and self.options[k.evolve(subproject='', machine=MachineChoice.HOST)].yielding:
+ continue
+ # Skip base, compiler, and backend options, they are handled when
+ # adding languages and setting backend.
+ if k.type in {OptionType.COMPILER, OptionType.BACKEND, OptionType.BASE}:
+ continue
options[k] = v
self.set_options(options, subproject=subproject)
+ def add_compiler_options(self, options: 'KeyedOptionDictType', lang: str, for_machine: MachineChoice,
+ env: 'Environment') -> None:
+ for k, o in options.items():
+ value = env.options.get(k)
+ if value is not None:
+ o.set_value(value)
+ self.options.setdefault(k, o)
+
def add_lang_args(self, lang: str, comp: T.Type['Compiler'],
for_machine: MachineChoice, env: 'Environment') -> None:
"""Add global language arguments that are needed before compiler/linker detection."""
from .compilers import compilers
+ # These options are all new at this point, because the compiler is
+ # responsible for adding its own options, thus calling
+ # `self.options.update()`` is perfectly safe.
+ self.options.update(compilers.get_global_options(lang, comp, for_machine, env))
- optprefix = lang + '_'
- for k, o in compilers.get_global_options(lang, comp, env.properties[for_machine]).items():
- if not k.startswith(optprefix):
- raise MesonException('Internal error, %s has incorrect prefix.' % k)
- # prefixed compiler options affect just this machine
- opt_prefix = for_machine.get_prefix()
- if opt_prefix + k in env.cmd_line_options:
- o.set_value(env.cmd_line_options[opt_prefix + k])
- self.compiler_options[for_machine].setdefault(k, o)
-
- def process_new_compiler(self, lang: str, comp: T.Type['Compiler'], env: 'Environment') -> None:
+ def process_new_compiler(self, lang: str, comp: 'Compiler', env: 'Environment') -> None:
from . import compilers
self.compilers[comp.for_machine][lang] = comp
- enabled_opts = []
+ self.add_compiler_options(comp.get_options(), lang, comp.for_machine, env)
- optprefix = lang + '_'
- for k, o in comp.get_options().items():
- if not k.startswith(optprefix):
- raise MesonException('Internal error, %s has incorrect prefix.' % k)
- # prefixed compiler options affect just this machine
- opt_prefix = comp.for_machine.get_prefix()
- if opt_prefix + k in env.cmd_line_options:
- o.set_value(env.cmd_line_options[opt_prefix + k])
- self.compiler_options[comp.for_machine].setdefault(k, o)
-
- enabled_opts = []
- for optname in comp.base_options:
- if optname in self.base_options:
+ enabled_opts: T.List[OptionKey] = []
+ for key in comp.base_options:
+ if key in self.options:
continue
- oobj = compilers.base_options[optname]
- if optname in env.cmd_line_options:
- oobj.set_value(env.cmd_line_options[optname])
- enabled_opts.append(optname)
- self.base_options[optname] = oobj
+ oobj = compilers.base_options[key]
+ if key in env.options:
+ oobj.set_value(env.options[key])
+ enabled_opts.append(key)
+ self.options[key] = oobj
self.emit_base_options_warnings(enabled_opts)
- def emit_base_options_warnings(self, enabled_opts: list):
- if 'b_bitcode' in enabled_opts:
- mlog.warning('Base option \'b_bitcode\' is enabled, which is incompatible with many linker options. Incompatible options such as such as \'b_asneeded\' have been disabled.')
- mlog.warning('Please see https://mesonbuild.com/Builtin-options.html#Notes_about_Apple_Bitcode_support for more details.')
+ def emit_base_options_warnings(self, enabled_opts: T.List[OptionKey]) -> None:
+ if OptionKey('b_bitcode') in enabled_opts:
+ mlog.warning('Base option \'b_bitcode\' is enabled, which is incompatible with many linker options. Incompatible options such as \'b_asneeded\' have been disabled.', fatal=False)
+ mlog.warning('Please see https://mesonbuild.com/Builtin-options.html#Notes_about_Apple_Bitcode_support for more details.', fatal=False)
class CmdLineFileParser(configparser.ConfigParser):
- def __init__(self):
+ def __init__(self) -> None:
# We don't want ':' as key delimiter, otherwise it would break when
# storing subproject options like "subproject:option=value"
super().__init__(delimiters=['='], interpolation=None)
-def get_cmd_line_file(build_dir):
+ def optionxform(self, option: str) -> str:
+ # Don't call str.lower() on keys
+ return option
+
+class MachineFileParser():
+ def __init__(self, filenames: T.List[str]) -> None:
+ self.parser = CmdLineFileParser()
+ self.constants = {'True': True, 'False': False}
+ self.sections = {}
+
+ self.parser.read(filenames)
+
+ # Parse [constants] first so they can be used in other sections
+ if self.parser.has_section('constants'):
+ self.constants.update(self._parse_section('constants'))
+
+ for s in self.parser.sections():
+ if s == 'constants':
+ continue
+ self.sections[s] = self._parse_section(s)
+
+ def _parse_section(self, s):
+ self.scope = self.constants.copy()
+ section = {}
+ for entry, value in self.parser.items(s):
+ if ' ' in entry or '\t' in entry or "'" in entry or '"' in entry:
+ raise EnvironmentException(f'Malformed variable name {entry!r} in machine file.')
+ # Windows paths...
+ value = value.replace('\\', '\\\\')
+ try:
+ ast = mparser.Parser(value, 'machinefile').parse()
+ res = self._evaluate_statement(ast.lines[0])
+ except MesonException:
+ raise EnvironmentException(f'Malformed value in machine file variable {entry!r}.')
+ except KeyError as e:
+ raise EnvironmentException(f'Undefined constant {e.args[0]!r} in machine file variable {entry!r}.')
+ section[entry] = res
+ self.scope[entry] = res
+ return section
+
+ def _evaluate_statement(self, node):
+ if isinstance(node, (mparser.StringNode)):
+ return node.value
+ elif isinstance(node, mparser.BooleanNode):
+ return node.value
+ elif isinstance(node, mparser.NumberNode):
+ return node.value
+ elif isinstance(node, mparser.ArrayNode):
+ return [self._evaluate_statement(arg) for arg in node.args.arguments]
+ elif isinstance(node, mparser.IdNode):
+ return self.scope[node.value]
+ elif isinstance(node, mparser.ArithmeticNode):
+ l = self._evaluate_statement(node.left)
+ r = self._evaluate_statement(node.right)
+ if node.operation == 'add':
+ if (isinstance(l, str) and isinstance(r, str)) or \
+ (isinstance(l, list) and isinstance(r, list)):
+ return l + r
+ elif node.operation == 'div':
+ if isinstance(l, str) and isinstance(r, str):
+ return os.path.join(l, r)
+ raise EnvironmentException('Unsupported node type')
+
+def parse_machine_files(filenames):
+ parser = MachineFileParser(filenames)
+ return parser.sections
+
+def get_cmd_line_file(build_dir: str) -> str:
return os.path.join(build_dir, 'meson-private', 'cmd_line.txt')
-def read_cmd_line_file(build_dir, options):
+def read_cmd_line_file(build_dir: str, options: argparse.Namespace) -> None:
filename = get_cmd_line_file(build_dir)
if not os.path.isfile(filename):
return
@@ -807,7 +977,7 @@
# Do a copy because config is not really a dict. options.cmd_line_options
# overrides values from the file.
- d = dict(config['options'])
+ d = {OptionKey.from_string(k): v for k, v in config['options'].items()}
d.update(options.cmd_line_options)
options.cmd_line_options = d
@@ -819,67 +989,63 @@
# literal_eval to get it into the list of strings.
options.native_file = ast.literal_eval(properties.get('native_file', '[]'))
-def cmd_line_options_to_string(options):
- return {k: str(v) for k, v in options.cmd_line_options.items()}
-
-def write_cmd_line_file(build_dir, options):
+def write_cmd_line_file(build_dir: str, options: argparse.Namespace) -> None:
filename = get_cmd_line_file(build_dir)
config = CmdLineFileParser()
- properties = {}
+ properties = OrderedDict()
if options.cross_file:
properties['cross_file'] = options.cross_file
if options.native_file:
properties['native_file'] = options.native_file
- config['options'] = cmd_line_options_to_string(options)
+ config['options'] = {str(k): str(v) for k, v in options.cmd_line_options.items()}
config['properties'] = properties
- with open(filename, 'w') as f:
+ with open(filename, 'w', encoding='utf-8') as f:
config.write(f)
-def update_cmd_line_file(build_dir, options):
+def update_cmd_line_file(build_dir: str, options: argparse.Namespace):
filename = get_cmd_line_file(build_dir)
config = CmdLineFileParser()
config.read(filename)
- config['options'].update(cmd_line_options_to_string(options))
- with open(filename, 'w') as f:
+ config['options'].update({str(k): str(v) for k, v in options.cmd_line_options.items()})
+ with open(filename, 'w', encoding='utf-8') as f:
config.write(f)
-def get_cmd_line_options(build_dir, options):
- copy = argparse.Namespace(**vars(options))
- read_cmd_line_file(build_dir, copy)
- cmdline = ['-D{}={}'.format(k, v) for k, v in copy.cmd_line_options.items()]
+def format_cmd_line_options(options: argparse.Namespace) -> str:
+ cmdline = ['-D{}={}'.format(str(k), v) for k, v in options.cmd_line_options.items()]
if options.cross_file:
- cmdline += ['--cross-file {}'.format(f) for f in options.cross_file]
+ cmdline += [f'--cross-file {f}' for f in options.cross_file]
if options.native_file:
- cmdline += ['--native-file {}'.format(f) for f in options.native_file]
+ cmdline += [f'--native-file {f}' for f in options.native_file]
return ' '.join([shlex.quote(x) for x in cmdline])
-def major_versions_differ(v1, v2):
- return v1.split('.')[0:2] != v2.split('.')[0:2]
+def major_versions_differ(v1: str, v2: str) -> bool:
+ v1_major, v1_minor = v1.rsplit('.', 1)
+ v2_major, v2_minor = v2.rsplit('.', 1)
+ # Major version differ, or one is development version but not the other.
+ return v1_major != v2_major or ('99' in {v1_minor, v2_minor} and v1_minor != v2_minor)
-def load(build_dir):
+def load(build_dir: str) -> CoreData:
filename = os.path.join(build_dir, 'meson-private', 'coredata.dat')
- load_fail_msg = 'Coredata file {!r} is corrupted. Try with a fresh build tree.'.format(filename)
+ load_fail_msg = f'Coredata file {filename!r} is corrupted. Try with a fresh build tree.'
try:
with open(filename, 'rb') as f:
obj = pickle.load(f)
except (pickle.UnpicklingError, EOFError):
raise MesonException(load_fail_msg)
- except AttributeError:
+ except (ModuleNotFoundError, AttributeError):
raise MesonException(
- "Coredata file {!r} references functions or classes that don't "
+ f"Coredata file {filename!r} references functions or classes that don't "
"exist. This probably means that it was generated with an old "
- "version of meson.".format(filename))
+ "version of meson.")
if not isinstance(obj, CoreData):
raise MesonException(load_fail_msg)
if major_versions_differ(obj.version, version):
- raise MesonException('Build directory has been generated with Meson version %s, '
- 'which is incompatible with current version %s.\n' %
- (obj.version, version))
+ raise MesonVersionMismatchException(obj.version, version)
return obj
-def save(obj, build_dir):
+def save(obj: CoreData, build_dir: str) -> str:
filename = os.path.join(build_dir, 'meson-private', 'coredata.dat')
prev_filename = filename + '.prev'
tempfilename = filename + '~'
@@ -896,41 +1062,45 @@
return filename
-def register_builtin_arguments(parser):
- for n, b in builtin_options.items():
- b.add_to_argparse(n, parser, '', '')
- for n, b in builtin_options_per_machine.items():
- b.add_to_argparse(n, parser, '', ' (just for host machine)')
- b.add_to_argparse(n, parser, 'build.', ' (just for build machine)')
+def register_builtin_arguments(parser: argparse.ArgumentParser) -> None:
+ for n, b in BUILTIN_OPTIONS.items():
+ b.add_to_argparse(str(n), parser, '')
+ for n, b in BUILTIN_OPTIONS_PER_MACHINE.items():
+ b.add_to_argparse(str(n), parser, ' (just for host machine)')
+ b.add_to_argparse(str(n.as_build()), parser, ' (just for build machine)')
parser.add_argument('-D', action='append', dest='projectoptions', default=[], metavar="option",
help='Set the value of an option, can be used several times to set multiple options.')
-def create_options_dict(options):
- result = {}
+def create_options_dict(options: T.List[str], subproject: str = '') -> T.Dict[OptionKey, str]:
+ result: T.OrderedDict[OptionKey, str] = OrderedDict()
for o in options:
try:
(key, value) = o.split('=', 1)
except ValueError:
- raise MesonException('Option {!r} must have a value separated by equals sign.'.format(o))
- result[key] = value
+ raise MesonException(f'Option {o!r} must have a value separated by equals sign.')
+ k = OptionKey.from_string(key)
+ if subproject:
+ k = k.evolve(subproject=subproject)
+ result[k] = value
return result
-def parse_cmd_line_options(args):
+def parse_cmd_line_options(args: argparse.Namespace) -> None:
args.cmd_line_options = create_options_dict(args.projectoptions)
# Merge builtin options set with --option into the dict.
- for name in chain(
- builtin_options.keys(),
- ('build.' + k for k in builtin_options_per_machine.keys()),
- builtin_options_per_machine.keys(),
+ for key in chain(
+ BUILTIN_OPTIONS.keys(),
+ (k.as_build() for k in BUILTIN_OPTIONS_PER_MACHINE.keys()),
+ BUILTIN_OPTIONS_PER_MACHINE.keys(),
):
+ name = str(key)
value = getattr(args, name, None)
if value is not None:
- if name in args.cmd_line_options:
+ if key in args.cmd_line_options:
cmdline_name = BuiltinOption.argparse_name_to_arg(name)
raise MesonException(
- 'Got argument {0} as both -D{0} and {1}. Pick one.'.format(name, cmdline_name))
- args.cmd_line_options[name] = value
+ f'Got argument {name} as both -D{name} and {cmdline_name}. Pick one.')
+ args.cmd_line_options[key] = value
delattr(args, name)
@@ -940,10 +1110,10 @@
"""Class for a builtin option type.
- Currently doesn't support UserIntegerOption, or a few other cases.
+ There are some cases that are not fully supported yet.
"""
- def __init__(self, opt_type: T.Type[_U], description: str, default: T.Any, yielding: T.Optional[bool] = None, *,
+ def __init__(self, opt_type: T.Type[_U], description: str, default: T.Any, yielding: bool = True, *,
choices: T.Any = None):
self.opt_type = opt_type
self.description = description
@@ -951,17 +1121,20 @@
self.choices = choices
self.yielding = yielding
- def init_option(self, name: str = 'prefix', prefix: str = '') -> _U:
+ def init_option(self, name: 'OptionKey', value: T.Optional[T.Any], prefix: str) -> _U:
"""Create an instance of opt_type and return it."""
- keywords = {'yielding': self.yielding, 'value': self.prefixed_default(name, prefix)}
+ if value is None:
+ value = self.prefixed_default(name, prefix)
+ keywords = {'yielding': self.yielding, 'value': value}
if self.choices:
keywords['choices'] = self.choices
return self.opt_type(self.description, **keywords)
def _argparse_action(self) -> T.Optional[str]:
- if self.default is True:
- return 'store_false'
- elif self.default is False:
+ # If the type is a boolean, the presence of the argument in --foo form
+ # is to enable it. Disabling happens by using -Dfoo=false, which is
+ # parsed under `args.projectoptions` and does not hit this codepath.
+ if isinstance(self.default, bool):
return 'store_true'
return None
@@ -979,17 +1152,17 @@
else:
return '--' + name.replace('_', '-')
- def prefixed_default(self, name: str, prefix: str = '') -> T.Any:
+ def prefixed_default(self, name: 'OptionKey', prefix: str = '') -> T.Any:
if self.opt_type in [UserComboOption, UserIntegerOption]:
return self.default
try:
- return builtin_dir_noprefix_options[name][prefix]
+ return BULITIN_DIR_NOPREFIX_OPTIONS[name][prefix]
except KeyError:
pass
return self.default
- def add_to_argparse(self, name: str, parser: argparse.ArgumentParser, prefix: str, help_suffix: str) -> None:
- kwargs = {}
+ def add_to_argparse(self, name: str, parser: argparse.ArgumentParser, help_suffix: str) -> None:
+ kwargs = OrderedDict()
c = self._argparse_choices()
b = self._argparse_action()
@@ -1001,60 +1174,76 @@
if c and not b:
kwargs['choices'] = c
kwargs['default'] = argparse.SUPPRESS
- kwargs['dest'] = prefix + name
+ kwargs['dest'] = name
- cmdline_name = self.argparse_name_to_arg(prefix + name)
+ cmdline_name = self.argparse_name_to_arg(name)
parser.add_argument(cmdline_name, help=h + help_suffix, **kwargs)
+
# Update `docs/markdown/Builtin-options.md` after changing the options below
-builtin_options = OrderedDict([
- # Directories
- ('prefix', BuiltinOption(UserStringOption, 'Installation prefix', default_prefix())),
- ('bindir', BuiltinOption(UserStringOption, 'Executable directory', 'bin')),
- ('datadir', BuiltinOption(UserStringOption, 'Data file directory', 'share')),
- ('includedir', BuiltinOption(UserStringOption, 'Header file directory', 'include')),
- ('infodir', BuiltinOption(UserStringOption, 'Info page directory', 'share/info')),
- ('libdir', BuiltinOption(UserStringOption, 'Library directory', default_libdir())),
- ('libexecdir', BuiltinOption(UserStringOption, 'Library executable directory', default_libexecdir())),
- ('localedir', BuiltinOption(UserStringOption, 'Locale data directory', 'share/locale')),
- ('localstatedir', BuiltinOption(UserStringOption, 'Localstate data directory', 'var')),
- ('mandir', BuiltinOption(UserStringOption, 'Manual page directory', 'share/man')),
- ('sbindir', BuiltinOption(UserStringOption, 'System executable directory', 'sbin')),
- ('sharedstatedir', BuiltinOption(UserStringOption, 'Architecture-independent data directory', 'com')),
- ('sysconfdir', BuiltinOption(UserStringOption, 'Sysconf data directory', 'etc')),
- # Core options
- ('auto_features', BuiltinOption(UserFeatureOption, "Override value of all 'auto' features", 'auto')),
- ('backend', BuiltinOption(UserComboOption, 'Backend to use', 'ninja', choices=backendlist)),
- ('buildtype', BuiltinOption(UserComboOption, 'Build type to use', 'debug',
- choices=['plain', 'debug', 'debugoptimized', 'release', 'minsize', 'custom'])),
- ('debug', BuiltinOption(UserBooleanOption, 'Debug', True)),
- ('default_library', BuiltinOption(UserComboOption, 'Default library type', 'shared', choices=['shared', 'static', 'both'])),
- ('errorlogs', BuiltinOption(UserBooleanOption, "Whether to print the logs from failing tests", True)),
- ('install_umask', BuiltinOption(UserUmaskOption, 'Default umask to apply on permissions of installed files', '022')),
- ('layout', BuiltinOption(UserComboOption, 'Build directory layout', 'mirror', choices=['mirror', 'flat'])),
- ('optimization', BuiltinOption(UserComboOption, 'Optimization level', '0', choices=['0', 'g', '1', '2', '3', 's'])),
- ('stdsplit', BuiltinOption(UserBooleanOption, 'Split stdout and stderr in test logs', True)),
- ('strip', BuiltinOption(UserBooleanOption, 'Strip targets on install', False)),
- ('unity', BuiltinOption(UserComboOption, 'Unity build', 'off', choices=['on', 'off', 'subprojects'])),
- ('warning_level', BuiltinOption(UserComboOption, 'Compiler warning level to use', '1', choices=['0', '1', '2', '3'])),
- ('werror', BuiltinOption(UserBooleanOption, 'Treat warnings as errors', False)),
- ('wrap_mode', BuiltinOption(UserComboOption, 'Wrap mode', 'default', choices=['default', 'nofallback', 'nodownload', 'forcefallback'])),
+# Also update mesonlib._BUILTIN_NAMES. See the comment there for why this is required.
+BUILTIN_DIR_OPTIONS: 'KeyedOptionDictType' = OrderedDict([
+ (OptionKey('prefix'), BuiltinOption(UserStringOption, 'Installation prefix', default_prefix())),
+ (OptionKey('bindir'), BuiltinOption(UserStringOption, 'Executable directory', 'bin')),
+ (OptionKey('datadir'), BuiltinOption(UserStringOption, 'Data file directory', 'share')),
+ (OptionKey('includedir'), BuiltinOption(UserStringOption, 'Header file directory', 'include')),
+ (OptionKey('infodir'), BuiltinOption(UserStringOption, 'Info page directory', 'share/info')),
+ (OptionKey('libdir'), BuiltinOption(UserStringOption, 'Library directory', default_libdir())),
+ (OptionKey('libexecdir'), BuiltinOption(UserStringOption, 'Library executable directory', default_libexecdir())),
+ (OptionKey('localedir'), BuiltinOption(UserStringOption, 'Locale data directory', 'share/locale')),
+ (OptionKey('localstatedir'), BuiltinOption(UserStringOption, 'Localstate data directory', 'var')),
+ (OptionKey('mandir'), BuiltinOption(UserStringOption, 'Manual page directory', 'share/man')),
+ (OptionKey('sbindir'), BuiltinOption(UserStringOption, 'System executable directory', 'sbin')),
+ (OptionKey('sharedstatedir'), BuiltinOption(UserStringOption, 'Architecture-independent data directory', 'com')),
+ (OptionKey('sysconfdir'), BuiltinOption(UserStringOption, 'Sysconf data directory', 'etc')),
])
-builtin_options_per_machine = OrderedDict([
- ('pkg_config_path', BuiltinOption(UserArrayOption, 'T.List of additional paths for pkg-config to search', [])),
- ('cmake_prefix_path', BuiltinOption(UserArrayOption, 'T.List of additional prefixes for cmake to search', [])),
+BUILTIN_CORE_OPTIONS: 'KeyedOptionDictType' = OrderedDict([
+ (OptionKey('auto_features'), BuiltinOption(UserFeatureOption, "Override value of all 'auto' features", 'auto')),
+ (OptionKey('backend'), BuiltinOption(UserComboOption, 'Backend to use', 'ninja', choices=backendlist)),
+ (OptionKey('buildtype'), BuiltinOption(UserComboOption, 'Build type to use', 'debug',
+ choices=['plain', 'debug', 'debugoptimized', 'release', 'minsize', 'custom'])),
+ (OptionKey('debug'), BuiltinOption(UserBooleanOption, 'Debug', True)),
+ (OptionKey('default_library'), BuiltinOption(UserComboOption, 'Default library type', 'shared', choices=['shared', 'static', 'both'],
+ yielding=False)),
+ (OptionKey('errorlogs'), BuiltinOption(UserBooleanOption, "Whether to print the logs from failing tests", True)),
+ (OptionKey('install_umask'), BuiltinOption(UserUmaskOption, 'Default umask to apply on permissions of installed files', '022')),
+ (OptionKey('layout'), BuiltinOption(UserComboOption, 'Build directory layout', 'mirror', choices=['mirror', 'flat'])),
+ (OptionKey('optimization'), BuiltinOption(UserComboOption, 'Optimization level', '0', choices=['0', 'g', '1', '2', '3', 's'])),
+ (OptionKey('stdsplit'), BuiltinOption(UserBooleanOption, 'Split stdout and stderr in test logs', True)),
+ (OptionKey('strip'), BuiltinOption(UserBooleanOption, 'Strip targets on install', False)),
+ (OptionKey('unity'), BuiltinOption(UserComboOption, 'Unity build', 'off', choices=['on', 'off', 'subprojects'])),
+ (OptionKey('unity_size'), BuiltinOption(UserIntegerOption, 'Unity block size', (2, None, 4))),
+ (OptionKey('warning_level'), BuiltinOption(UserComboOption, 'Compiler warning level to use', '1', choices=['0', '1', '2', '3'], yielding=False)),
+ (OptionKey('werror'), BuiltinOption(UserBooleanOption, 'Treat warnings as errors', False, yielding=False)),
+ (OptionKey('wrap_mode'), BuiltinOption(UserComboOption, 'Wrap mode', 'default', choices=['default', 'nofallback', 'nodownload', 'forcefallback', 'nopromote'])),
+ (OptionKey('force_fallback_for'), BuiltinOption(UserArrayOption, 'Force fallback for those subprojects', [])),
+
+ # Python module
+ (OptionKey('platlibdir', module='python'),
+ BuiltinOption(UserStringOption, 'Directory for site-specific, platform-specific files.', '')),
+ (OptionKey('purelibdir', module='python'),
+ BuiltinOption(UserStringOption, 'Directory for site-specific, non-platform-specific files.', '')),
+])
+
+BUILTIN_OPTIONS = OrderedDict(chain(BUILTIN_DIR_OPTIONS.items(), BUILTIN_CORE_OPTIONS.items()))
+
+BUILTIN_OPTIONS_PER_MACHINE: 'KeyedOptionDictType' = OrderedDict([
+ (OptionKey('pkg_config_path'), BuiltinOption(UserArrayOption, 'List of additional paths for pkg-config to search', [])),
+ (OptionKey('cmake_prefix_path'), BuiltinOption(UserArrayOption, 'List of additional prefixes for cmake to search', [])),
])
# Special prefix-dependent defaults for installation directories that reside in
# a path outside of the prefix in FHS and common usage.
-builtin_dir_noprefix_options = {
- 'sysconfdir': {'/usr': '/etc'},
- 'localstatedir': {'/usr': '/var', '/usr/local': '/var/local'},
- 'sharedstatedir': {'/usr': '/var/lib', '/usr/local': '/var/local/lib'},
+BULITIN_DIR_NOPREFIX_OPTIONS: T.Dict[OptionKey, T.Dict[str, str]] = {
+ OptionKey('sysconfdir'): {'/usr': '/etc'},
+ OptionKey('localstatedir'): {'/usr': '/var', '/usr/local': '/var/local'},
+ OptionKey('sharedstatedir'): {'/usr': '/var/lib', '/usr/local': '/var/local/lib'},
+ OptionKey('platlibdir', module='python'): {},
+ OptionKey('purelibdir', module='python'): {},
}
-forbidden_target_names = {'clean': None,
+FORBIDDEN_TARGET_NAMES = {'clean': None,
'clean-ctlist': None,
'clean-gcno': None,
'clean-gcda': None,
diff -Nru meson-0.53.2/mesonbuild/dependencies/base.py meson-0.61.2/mesonbuild/dependencies/base.py
--- meson-0.53.2/mesonbuild/dependencies/base.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/base.py 2021-12-26 16:24:25.000000000 +0000
@@ -15,31 +15,22 @@
# This file contains the detection logic for external dependencies.
# Custom logic for several other packages are in separate files.
import copy
-import functools
import os
-import re
-import json
-import shlex
-import shutil
-import stat
-import textwrap
-import platform
+import itertools
import typing as T
from enum import Enum
-from pathlib import Path, PurePath
from .. import mlog
-from .. import mesonlib
from ..compilers import clib_langs
-from ..environment import BinaryTable, Environment, MachineInfo
-from ..cmake import CMakeExecutor, CMakeTraceParser, CMakeException
-from ..mesonlib import MachineChoice, MesonException, OrderedSet, PerMachine
-from ..mesonlib import Popen_safe, version_compare_many, version_compare, listify, stringlistify, extract_as_list, split_args
-from ..mesonlib import Version, LibType
-
-# These must be defined in this file to avoid cyclical references.
-packages = {}
-_packages_accept_language = set()
+from ..mesonlib import LibType, MachineChoice, MesonException, HoldableObject
+from ..mesonlib import version_compare_many
+from ..interpreterbase import FeatureDeprecated
+
+if T.TYPE_CHECKING:
+ from ..compilers.compilers import Compiler
+ from ..environment import Environment
+ from ..build import BuildTarget, CustomTarget
+ from ..mesonlib import FileOrString
class DependencyException(MesonException):
@@ -50,8 +41,9 @@
# Auto means to use whatever dependency checking mechanisms in whatever order meson thinks is best.
AUTO = 'auto'
PKGCONFIG = 'pkg-config'
- QMAKE = 'qmake'
CMAKE = 'cmake'
+ # The dependency is provided by the standard library and does not need to be linked
+ BUILTIN = 'builtin'
# Just specify the standard link arguments, assuming the operating system provides the library.
SYSTEM = 'system'
# This is only supported on OSX - search the frameworks directory by name.
@@ -65,46 +57,18 @@
CUPSCONFIG = 'cups-config'
PCAPCONFIG = 'pcap-config'
LIBWMFCONFIG = 'libwmf-config'
+ QMAKE = 'qmake'
# Misc
DUB = 'dub'
-class Dependency:
- @classmethod
- def _process_method_kw(cls, kwargs):
- method = kwargs.get('method', 'auto')
- if isinstance(method, DependencyMethods):
- return method
- if method not in [e.value for e in DependencyMethods]:
- raise DependencyException('method {!r} is invalid'.format(method))
- method = DependencyMethods(method)
-
- # This sets per-tool config methods which are deprecated to to the new
- # generic CONFIG_TOOL value.
- if method in [DependencyMethods.SDLCONFIG, DependencyMethods.CUPSCONFIG,
- DependencyMethods.PCAPCONFIG, DependencyMethods.LIBWMFCONFIG]:
- mlog.warning(textwrap.dedent("""\
- Configuration method {} has been deprecated in favor of
- 'config-tool'. This will be removed in a future version of
- meson.""".format(method)))
- method = DependencyMethods.CONFIG_TOOL
-
- # Set the detection method. If the method is set to auto, use any available method.
- # If method is set to a specific string, allow only that detection method.
- if method == DependencyMethods.AUTO:
- methods = cls.get_methods()
- elif method in cls.get_methods():
- methods = [method]
- else:
- raise DependencyException(
- 'Unsupported detection method: {}, allowed methods are {}'.format(
- method.value,
- mlog.format_list([x.value for x in [DependencyMethods.AUTO] + cls.get_methods()])))
+DependencyTypeName = T.NewType('DependencyTypeName', str)
+
- return methods
+class Dependency(HoldableObject):
@classmethod
- def _process_include_type_kw(cls, kwargs) -> str:
+ def _process_include_type_kw(cls, kwargs: T.Dict[str, T.Any]) -> str:
if 'include_type' not in kwargs:
return 'preserve'
if not isinstance(kwargs['include_type'], str):
@@ -113,27 +77,35 @@
raise DependencyException("include_type may only be one of ['preserve', 'system', 'non-system']")
return kwargs['include_type']
- def __init__(self, type_name, kwargs):
+ def __init__(self, type_name: DependencyTypeName, kwargs: T.Dict[str, T.Any]) -> None:
self.name = "null"
- self.version = None
- self.language = None # None means C-like
+ self.version: T.Optional[str] = None
+ self.language: T.Optional[str] = None # None means C-like
self.is_found = False
self.type_name = type_name
- self.compile_args = []
- self.link_args = []
+ self.compile_args: T.List[str] = []
+ self.link_args: T.List[str] = []
# Raw -L and -l arguments without manual library searching
# If None, self.link_args will be used
- self.raw_link_args = None
- self.sources = []
- self.methods = self._process_method_kw(kwargs)
+ self.raw_link_args: T.Optional[T.List[str]] = None
+ self.sources: T.List[T.Union['FileOrString', 'CustomTarget']] = []
self.include_type = self._process_include_type_kw(kwargs)
- self.ext_deps = [] # type: T.List[Dependency]
+ self.ext_deps: T.List[Dependency] = []
- def __repr__(self):
- s = '<{0} {1}: {2}>'
- return s.format(self.__class__.__name__, self.name, self.is_found)
+ def __repr__(self) -> str:
+ return f'<{self.__class__.__name__} {self.name}: {self.is_found}>'
+
+ def is_built(self) -> bool:
+ return False
- def get_compile_args(self):
+ def summary_value(self) -> T.Union[str, mlog.AnsiDecorator, mlog.AnsiText]:
+ if not self.found():
+ return mlog.red('NO')
+ if not self.version:
+ return mlog.green('YES')
+ return mlog.AnsiText(mlog.green('YES'), ' ', mlog.cyan(self.version))
+
+ def get_compile_args(self) -> T.List[str]:
if self.include_type == 'system':
converted = []
for i in self.compile_args:
@@ -152,27 +124,33 @@
return converted
return self.compile_args
- def get_link_args(self, raw: bool = False) -> T.List[str]:
+ def get_all_compile_args(self) -> T.List[str]:
+ """Get the compile arguments from this dependency and it's sub dependencies."""
+ return list(itertools.chain(self.get_compile_args(),
+ *(d.get_all_compile_args() for d in self.ext_deps)))
+
+ def get_link_args(self, language: T.Optional[str] = None, raw: bool = False) -> T.List[str]:
if raw and self.raw_link_args is not None:
return self.raw_link_args
return self.link_args
- def found(self):
+ def get_all_link_args(self) -> T.List[str]:
+ """Get the link arguments from this dependency and it's sub dependencies."""
+ return list(itertools.chain(self.get_link_args(),
+ *(d.get_all_link_args() for d in self.ext_deps)))
+
+ def found(self) -> bool:
return self.is_found
- def get_sources(self):
+ def get_sources(self) -> T.List[T.Union['FileOrString', 'CustomTarget']]:
"""Source files that need to be added to the target.
As an example, gtest-all.cc when using GTest."""
return self.sources
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO]
-
- def get_name(self):
+ def get_name(self) -> str:
return self.name
- def get_version(self):
+ def get_version(self) -> str:
if self.version:
return self.version
else:
@@ -181,18 +159,18 @@
def get_include_type(self) -> str:
return self.include_type
- def get_exe_args(self, compiler):
+ def get_exe_args(self, compiler: 'Compiler') -> T.List[str]:
return []
- def get_pkgconfig_variable(self, variable_name, kwargs):
- raise DependencyException('{!r} is not a pkgconfig dependency'.format(self.name))
+ def get_pkgconfig_variable(self, variable_name: str, kwargs: T.Dict[str, T.Any]) -> str:
+ raise DependencyException(f'{self.name!r} is not a pkgconfig dependency')
- def get_configtool_variable(self, variable_name):
- raise DependencyException('{!r} is not a config-tool dependency'.format(self.name))
+ def get_configtool_variable(self, variable_name: str) -> str:
+ raise DependencyException(f'{self.name!r} is not a config-tool dependency')
def get_partial_dependency(self, *, compile_args: bool = False,
link_args: bool = False, links: bool = False,
- includes: bool = False, sources: bool = False):
+ includes: bool = False, sources: bool = False) -> 'Dependency':
"""Create a new dependency that contains part of the parent dependency.
The following options can be inherited:
@@ -208,35 +186,42 @@
"""
raise RuntimeError('Unreachable code in partial_dependency called')
- def _add_sub_dependency(self, dep_type: T.Type['Dependency'], env: Environment,
- kwargs: T.Dict[str, T.Any], *,
- method: DependencyMethods = DependencyMethods.AUTO) -> None:
- """Add an internal dependency of of the given type.
-
- This method is intended to simplify cases of adding a dependency on
- another dependency type (such as threads). This will by default set
- the method back to auto, but the 'method' keyword argument can be
- used to overwrite this behavior.
+ def _add_sub_dependency(self, deplist: T.Iterable[T.Callable[[], 'Dependency']]) -> bool:
+ """Add an internal dependency from a list of possible dependencies.
+
+ This method is intended to make it easier to add additional
+ dependencies to another dependency internally.
+
+ Returns true if the dependency was successfully added, false
+ otherwise.
"""
- kwargs = kwargs.copy()
- kwargs['method'] = method
- self.ext_deps.append(dep_type(env, kwargs))
+ for d in deplist:
+ dep = d()
+ if dep.is_found:
+ self.ext_deps.append(dep)
+ return True
+ return False
def get_variable(self, *, cmake: T.Optional[str] = None, pkgconfig: T.Optional[str] = None,
- configtool: T.Optional[str] = None, default_value: T.Optional[str] = None,
+ configtool: T.Optional[str] = None, internal: T.Optional[str] = None,
+ default_value: T.Optional[str] = None,
pkgconfig_define: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
if default_value is not None:
return default_value
- raise DependencyException('No default provided for dependency {!r}, which is not pkg-config, cmake, or config-tool based.'.format(self))
+ raise DependencyException(f'No default provided for dependency {self!r}, which is not pkg-config, cmake, or config-tool based.')
- def generate_system_dependency(self, include_type: str) -> T.Type['Dependency']:
+ def generate_system_dependency(self, include_type: str) -> 'Dependency':
new_dep = copy.deepcopy(self)
new_dep.include_type = self._process_include_type_kw({'include_type': include_type})
return new_dep
class InternalDependency(Dependency):
- def __init__(self, version, incdirs, compile_args, link_args, libraries, whole_libraries, sources, ext_deps):
- super().__init__('internal', {})
+ def __init__(self, version: str, incdirs: T.List[str], compile_args: T.List[str],
+ link_args: T.List[str], libraries: T.List['BuildTarget'],
+ whole_libraries: T.List['BuildTarget'],
+ sources: T.Sequence[T.Union['FileOrString', 'CustomTarget']],
+ ext_deps: T.List[Dependency], variables: T.Dict[str, T.Any]):
+ super().__init__(DependencyTypeName('internal'), {})
self.version = version
self.is_found = True
self.include_directories = incdirs
@@ -244,20 +229,42 @@
self.link_args = link_args
self.libraries = libraries
self.whole_libraries = whole_libraries
- self.sources = sources
+ self.sources = list(sources)
self.ext_deps = ext_deps
+ self.variables = variables
+
+ def __deepcopy__(self, memo: T.Dict[int, 'InternalDependency']) -> 'InternalDependency':
+ result = self.__class__.__new__(self.__class__)
+ assert isinstance(result, InternalDependency)
+ memo[id(self)] = result
+ for k, v in self.__dict__.items():
+ if k in ['libraries', 'whole_libraries']:
+ setattr(result, k, copy.copy(v))
+ else:
+ setattr(result, k, copy.deepcopy(v, memo))
+ return result
- def get_pkgconfig_variable(self, variable_name, kwargs):
+ def summary_value(self) -> mlog.AnsiDecorator:
+ # Omit the version. Most of the time it will be just the project
+ # version, which is uninteresting in the summary.
+ return mlog.green('YES')
+
+ def is_built(self) -> bool:
+ if self.sources or self.libraries or self.whole_libraries:
+ return True
+ return any(d.is_built() for d in self.ext_deps)
+
+ def get_pkgconfig_variable(self, variable_name: str, kwargs: T.Dict[str, T.Any]) -> str:
raise DependencyException('Method "get_pkgconfig_variable()" is '
'invalid for an internal dependency')
- def get_configtool_variable(self, variable_name):
+ def get_configtool_variable(self, variable_name: str) -> str:
raise DependencyException('Method "get_configtool_variable()" is '
'invalid for an internal dependency')
def get_partial_dependency(self, *, compile_args: bool = False,
link_args: bool = False, links: bool = False,
- includes: bool = False, sources: bool = False):
+ includes: bool = False, sources: bool = False) -> 'InternalDependency':
final_compile_args = self.compile_args.copy() if compile_args else []
final_link_args = self.link_args.copy() if link_args else []
final_libraries = self.libraries.copy() if links else []
@@ -270,17 +277,38 @@
return InternalDependency(
self.version, final_includes, final_compile_args,
final_link_args, final_libraries, final_whole_libraries,
- final_sources, final_deps)
+ final_sources, final_deps, self.variables)
+
+ 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: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
+ val = self.variables.get(internal, default_value)
+ if val is not None:
+ # TODO: Try removing this assert by better typing self.variables
+ if isinstance(val, str):
+ return val
+ if isinstance(val, list):
+ for i in val:
+ assert isinstance(i, str)
+ return val
+ raise DependencyException(f'Could not get an internal variable and no default provided for {self!r}')
+
+ def generate_link_whole_dependency(self) -> Dependency:
+ new_dep = copy.deepcopy(self)
+ new_dep.whole_libraries += new_dep.libraries
+ new_dep.libraries = []
+ return new_dep
class HasNativeKwarg:
- def __init__(self, kwargs):
+ def __init__(self, kwargs: T.Dict[str, T.Any]):
self.for_machine = self.get_for_machine_from_kwargs(kwargs)
- def get_for_machine_from_kwargs(self, kwargs):
+ def get_for_machine_from_kwargs(self, kwargs: T.Dict[str, T.Any]) -> MachineChoice:
return MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST
class ExternalDependency(Dependency, HasNativeKwarg):
- def __init__(self, type_name, environment, language, kwargs):
+ def __init__(self, type_name: DependencyTypeName, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None):
Dependency.__init__(self, type_name, kwargs)
self.env = environment
self.name = type_name # default
@@ -292,36 +320,19 @@
self.required = kwargs.get('required', True)
self.silent = kwargs.get('silent', False)
self.static = kwargs.get('static', False)
+ self.libtype = LibType.STATIC if self.static else LibType.PREFER_SHARED
if not isinstance(self.static, bool):
raise DependencyException('Static keyword must be boolean')
# Is this dependency to be run on the build platform?
HasNativeKwarg.__init__(self, kwargs)
- self.clib_compiler = None
- # Set the compiler that will be used by this dependency
- # This is only used for configuration checks
- compilers = self.env.coredata.compilers[self.for_machine]
- # Set the compiler for this dependency if a language is specified,
- # else try to pick something that looks usable.
- if self.language:
- if self.language not in compilers:
- m = self.name.capitalize() + ' requires a {0} compiler, but ' \
- '{0} is not in the list of project languages'
- raise DependencyException(m.format(self.language.capitalize()))
- self.clib_compiler = compilers[self.language]
- else:
- # Try to find a compiler that can find C libraries for
- # running compiler.find_library()
- for lang in clib_langs:
- self.clib_compiler = compilers.get(lang, None)
- if self.clib_compiler:
- break
+ self.clib_compiler = detect_compiler(self.name, environment, self.for_machine, self.language)
- def get_compiler(self):
+ def get_compiler(self) -> 'Compiler':
return self.clib_compiler
def get_partial_dependency(self, *, compile_args: bool = False,
link_args: bool = False, links: bool = False,
- includes: bool = False, sources: bool = False):
+ includes: bool = False, sources: bool = False) -> Dependency:
new = copy.copy(self)
if not compile_args:
new.compile_args = []
@@ -330,37 +341,38 @@
if not sources:
new.sources = []
if not includes:
- new.include_directories = []
+ pass # TODO maybe filter compile_args?
if not sources:
new.sources = []
return new
- def log_details(self):
+ def log_details(self) -> str:
return ''
- def log_info(self):
+ def log_info(self) -> str:
return ''
- def log_tried(self):
+ def log_tried(self) -> str:
return ''
# Check if dependency version meets the requirements
- def _check_version(self):
+ def _check_version(self) -> None:
if not self.is_found:
return
if self.version_reqs:
# an unknown version can never satisfy any requirement
if not self.version:
- found_msg = ['Dependency', mlog.bold(self.name), 'found:']
- found_msg += [mlog.red('NO'), 'unknown version, but need:',
- self.version_reqs]
+ self.is_found = False
+ found_msg: mlog.TV_LoggableList = []
+ found_msg += ['Dependency', mlog.bold(self.name), 'found:']
+ found_msg += [mlog.red('NO'), 'unknown version, but need:', self.version_reqs]
mlog.log(*found_msg)
if self.required:
- m = 'Unknown version of dependency {!r}, but need {!r}.'
- raise DependencyException(m.format(self.name, self.version_reqs))
+ m = f'Unknown version of dependency {self.name!r}, but need {self.version_reqs!r}.'
+ raise DependencyException(m)
else:
(self.is_found, not_found, found) = \
@@ -369,10 +381,10 @@
found_msg = ['Dependency', mlog.bold(self.name), 'found:']
found_msg += [mlog.red('NO'),
'found', mlog.normal_cyan(self.version), 'but need:',
- mlog.bold(', '.join(["'{}'".format(e) for e in not_found]))]
+ mlog.bold(', '.join([f"'{e}'" for e in not_found]))]
if found:
found_msg += ['; matched:',
- ', '.join(["'{}'".format(e) for e in found])]
+ ', '.join([f"'{e}'" for e in found])]
mlog.log(*found_msg)
if self.required:
@@ -382,1655 +394,22 @@
class NotFoundDependency(Dependency):
- def __init__(self, environment):
- super().__init__('not-found', {})
+ def __init__(self, name: str, environment: 'Environment') -> None:
+ super().__init__(DependencyTypeName('not-found'), {})
self.env = environment
- self.name = 'not-found'
+ self.name = name
self.is_found = False
def get_partial_dependency(self, *, compile_args: bool = False,
link_args: bool = False, links: bool = False,
- includes: bool = False, sources: bool = False):
+ includes: bool = False, sources: bool = False) -> 'NotFoundDependency':
return copy.copy(self)
-class ConfigToolDependency(ExternalDependency):
-
- """Class representing dependencies found using a config tool."""
-
- tools = None
- tool_name = None
- __strip_version = re.compile(r'^[0-9][0-9.]+')
-
- def __init__(self, name, environment, language, kwargs):
- super().__init__('config-tool', environment, language, kwargs)
- self.name = name
- self.tools = listify(kwargs.get('tools', self.tools))
-
- req_version = kwargs.get('version', None)
- tool, version = self.find_config(req_version)
- self.config = tool
- self.is_found = self.report_config(version, req_version)
- if not self.is_found:
- self.config = None
- return
- self.version = version
- if getattr(self, 'finish_init', None):
- self.finish_init(self)
-
- def _sanitize_version(self, version):
- """Remove any non-numeric, non-point version suffixes."""
- m = self.__strip_version.match(version)
- if m:
- # Ensure that there isn't a trailing '.', such as an input like
- # `1.2.3.git-1234`
- return m.group(0).rstrip('.')
- return version
-
- @classmethod
- def factory(cls, name, environment, language, kwargs, tools, tool_name, finish_init=None):
- """Constructor for use in dependencies that can be found multiple ways.
-
- In addition to the standard constructor values, this constructor sets
- the tool_name and tools values of the instance.
- """
- # This deserves some explanation, because metaprogramming is hard.
- # This uses type() to create a dynamic subclass of ConfigToolDependency
- # with the tools and tool_name class attributes set, this class is then
- # instantiated and returned. The reduce function (method) is also
- # attached, since python's pickle module won't be able to do anything
- # with this dynamically generated class otherwise.
- def reduce(self):
- return (cls._unpickle, (), self.__dict__)
- sub = type('{}Dependency'.format(name.capitalize()), (cls, ),
- {'tools': tools, 'tool_name': tool_name, '__reduce__': reduce, 'finish_init': staticmethod(finish_init)})
-
- return sub(name, environment, language, kwargs)
-
- @classmethod
- def _unpickle(cls):
- return cls.__new__(cls)
-
- def find_config(self, versions=None):
- """Helper method that searches for config tool binaries in PATH and
- returns the one that best matches the given version requirements.
- """
- if not isinstance(versions, list) and versions is not None:
- versions = listify(versions)
-
- tool = self.env.binaries[self.for_machine].lookup_entry(self.tool_name)
- if tool is not None:
- tools = [tool]
- else:
- if not self.env.machines.matches_build_machine(self.for_machine):
- mlog.deprecation('No entry for {0} specified in your cross file. '
- 'Falling back to searching PATH. This may find a '
- 'native version of {0}! This will become a hard '
- 'error in a future version of meson'.format(self.tool_name))
- tools = [[t] for t in self.tools]
-
- best_match = (None, None)
- for tool in tools:
- if len(tool) == 1:
- # In some situations the command can't be directly executed.
- # For example Shell scripts need to be called through sh on
- # Windows (see issue #1423).
- potential_bin = ExternalProgram(tool[0], silent=True)
- if not potential_bin.found():
- continue
- tool = potential_bin.get_command()
- try:
- p, out = Popen_safe(tool + ['--version'])[:2]
- except (FileNotFoundError, PermissionError):
- continue
- if p.returncode != 0:
- continue
-
- out = self._sanitize_version(out.strip())
- # Some tools, like pcap-config don't supply a version, but also
- # don't fail with --version, in that case just assume that there is
- # only one version and return it.
- if not out:
- return (tool, None)
- if versions:
- is_found = version_compare_many(out, versions)[0]
- # This allows returning a found version without a config tool,
- # which is useful to inform the user that you found version x,
- # but y was required.
- if not is_found:
- tool = None
- if best_match[1]:
- if version_compare(out, '> {}'.format(best_match[1])):
- best_match = (tool, out)
- else:
- best_match = (tool, out)
-
- return best_match
-
- def report_config(self, version, req_version):
- """Helper method to print messages about the tool."""
-
- found_msg = [mlog.bold(self.tool_name), 'found:']
-
- if self.config is None:
- found_msg.append(mlog.red('NO'))
- if version is not None and req_version is not None:
- found_msg.append('found {!r} but need {!r}'.format(version, req_version))
- elif req_version:
- found_msg.append('need {!r}'.format(req_version))
- else:
- found_msg += [mlog.green('YES'), '({})'.format(' '.join(self.config)), version]
-
- mlog.log(*found_msg)
-
- return self.config is not None
-
- def get_config_value(self, args, stage):
- p, out, err = Popen_safe(self.config + args)
- if p.returncode != 0:
- if self.required:
- raise DependencyException(
- 'Could not generate {} for {}.\n{}'.format(
- stage, self.name, err))
- return []
- return split_args(out)
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.CONFIG_TOOL]
-
- def get_configtool_variable(self, variable_name):
- p, out, _ = Popen_safe(self.config + ['--{}'.format(variable_name)])
- if p.returncode != 0:
- if self.required:
- raise DependencyException(
- 'Could not get variable "{}" for dependency {}'.format(
- variable_name, self.name))
- variable = out.strip()
- mlog.debug('Got config-tool variable {} : {}'.format(variable_name, variable))
- return variable
-
- def log_tried(self):
- return self.type_name
-
- def get_variable(self, *, cmake: T.Optional[str] = None, pkgconfig: T.Optional[str] = None,
- configtool: T.Optional[str] = None, default_value: T.Optional[str] = None,
- pkgconfig_define: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
- if configtool:
- # In the not required case '' (empty string) will be returned if the
- # variable is not found. Since '' is a valid value to return we
- # set required to True here to force and error, and use the
- # finally clause to ensure it's restored.
- restore = self.required
- self.required = True
- try:
- return self.get_configtool_variable(configtool)
- except DependencyException:
- pass
- finally:
- self.required = restore
- if default_value is not None:
- return default_value
- raise DependencyException('Could not get config-tool variable and no default provided for {!r}'.format(self))
-
-
-class PkgConfigDependency(ExternalDependency):
- # The class's copy of the pkg-config path. Avoids having to search for it
- # multiple times in the same Meson invocation.
- class_pkgbin = PerMachine(None, None)
- # We cache all pkg-config subprocess invocations to avoid redundant calls
- pkgbin_cache = {}
-
- def __init__(self, name, environment, kwargs, language=None):
- super().__init__('pkgconfig', environment, language, kwargs)
- self.name = name
- self.is_libtool = False
- # Store a copy of the pkg-config path on the object itself so it is
- # stored in the pickled coredata and recovered.
- self.pkgbin = None
-
- # Create an iterator of options
- def search():
- # Lookup in cross or machine file.
- potential_pkgpath = environment.binaries[self.for_machine].lookup_entry('pkgconfig')
- if potential_pkgpath is not None:
- mlog.debug('Pkg-config binary for {} specified from cross file, native file, '
- 'or env var as {}'.format(self.for_machine, potential_pkgpath))
- yield ExternalProgram.from_entry('pkgconfig', potential_pkgpath)
- # We never fallback if the user-specified option is no good, so
- # stop returning options.
- return
- mlog.debug('Pkg-config binary missing from cross or native file, or env var undefined.')
- # Fallback on hard-coded defaults.
- # TODO prefix this for the cross case instead of ignoring thing.
- if environment.machines.matches_build_machine(self.for_machine):
- for potential_pkgpath in environment.default_pkgconfig:
- mlog.debug('Trying a default pkg-config fallback at', potential_pkgpath)
- yield ExternalProgram(potential_pkgpath, silent=True)
-
- # Only search for pkg-config for each machine the first time and store
- # the result in the class definition
- if PkgConfigDependency.class_pkgbin[self.for_machine] is False:
- mlog.debug('Pkg-config binary for %s is cached as not found.' % self.for_machine)
- elif PkgConfigDependency.class_pkgbin[self.for_machine] is not None:
- mlog.debug('Pkg-config binary for %s is cached.' % self.for_machine)
- else:
- assert PkgConfigDependency.class_pkgbin[self.for_machine] is None
- mlog.debug('Pkg-config binary for %s is not cached.' % self.for_machine)
- for potential_pkgbin in search():
- mlog.debug('Trying pkg-config binary {} for machine {} at {}'
- .format(potential_pkgbin.name, self.for_machine, potential_pkgbin.command))
- version_if_ok = self.check_pkgconfig(potential_pkgbin)
- if not version_if_ok:
- continue
- if not self.silent:
- mlog.log('Found pkg-config:', mlog.bold(potential_pkgbin.get_path()),
- '(%s)' % version_if_ok)
- PkgConfigDependency.class_pkgbin[self.for_machine] = potential_pkgbin
- break
- else:
- if not self.silent:
- mlog.log('Found Pkg-config:', mlog.red('NO'))
- # Set to False instead of None to signify that we've already
- # searched for it and not found it
- PkgConfigDependency.class_pkgbin[self.for_machine] = False
-
- self.pkgbin = PkgConfigDependency.class_pkgbin[self.for_machine]
- if self.pkgbin is False:
- self.pkgbin = None
- msg = 'Pkg-config binary for machine %s not found. Giving up.' % self.for_machine
- if self.required:
- raise DependencyException(msg)
- else:
- mlog.debug(msg)
- return
-
- mlog.debug('Determining dependency {!r} with pkg-config executable '
- '{!r}'.format(name, self.pkgbin.get_path()))
- ret, self.version, _ = self._call_pkgbin(['--modversion', name])
- if ret != 0:
- return
-
- self.is_found = True
-
- try:
- # Fetch cargs to be used while using this dependency
- self._set_cargs()
- # Fetch the libraries and library paths needed for using this
- self._set_libs()
- except DependencyException as e:
- mlog.debug("pkg-config error with '%s': %s" % (name, e))
- if self.required:
- raise
- else:
- self.compile_args = []
- self.link_args = []
- self.is_found = False
- self.reason = e
-
- def __repr__(self):
- s = '<{0} {1}: {2} {3}>'
- return s.format(self.__class__.__name__, self.name, self.is_found,
- self.version_reqs)
-
- def _call_pkgbin_real(self, args, env):
- cmd = self.pkgbin.get_command() + args
- p, out, err = Popen_safe(cmd, env=env)
- rc, out, err = p.returncode, out.strip(), err.strip()
- call = ' '.join(cmd)
- mlog.debug("Called `{}` -> {}\n{}".format(call, rc, out))
- return rc, out, err
-
- def _call_pkgbin(self, args, env=None):
- # Always copy the environment since we're going to modify it
- # with pkg-config variables
- if env is None:
- env = os.environ.copy()
- else:
- env = env.copy()
-
- extra_paths = self.env.coredata.builtins_per_machine[self.for_machine]['pkg_config_path'].value
- sysroot = self.env.properties[self.for_machine].get_sys_root()
- if sysroot:
- env['PKG_CONFIG_SYSROOT_DIR'] = sysroot
- new_pkg_config_path = ':'.join([p for p in extra_paths])
- mlog.debug('PKG_CONFIG_PATH: ' + new_pkg_config_path)
- env['PKG_CONFIG_PATH'] = new_pkg_config_path
-
- fenv = frozenset(env.items())
- targs = tuple(args)
- cache = PkgConfigDependency.pkgbin_cache
- if (self.pkgbin, targs, fenv) not in cache:
- cache[(self.pkgbin, targs, fenv)] = self._call_pkgbin_real(args, env)
- return cache[(self.pkgbin, targs, fenv)]
-
- def _convert_mingw_paths(self, args: T.List[str]) -> T.List[str]:
- '''
- Both MSVC and native Python on Windows cannot handle MinGW-esque /c/foo
- paths so convert them to C:/foo. We cannot resolve other paths starting
- with / like /home/foo so leave them as-is so that the user gets an
- error/warning from the compiler/linker.
- '''
- if not mesonlib.is_windows():
- return args
- converted = []
- for arg in args:
- pargs = []
- # Library search path
- if arg.startswith('-L/'):
- pargs = PurePath(arg[2:]).parts
- tmpl = '-L{}:/{}'
- elif arg.startswith('-I/'):
- pargs = PurePath(arg[2:]).parts
- tmpl = '-I{}:/{}'
- # Full path to library or .la file
- elif arg.startswith('/'):
- pargs = PurePath(arg).parts
- tmpl = '{}:/{}'
- elif arg.startswith(('-L', '-I')) or (len(arg) > 2 and arg[1] == ':'):
- # clean out improper '\\ ' as comes from some Windows pkg-config files
- arg = arg.replace('\\ ', ' ')
- if len(pargs) > 1 and len(pargs[1]) == 1:
- arg = tmpl.format(pargs[1], '/'.join(pargs[2:]))
- converted.append(arg)
- return converted
-
- def _split_args(self, cmd):
- # pkg-config paths follow Unix conventions, even on Windows; split the
- # output using shlex.split rather than mesonlib.split_args
- return shlex.split(cmd)
-
- def _set_cargs(self):
- env = None
- if self.language == 'fortran':
- # gfortran doesn't appear to look in system paths for INCLUDE files,
- # so don't allow pkg-config to suppress -I flags for system paths
- env = os.environ.copy()
- env['PKG_CONFIG_ALLOW_SYSTEM_CFLAGS'] = '1'
- ret, out, err = self._call_pkgbin(['--cflags', self.name], env=env)
- if ret != 0:
- raise DependencyException('Could not generate cargs for %s:\n%s\n' %
- (self.name, err))
- self.compile_args = self._convert_mingw_paths(self._split_args(out))
-
- def _search_libs(self, out, out_raw):
- '''
- @out: PKG_CONFIG_ALLOW_SYSTEM_LIBS=1 pkg-config --libs
- @out_raw: pkg-config --libs
-
- We always look for the file ourselves instead of depending on the
- compiler to find it with -lfoo or foo.lib (if possible) because:
- 1. We want to be able to select static or shared
- 2. We need the full path of the library to calculate RPATH values
- 3. De-dup of libraries is easier when we have absolute paths
-
- Libraries that are provided by the toolchain or are not found by
- find_library() will be added with -L -l pairs.
- '''
- # Library paths should be safe to de-dup
- #
- # First, figure out what library paths to use. Originally, we were
- # doing this as part of the loop, but due to differences in the order
- # of -L values between pkg-config and pkgconf, we need to do that as
- # a separate step. See:
- # https://github.com/mesonbuild/meson/issues/3951
- # https://github.com/mesonbuild/meson/issues/4023
- #
- # Separate system and prefix paths, and ensure that prefix paths are
- # always searched first.
- prefix_libpaths = OrderedSet()
- # We also store this raw_link_args on the object later
- raw_link_args = self._convert_mingw_paths(self._split_args(out_raw))
- for arg in raw_link_args:
- if arg.startswith('-L') and not arg.startswith(('-L-l', '-L-L')):
- path = arg[2:]
- if not os.path.isabs(path):
- # Resolve the path as a compiler in the build directory would
- path = os.path.join(self.env.get_build_dir(), path)
- prefix_libpaths.add(path)
- # Library paths are not always ordered in a meaningful way
- #
- # Instead of relying on pkg-config or pkgconf to provide -L flags in a
- # specific order, we reorder library paths ourselves, according to th
- # order specified in PKG_CONFIG_PATH. See:
- # https://github.com/mesonbuild/meson/issues/4271
- #
- # Only prefix_libpaths are reordered here because there should not be
- # too many system_libpaths to cause library version issues.
- pkg_config_path = os.environ.get('PKG_CONFIG_PATH')
- if pkg_config_path:
- pkg_config_path = pkg_config_path.split(os.pathsep)
- else:
- pkg_config_path = []
- pkg_config_path = self._convert_mingw_paths(pkg_config_path)
- prefix_libpaths = sort_libpaths(prefix_libpaths, pkg_config_path)
- system_libpaths = OrderedSet()
- full_args = self._convert_mingw_paths(self._split_args(out))
- for arg in full_args:
- if arg.startswith(('-L-l', '-L-L')):
- # These are D language arguments, not library paths
- continue
- if arg.startswith('-L') and arg[2:] not in prefix_libpaths:
- system_libpaths.add(arg[2:])
- # Use this re-ordered path list for library resolution
- libpaths = list(prefix_libpaths) + list(system_libpaths)
- # Track -lfoo libraries to avoid duplicate work
- libs_found = OrderedSet()
- # Track not-found libraries to know whether to add library paths
- libs_notfound = []
- libtype = LibType.STATIC if self.static else LibType.PREFER_SHARED
- # Generate link arguments for this library
- link_args = []
- for lib in full_args:
- if lib.startswith(('-L-l', '-L-L')):
- # These are D language arguments, add them as-is
- pass
- elif lib.startswith('-L'):
- # We already handled library paths above
- continue
- elif lib.startswith('-l'):
- # Don't resolve the same -lfoo argument again
- if lib in libs_found:
- continue
- if self.clib_compiler:
- args = self.clib_compiler.find_library(lib[2:], self.env,
- libpaths, libtype)
- # If the project only uses a non-clib language such as D, Rust,
- # C#, Python, etc, all we can do is limp along by adding the
- # arguments as-is and then adding the libpaths at the end.
- else:
- args = None
- if args is not None:
- libs_found.add(lib)
- # Replace -l arg with full path to library if available
- # else, library is either to be ignored, or is provided by
- # the compiler, can't be resolved, and should be used as-is
- if args:
- if not args[0].startswith('-l'):
- lib = args[0]
- else:
- continue
- else:
- # Library wasn't found, maybe we're looking in the wrong
- # places or the library will be provided with LDFLAGS or
- # LIBRARY_PATH from the environment (on macOS), and many
- # other edge cases that we can't account for.
- #
- # Add all -L paths and use it as -lfoo
- if lib in libs_notfound:
- continue
- if self.static:
- mlog.warning('Static library {!r} not found for dependency {!r}, may '
- 'not be statically linked'.format(lib[2:], self.name))
- libs_notfound.append(lib)
- elif lib.endswith(".la"):
- shared_libname = self.extract_libtool_shlib(lib)
- shared_lib = os.path.join(os.path.dirname(lib), shared_libname)
- if not os.path.exists(shared_lib):
- shared_lib = os.path.join(os.path.dirname(lib), ".libs", shared_libname)
-
- if not os.path.exists(shared_lib):
- raise DependencyException('Got a libtools specific "%s" dependencies'
- 'but we could not compute the actual shared'
- 'library path' % lib)
- self.is_libtool = True
- lib = shared_lib
- if lib in link_args:
- continue
- link_args.append(lib)
- # Add all -Lbar args if we have -lfoo args in link_args
- if libs_notfound:
- # Order of -L flags doesn't matter with ld, but it might with other
- # linkers such as MSVC, so prepend them.
- link_args = ['-L' + lp for lp in prefix_libpaths] + link_args
- return link_args, raw_link_args
-
- def _set_libs(self):
- env = None
- libcmd = [self.name, '--libs']
- if self.static:
- libcmd.append('--static')
- # Force pkg-config to output -L fields even if they are system
- # paths so we can do manual searching with cc.find_library() later.
- env = os.environ.copy()
- env['PKG_CONFIG_ALLOW_SYSTEM_LIBS'] = '1'
- ret, out, err = self._call_pkgbin(libcmd, env=env)
- if ret != 0:
- raise DependencyException('Could not generate libs for %s:\n%s\n' %
- (self.name, err))
- # Also get the 'raw' output without -Lfoo system paths for adding -L
- # args with -lfoo when a library can't be found, and also in
- # gnome.generate_gir + gnome.gtkdoc which need -L -l arguments.
- ret, out_raw, err_raw = self._call_pkgbin(libcmd)
- if ret != 0:
- raise DependencyException('Could not generate libs for %s:\n\n%s' %
- (self.name, out_raw))
- self.link_args, self.raw_link_args = self._search_libs(out, out_raw)
-
- def get_pkgconfig_variable(self, variable_name, kwargs):
- options = ['--variable=' + variable_name, self.name]
-
- if 'define_variable' in kwargs:
- definition = kwargs.get('define_variable', [])
- if not isinstance(definition, list):
- raise DependencyException('define_variable takes a list')
-
- if len(definition) != 2 or not all(isinstance(i, str) for i in definition):
- raise DependencyException('define_variable must be made up of 2 strings for VARIABLENAME and VARIABLEVALUE')
-
- options = ['--define-variable=' + '='.join(definition)] + options
-
- ret, out, err = self._call_pkgbin(options)
- variable = ''
- if ret != 0:
- if self.required:
- raise DependencyException('dependency %s not found:\n%s\n' %
- (self.name, err))
- else:
- variable = out.strip()
-
- # pkg-config doesn't distinguish between empty and non-existent variables
- # use the variable list to check for variable existence
- if not variable:
- ret, out, _ = self._call_pkgbin(['--print-variables', self.name])
- if not re.search(r'^' + variable_name + r'$', out, re.MULTILINE):
- if 'default' in kwargs:
- variable = kwargs['default']
- else:
- mlog.warning("pkgconfig variable '%s' not defined for dependency %s." % (variable_name, self.name))
-
- mlog.debug('Got pkgconfig variable %s : %s' % (variable_name, variable))
- return variable
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG]
-
- def check_pkgconfig(self, pkgbin):
- if not pkgbin.found():
- mlog.log('Did not find pkg-config by name {!r}'.format(pkgbin.name))
- return None
- try:
- p, out = Popen_safe(pkgbin.get_command() + ['--version'])[0:2]
- if p.returncode != 0:
- mlog.warning('Found pkg-config {!r} but it failed when run'
- ''.format(' '.join(pkgbin.get_command())))
- return None
- except FileNotFoundError:
- mlog.warning('We thought we found pkg-config {!r} but now it\'s not there. How odd!'
- ''.format(' '.join(pkgbin.get_command())))
- return None
- except PermissionError:
- msg = 'Found pkg-config {!r} but didn\'t have permissions to run it.'.format(' '.join(pkgbin.get_command()))
- if not mesonlib.is_windows():
- msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
- mlog.warning(msg)
- return None
- return out.strip()
-
- def extract_field(self, la_file, fieldname):
- with open(la_file) as f:
- for line in f:
- arr = line.strip().split('=')
- if arr[0] == fieldname:
- return arr[1][1:-1]
- return None
-
- def extract_dlname_field(self, la_file):
- return self.extract_field(la_file, 'dlname')
-
- def extract_libdir_field(self, la_file):
- return self.extract_field(la_file, 'libdir')
-
- def extract_libtool_shlib(self, la_file):
- '''
- Returns the path to the shared library
- corresponding to this .la file
- '''
- dlname = self.extract_dlname_field(la_file)
- if dlname is None:
- return None
-
- # Darwin uses absolute paths where possible; since the libtool files never
- # contain absolute paths, use the libdir field
- if mesonlib.is_osx():
- dlbasename = os.path.basename(dlname)
- libdir = self.extract_libdir_field(la_file)
- if libdir is None:
- return dlbasename
- return os.path.join(libdir, dlbasename)
- # From the comments in extract_libtool(), older libtools had
- # a path rather than the raw dlname
- return os.path.basename(dlname)
-
- def log_tried(self):
- return self.type_name
-
- def get_variable(self, *, cmake: T.Optional[str] = None, pkgconfig: T.Optional[str] = None,
- configtool: T.Optional[str] = None, default_value: T.Optional[str] = None,
- pkgconfig_define: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
- if pkgconfig:
- kwargs = {}
- if default_value is not None:
- kwargs['default'] = default_value
- if pkgconfig_define is not None:
- kwargs['define_variable'] = pkgconfig_define
- try:
- return self.get_pkgconfig_variable(pkgconfig, kwargs)
- except DependencyException:
- pass
- if default_value is not None:
- return default_value
- raise DependencyException('Could not get pkg-config variable and no default provided for {!r}'.format(self))
-
-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(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 = None
-
- def _gen_exception(self, msg):
- return DependencyException('Dependency {} not found: {}'.format(self.name, 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]]) -> 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.
- return modules
-
- 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, language: str = None):
- # Gather a list of all languages to support
- self.language_list = [] # type: T.List[str]
- if language is None:
- 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__('cmake', environment, language, kwargs)
- 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 = None
- self.cmakeinfo = None
- self.traceparser = CMakeTraceParser()
-
- # Where all CMake "build dirs" are located
- self.cmake_root_dir = environment.scratch_dir
-
- # T.List of successfully found modules
- self.found_modules = []
-
- self.cmakebin = CMakeExecutor(environment, CMakeDependency.class_cmake_version, self.for_machine, silent=self.silent)
- if not self.cmakebin.found():
- self.cmakebin = None
- msg = 'No CMake binary for machine %s not found. Giving up.' % self.for_machine
- if self.required:
- raise DependencyException(msg)
- mlog.debug(msg)
- return
-
- if CMakeDependency.class_cmakeinfo[self.for_machine] is None:
- CMakeDependency.class_cmakeinfo[self.for_machine] = self._get_cmake_info()
- self.cmakeinfo = CMakeDependency.class_cmakeinfo[self.for_machine]
- if self.cmakeinfo is None:
- raise self._gen_exception('Unable to obtain CMake system information')
-
- 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]
- cm_args = stringlistify(extract_as_list(kwargs, 'cmake_args'))
- if cm_path:
- cm_args.append('-DCMAKE_MODULE_PATH=' + ';'.join(cm_path))
-
- pref_path = self.env.coredata.builtins_per_machine[self.for_machine]['cmake_prefix_path'].value
- if 'CMAKE_PREFIX_PATH' in os.environ:
- env_pref_path = os.environ['CMAKE_PREFIX_PATH'].split(os.pathsep)
- env_pref_path = [x for x in env_pref_path if x] # Filter out empty strings
- if not pref_path:
- pref_path = []
- pref_path += env_pref_path
- if pref_path:
- cm_args.append('-DCMAKE_PREFIX_PATH={}'.format(';'.join(pref_path)))
-
- if not self._preliminary_find_check(name, cm_path, pref_path, environment.machines[self.for_machine]):
- mlog.debug('Preliminary CMake check failed. Aborting.')
- return
- self._detect_dep(name, modules, cm_args)
-
- def __repr__(self):
- s = '<{0} {1}: {2} {3}>'
- return s.format(self.__class__.__name__, self.name, self.is_found,
- self.version_reqs)
-
- def _get_cmake_info(self):
- mlog.debug("Extracting basic cmake information")
- res = {}
-
- # 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
-
- for i in gen_list:
- mlog.debug('Try CMake generator: {}'.format(i if len(i) > 0 else 'auto'))
-
- # Prepare options
- cmake_opts = ['--trace-expand', '.']
- 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('CMake failed to gather system information for generator {} with error code {}'.format(i, ret1))
- mlog.debug('OUT:\n{}\n\n\nERR:\n{}\n\n'.format(out1, err1))
-
- # Check if any generator succeeded
- if ret1 != 0:
- return None
-
- try:
- temp_parser = CMakeTraceParser()
- temp_parser.parse(err1)
- except MesonException:
- return None
-
- # Extract the variables and sanity check them
- root_paths = set(temp_parser.get_cmake_var('MESON_FIND_ROOT_PATH'))
- root_paths.update(set(temp_parser.get_cmake_var('MESON_CMAKE_SYSROOT')))
- root_paths = sorted(root_paths)
- root_paths = list(filter(lambda x: os.path.isdir(x), root_paths))
- module_paths = set(temp_parser.get_cmake_var('MESON_PATHS_LIST'))
- rooted_paths = []
- for j in [Path(x) for x in root_paths]:
- for i in [Path(x) for x in module_paths]:
- rooted_paths.append(str(j / i.relative_to(i.anchor)))
- module_paths = sorted(module_paths.union(rooted_paths))
- module_paths = list(filter(lambda x: os.path.isdir(x), module_paths))
- 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 = {
- 'module_paths': module_paths,
- 'cmake_root': temp_parser.get_cmake_var('MESON_CMAKE_ROOT')[0],
- 'archs': archs,
- 'common_paths': common_paths
- }
-
- mlog.debug(' -- Module search paths: {}'.format(res['module_paths']))
- mlog.debug(' -- CMake root: {}'.format(res['cmake_root']))
- mlog.debug(' -- CMake architectures: {}'.format(res['archs']))
- mlog.debug(' -- CMake lib search paths: {}'.format(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 ()
-
- @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 , /cmake, /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 insensitve
- 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 /(lib/|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 /(lib/|lib*|share)/cmake/*/
- cm_dir = os.path.join(i, 'cmake')
- if self._cached_isdir(cm_dir):
- content = self._cached_listdir(cm_dir)
- content = list(filter(lambda x: x[1].startswith(lname), content))
- for k in content:
- if find_module(os.path.join(cm_dir, k[0])):
- return True
-
- # /(lib/|lib*|share)/*/
- # /(lib/|lib*|share)/*/(cmake|CMake)/
- content = self._cached_listdir(i)
- content = list(filter(lambda x: x[1].startswith(lname), content))
- 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 the system paths
- for i in self.cmakeinfo['module_paths']:
- if find_module(i):
- return True
-
- if search_lib_dirs(i):
- return True
-
- content = self._cached_listdir(i)
- content = list(filter(lambda x: x[1].startswith(lname), content))
- 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 ['{}.framework', '{}.app']:
- j = j.format(lname)
- if j in content:
- if find_module(os.path.join(i, j[0], 'Resources')) or find_module(os.path.join(i, j[0], 'Version')):
- return True
-
- # Check the environment path
- env_path = os.environ.get('{}_DIR'.format(name))
- if env_path and find_module(env_path):
- return True
-
- return False
-
- def _detect_dep(self, name: str, modules: T.List[T.Tuple[str, bool]], args: T.List[str]):
- # 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
-
- for i in gen_list:
- mlog.debug('Try CMake generator: {}'.format(i if len(i) > 0 else 'auto'))
-
- # Prepare options
- cmake_opts = ['--trace-expand', '-DNAME={}'.format(name), '-DARCHS={}'.format(';'.join(self.cmakeinfo['archs']))] + args + ['.']
- cmake_opts += self._extra_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('CMake failed for generator {} and package {} with error code {}'.format(i, name, ret1))
- mlog.debug('OUT:\n{}\n\n\nERR:\n{}\n\n'.format(out1, err1))
-
- # Check if any generator succeeded
- if ret1 != 0:
- return
-
- try:
- self.traceparser.parse(err1)
- except CMakeException as e:
- e = self._gen_exception(str(e))
- if self.required:
- raise
- else:
- self.compile_args = []
- self.link_args = []
- self.is_found = False
- self.reason = e
- 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)
- 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 '{}::{}'.format(lname, lname) == tg or lname == tg.replace('::', ''):
- mlog.debug('Guessed CMake target \'{}\''.format(i))
- modules = [(i, True)]
- autodetected_module_list = True
- break
-
- # Failed to guess a target --> try the old-style method
- if len(modules) == 0:
- 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 = [x for x in self.traceparser.get_cmake_var('PACKAGE_LIBRARIES') if x]
-
- # Try to use old style variables if no module is specified
- if len(libs) > 0:
- self.compile_args = list(map(lambda x: '-I{}'.format(x), incDirs)) + defs
- self.link_args = libs
- mlog.debug('using old-style CMake variables for dependency {}'.format(name))
- mlog.debug('Include Dirs: {}'.format(incDirs))
- mlog.debug('Compiler Definitions: {}'.format(defs))
- mlog.debug('Libraries: {}'.format(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
- reg_is_lib = re.compile(r'^(-l[a-zA-Z0-9_]+|-pthread)$')
- processed_targets = []
- incDirs = []
- compileDefinitions = []
- 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())))
-
- targets = [i]
- if not autodetected_module_list:
- self.found_modules += [i]
-
- while len(targets) > 0:
- curr = targets.pop(0)
-
- # Skip already processed targets
- if curr in processed_targets:
- continue
-
- tgt = self.traceparser.targets[curr]
- cfgs = []
- cfg = ''
- otherDeps = []
- mlog.debug(tgt)
-
- if 'INTERFACE_INCLUDE_DIRECTORIES' in tgt.properties:
- incDirs += [x for x in tgt.properties['INTERFACE_INCLUDE_DIRECTORIES'] if x]
-
- if 'INTERFACE_COMPILE_DEFINITIONS' in tgt.properties:
- compileDefinitions += ['-D' + re.sub('^-D', '', x) for x in tgt.properties['INTERFACE_COMPILE_DEFINITIONS'] if x]
-
- if 'INTERFACE_COMPILE_OPTIONS' in tgt.properties:
- compileOptions += [x for x in tgt.properties['INTERFACE_COMPILE_OPTIONS'] if x]
-
- if 'IMPORTED_CONFIGURATIONS' in tgt.properties:
- cfgs = [x for x in tgt.properties['IMPORTED_CONFIGURATIONS'] if x]
- cfg = cfgs[0]
-
- if 'RELEASE' in cfgs:
- cfg = 'RELEASE'
-
- if 'IMPORTED_IMPLIB_{}'.format(cfg) in tgt.properties:
- libraries += [x for x in tgt.properties['IMPORTED_IMPLIB_{}'.format(cfg)] if x]
- elif 'IMPORTED_IMPLIB' in tgt.properties:
- libraries += [x for x in tgt.properties['IMPORTED_IMPLIB'] if x]
- elif 'IMPORTED_LOCATION_{}'.format(cfg) in tgt.properties:
- libraries += [x for x in tgt.properties['IMPORTED_LOCATION_{}'.format(cfg)] if x]
- elif 'IMPORTED_LOCATION' in tgt.properties:
- libraries += [x for x in tgt.properties['IMPORTED_LOCATION'] if x]
-
- if 'INTERFACE_LINK_LIBRARIES' in tgt.properties:
- otherDeps += [x for x in tgt.properties['INTERFACE_LINK_LIBRARIES'] if x]
-
- if 'IMPORTED_LINK_DEPENDENT_LIBRARIES_{}'.format(cfg) in tgt.properties:
- otherDeps += [x for x in tgt.properties['IMPORTED_LINK_DEPENDENT_LIBRARIES_{}'.format(cfg)] if x]
- elif 'IMPORTED_LINK_DEPENDENT_LIBRARIES' in tgt.properties:
- otherDeps += [x for x in tgt.properties['IMPORTED_LINK_DEPENDENT_LIBRARIES'] if x]
-
- for j in otherDeps:
- if j in self.traceparser.targets:
- targets += [j]
- elif reg_is_lib.match(j) or os.path.exists(j):
- libraries += [j]
-
- processed_targets += [curr]
-
- # Make sure all elements in the lists are unique and sorted
- incDirs = sorted(set(incDirs))
- compileDefinitions = sorted(set(compileDefinitions))
- compileOptions = sorted(set(compileOptions))
- libraries = sorted(set(libraries))
-
- mlog.debug('Include Dirs: {}'.format(incDirs))
- mlog.debug('Compiler Definitions: {}'.format(compileDefinitions))
- mlog.debug('Compiler Options: {}'.format(compileOptions))
- mlog.debug('Libraries: {}'.format(libraries))
-
- self.compile_args = compileOptions + compileDefinitions + ['-I{}'.format(x) for x in incDirs]
- self.link_args = libraries
-
- def _setup_cmake_dir(self, cmake_file: str) -> str:
- # Setup the CMake build environment and return the "build" directory
- build_dir = Path(self.cmake_root_dir) / 'cmake_{}'.format(self.name)
- build_dir.mkdir(parents=True, exist_ok=True)
-
- # Insert language parameters into the CMakeLists.txt and write new CMakeLists.txt
- src_cmake = Path(__file__).parent / 'data' / cmake_file
- cmake_txt = src_cmake.read_text()
-
- # 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 = """
-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)
- mlog.cmd_ci_include(cm_file.absolute().as_posix())
-
- return str(build_dir)
-
- def _call_cmake(self, args, cmake_file: str, env=None):
- build_dir = self._setup_cmake_dir(cmake_file)
- return self.cmakebin.call_with_fake_build(args, build_dir, env=env)
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.CMAKE]
-
- def log_tried(self):
- return self.type_name
-
- 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, default_value: T.Optional[str] = None,
- pkgconfig_define: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
- if cmake:
- try:
- v = self.traceparser.vars[cmake]
- except KeyError:
- pass
- else:
- if len(v) == 1:
- return v[0]
- elif v:
- return v
- if default_value is not None:
- return default_value
- raise DependencyException('Could not get cmake variable and no default provided for {!r}'.format(self))
-
-class DubDependency(ExternalDependency):
- class_dubbin = None
-
- def __init__(self, name, environment, kwargs):
- super().__init__('dub', environment, 'd', kwargs)
- self.name = name
- self.compiler = super().get_compiler()
- self.module_path = None
-
- if 'required' in kwargs:
- self.required = kwargs.get('required')
-
- if DubDependency.class_dubbin is None:
- self.dubbin = self._check_dub()
- DubDependency.class_dubbin = self.dubbin
- else:
- self.dubbin = DubDependency.class_dubbin
-
- if not self.dubbin:
- if self.required:
- raise DependencyException('DUB not found.')
- self.is_found = False
- return
-
- mlog.debug('Determining dependency {!r} with DUB executable '
- '{!r}'.format(name, self.dubbin.get_path()))
-
- # we need to know the target architecture
- arch = self.compiler.arch
-
- # Ask dub for the package
- ret, res = self._call_dubbin(['describe', name, '--arch=' + arch])
-
- if ret != 0:
- self.is_found = False
- return
-
- comp = self.compiler.get_id().replace('llvm', 'ldc').replace('gcc', 'gdc')
- packages = []
- description = json.loads(res)
- for package in description['packages']:
- packages.append(package['name'])
- if package['name'] == name:
- self.is_found = True
-
- not_lib = True
- if 'targetType' in package:
- if package['targetType'] in ['library', 'sourceLibrary', 'staticLibrary', 'dynamicLibrary']:
- not_lib = False
-
- if not_lib:
- mlog.error(mlog.bold(name), "found but it isn't a library")
- self.is_found = False
- return
-
- self.module_path = self._find_right_lib_path(package['path'], comp, description, True, package['targetFileName'])
- if not os.path.exists(self.module_path):
- # check if the dependency was built for other archs
- archs = [['x86_64'], ['x86'], ['x86', 'x86_mscoff']]
- for a in archs:
- description_a = copy.deepcopy(description)
- description_a['architecture'] = a
- arch_module_path = self._find_right_lib_path(package['path'], comp, description_a, True, package['targetFileName'])
- if arch_module_path:
- mlog.error(mlog.bold(name), "found but it wasn't compiled for", mlog.bold(arch))
- self.is_found = False
- return
-
- mlog.error(mlog.bold(name), "found but it wasn't compiled with", mlog.bold(comp))
- self.is_found = False
- return
-
- self.version = package['version']
- self.pkg = package
-
- if self.pkg['targetFileName'].endswith('.a'):
- self.static = True
-
- self.compile_args = []
- for flag in self.pkg['dflags']:
- self.link_args.append(flag)
- for path in self.pkg['importPaths']:
- self.compile_args.append('-I' + os.path.join(self.pkg['path'], path))
-
- self.link_args = self.raw_link_args = []
- for flag in self.pkg['lflags']:
- self.link_args.append(flag)
-
- self.link_args.append(os.path.join(self.module_path, self.pkg['targetFileName']))
-
- # Handle dependencies
- libs = []
-
- def add_lib_args(field_name, target):
- if field_name in target['buildSettings']:
- for lib in target['buildSettings'][field_name]:
- if lib not in libs:
- libs.append(lib)
- if os.name != 'nt':
- pkgdep = PkgConfigDependency(lib, environment, {'required': 'true', 'silent': 'true'})
- for arg in pkgdep.get_compile_args():
- self.compile_args.append(arg)
- for arg in pkgdep.get_link_args():
- self.link_args.append(arg)
- for arg in pkgdep.get_link_args(raw=True):
- self.raw_link_args.append(arg)
-
- for target in description['targets']:
- if target['rootPackage'] in packages:
- add_lib_args('libs', target)
- add_lib_args('libs-{}'.format(platform.machine()), target)
- for file in target['buildSettings']['linkerFiles']:
- lib_path = self._find_right_lib_path(file, comp, description)
- if lib_path:
- self.link_args.append(lib_path)
- else:
- self.is_found = False
-
- def get_compiler(self):
- return self.compiler
-
- def _find_right_lib_path(self, default_path, comp, description, folder_only=False, file_name=''):
- module_path = lib_file_name = ''
- if folder_only:
- module_path = default_path
- lib_file_name = file_name
- else:
- module_path = os.path.dirname(default_path)
- lib_file_name = os.path.basename(default_path)
- module_build_path = os.path.join(module_path, '.dub', 'build')
-
- # Get D version implemented in the compiler
- # gdc doesn't support this
- ret, res = self._call_dubbin(['--version'])
-
- if ret != 0:
- mlog.error('Failed to run {!r}', mlog.bold(comp))
- return
-
- d_ver = re.search('v[0-9].[0-9][0-9][0-9].[0-9]', res) # Ex.: v2.081.2
- if d_ver is not None:
- d_ver = d_ver.group().rsplit('.', 1)[0].replace('v', '').replace('.', '') # Fix structure. Ex.: 2081
- else:
- d_ver = '' # gdc
-
- if not os.path.isdir(module_build_path):
- return ''
-
- # Ex.: library-debug-linux.posix-x86_64-ldc_2081-EF934983A3319F8F8FF2F0E107A363BA
- build_name = '-{}-{}-{}-{}_{}'.format(description['buildType'], '.'.join(description['platform']), '.'.join(description['architecture']), comp, d_ver)
- for entry in os.listdir(module_build_path):
- if build_name in entry:
- for file in os.listdir(os.path.join(module_build_path, entry)):
- if file == lib_file_name:
- if folder_only:
- return os.path.join(module_build_path, entry)
- else:
- return os.path.join(module_build_path, entry, lib_file_name)
-
- return ''
-
- def _call_dubbin(self, args, env=None):
- p, out = Popen_safe(self.dubbin.get_command() + args, env=env)[0:2]
- return p.returncode, out.strip()
-
- def _call_copmbin(self, args, env=None):
- p, out = Popen_safe(self.compiler.get_exelist() + args, env=env)[0:2]
- return p.returncode, out.strip()
-
- def _check_dub(self):
- dubbin = ExternalProgram('dub', silent=True)
- if dubbin.found():
- try:
- p, out = Popen_safe(dubbin.get_command() + ['--version'])[0:2]
- if p.returncode != 0:
- mlog.warning('Found dub {!r} but couldn\'t run it'
- ''.format(' '.join(dubbin.get_command())))
- # Set to False instead of None to signify that we've already
- # searched for it and not found it
- dubbin = False
- except (FileNotFoundError, PermissionError):
- dubbin = False
- else:
- dubbin = False
- if dubbin:
- mlog.log('Found DUB:', mlog.bold(dubbin.get_path()),
- '(%s)' % out.strip())
- else:
- mlog.log('Found DUB:', mlog.red('NO'))
- return dubbin
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.DUB]
-
-class ExternalProgram:
- windows_exts = ('exe', 'msc', 'com', 'bat', 'cmd')
- # An 'ExternalProgram' always runs on the build machine
- for_machine = MachineChoice.BUILD
-
- def __init__(self, name: str, command: T.Optional[T.List[str]] = None,
- silent: bool = False, search_dir: T.Optional[str] = None,
- extra_search_dirs: T.Optional[T.List[str]] = None):
- self.name = name
- if command is not None:
- self.command = listify(command)
- else:
- all_search_dirs = [search_dir]
- if extra_search_dirs:
- all_search_dirs += extra_search_dirs
- for d in all_search_dirs:
- self.command = self._search(name, d)
- if self.found():
- break
-
- # Set path to be the last item that is actually a file (in order to
- # skip options in something like ['python', '-u', 'file.py']. If we
- # can't find any components, default to the last component of the path.
- self.path = self.command[-1]
- for i in range(len(self.command) - 1, -1, -1):
- arg = self.command[i]
- if arg is not None and os.path.isfile(arg):
- self.path = arg
- break
-
- if not silent:
- # ignore the warning because derived classes never call this __init__
- # method, and thus only the found() method of this class is ever executed
- if self.found(): # lgtm [py/init-calls-subclass]
- mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
- '(%s)' % ' '.join(self.command))
- else:
- mlog.log('Program', mlog.bold(name), 'found:', mlog.red('NO'))
-
- def __repr__(self) -> str:
- r = '<{} {!r} -> {!r}>'
- return r.format(self.__class__.__name__, self.name, self.command)
-
- def description(self) -> str:
- '''Human friendly description of the command'''
- return ' '.join(self.command)
-
- @classmethod
- def from_bin_list(cls, bt: BinaryTable, name):
- command = bt.lookup_entry(name)
- if command is None:
- return NonExistingExternalProgram()
- return cls.from_entry(name, command)
-
- @staticmethod
- @functools.lru_cache(maxsize=None)
- def _windows_sanitize_path(path: str) -> str:
- # Ensure that we use USERPROFILE even when inside MSYS, MSYS2, Cygwin, etc.
- if 'USERPROFILE' not in os.environ:
- return path
- # Ignore executables in the WindowsApps directory which are
- # zero-sized wrappers that magically open the Windows Store to
- # install the application.
- appstore_dir = Path(os.environ['USERPROFILE']) / 'AppData' / 'Local' / 'Microsoft' / 'WindowsApps'
- paths = []
- for each in path.split(os.pathsep):
- if Path(each) != appstore_dir:
- paths.append(each)
- return os.pathsep.join(paths)
-
- @staticmethod
- def from_entry(name, command):
- if isinstance(command, list):
- if len(command) == 1:
- command = command[0]
- # We cannot do any searching if the command is a list, and we don't
- # need to search if the path is an absolute path.
- if isinstance(command, list) or os.path.isabs(command):
- return ExternalProgram(name, command=command, silent=True)
- assert isinstance(command, str)
- # Search for the command using the specified string!
- return ExternalProgram(command, silent=True)
-
- @staticmethod
- def _shebang_to_cmd(script):
- """
- Check if the file has a shebang and manually parse it to figure out
- the interpreter to use. This is useful if the script is not executable
- or if we're on Windows (which does not understand shebangs).
- """
- try:
- with open(script) as f:
- first_line = f.readline().strip()
- if first_line.startswith('#!'):
- # In a shebang, everything before the first space is assumed to
- # be the command to run and everything after the first space is
- # the single argument to pass to that command. So we must split
- # exactly once.
- commands = first_line[2:].split('#')[0].strip().split(maxsplit=1)
- if mesonlib.is_windows():
- # Windows does not have UNIX paths so remove them,
- # but don't remove Windows paths
- if commands[0].startswith('/'):
- commands[0] = commands[0].split('/')[-1]
- if len(commands) > 0 and commands[0] == 'env':
- commands = commands[1:]
- # Windows does not ship python3.exe, but we know the path to it
- if len(commands) > 0 and commands[0] == 'python3':
- commands = mesonlib.python_command + commands[1:]
- elif mesonlib.is_haiku():
- # Haiku does not have /usr, but a lot of scripts assume that
- # /usr/bin/env always exists. Detect that case and run the
- # script with the interpreter after it.
- if commands[0] == '/usr/bin/env':
- commands = commands[1:]
- # We know what python3 is, we're running on it
- if len(commands) > 0 and commands[0] == 'python3':
- commands = mesonlib.python_command + commands[1:]
- else:
- # Replace python3 with the actual python3 that we are using
- if commands[0] == '/usr/bin/env' and commands[1] == 'python3':
- commands = mesonlib.python_command + commands[2:]
- elif commands[0].split('/')[-1] == 'python3':
- commands = mesonlib.python_command + commands[1:]
- return commands + [script]
- except Exception as e:
- mlog.debug(e)
- mlog.debug('Unusable script {!r}'.format(script))
- return False
-
- def _is_executable(self, path):
- suffix = os.path.splitext(path)[-1].lower()[1:]
- execmask = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
- if mesonlib.is_windows():
- if suffix in self.windows_exts:
- return True
- elif os.stat(path).st_mode & execmask:
- return not os.path.isdir(path)
- return False
-
- def _search_dir(self, name, search_dir):
- if search_dir is None:
- return False
- trial = os.path.join(search_dir, name)
- if os.path.exists(trial):
- if self._is_executable(trial):
- return [trial]
- # Now getting desperate. Maybe it is a script file that is
- # a) not chmodded executable, or
- # b) we are on windows so they can't be directly executed.
- return self._shebang_to_cmd(trial)
- else:
- if mesonlib.is_windows():
- for ext in self.windows_exts:
- trial_ext = '{}.{}'.format(trial, ext)
- if os.path.exists(trial_ext):
- return [trial_ext]
- return False
-
- def _search_windows_special_cases(self, name, command):
- '''
- Lots of weird Windows quirks:
- 1. PATH search for @name returns files with extensions from PATHEXT,
- but only self.windows_exts are executable without an interpreter.
- 2. @name might be an absolute path to an executable, but without the
- extension. This works inside MinGW so people use it a lot.
- 3. The script is specified without an extension, in which case we have
- to manually search in PATH.
- 4. More special-casing for the shebang inside the script.
- '''
- if command:
- # On Windows, even if the PATH search returned a full path, we can't be
- # sure that it can be run directly if it's not a native executable.
- # For instance, interpreted scripts sometimes need to be run explicitly
- # with an interpreter if the file association is not done properly.
- name_ext = os.path.splitext(command)[1]
- if name_ext[1:].lower() in self.windows_exts:
- # Good, it can be directly executed
- return [command]
- # Try to extract the interpreter from the shebang
- commands = self._shebang_to_cmd(command)
- if commands:
- return commands
- return [None]
- # Maybe the name is an absolute path to a native Windows
- # executable, but without the extension. This is technically wrong,
- # but many people do it because it works in the MinGW shell.
- if os.path.isabs(name):
- for ext in self.windows_exts:
- command = '{}.{}'.format(name, ext)
- if os.path.exists(command):
- return [command]
- # On Windows, interpreted scripts must have an extension otherwise they
- # cannot be found by a standard PATH search. So we do a custom search
- # where we manually search for a script with a shebang in PATH.
- search_dirs = self._windows_sanitize_path(os.environ.get('PATH', '')).split(';')
- for search_dir in search_dirs:
- commands = self._search_dir(name, search_dir)
- if commands:
- return commands
- return [None]
-
- def _search(self, name, search_dir):
- '''
- Search in the specified dir for the specified executable by name
- and if not found search in PATH
- '''
- commands = self._search_dir(name, search_dir)
- if commands:
- return commands
- # Do a standard search in PATH
- path = os.environ.get('PATH', None)
- if mesonlib.is_windows() and path:
- path = self._windows_sanitize_path(path)
- command = shutil.which(name, path=path)
- if mesonlib.is_windows():
- return self._search_windows_special_cases(name, command)
- # On UNIX-like platforms, shutil.which() is enough to find
- # all executables whether in PATH or with an absolute path
- return [command]
-
- def found(self) -> bool:
- return self.command[0] is not None
-
- def get_command(self):
- return self.command[:]
-
- def get_path(self):
- return self.path
-
- def get_name(self):
- return self.name
-
-
-class NonExistingExternalProgram(ExternalProgram): # lgtm [py/missing-call-to-init]
- "A program that will never exist"
-
- def __init__(self, name='nonexistingprogram'):
- self.name = name
- self.command = [None]
- self.path = None
-
- def __repr__(self):
- r = '<{} {!r} -> {!r}>'
- return r.format(self.__class__.__name__, self.name, self.command)
-
- def found(self):
- return False
-
-
-class EmptyExternalProgram(ExternalProgram): # lgtm [py/missing-call-to-init]
- '''
- A program object that returns an empty list of commands. Used for cases
- such as a cross file exe_wrapper to represent that it's not required.
- '''
-
- def __init__(self):
- self.name = None
- self.command = []
- self.path = None
-
- def __repr__(self):
- r = '<{} {!r} -> {!r}>'
- return r.format(self.__class__.__name__, self.name, self.command)
-
- def found(self):
- return True
-
-
class ExternalLibrary(ExternalDependency):
- def __init__(self, name, link_args, environment, language, silent=False):
- super().__init__('library', environment, language, {})
+ def __init__(self, name: str, link_args: T.List[str], environment: 'Environment',
+ language: str, silent: bool = False) -> None:
+ super().__init__(DependencyTypeName('library'), environment, {}, language=language)
self.name = name
self.language = language
self.is_found = False
@@ -2043,7 +422,7 @@
else:
mlog.log('Library', mlog.bold(name), 'found:', mlog.red('NO'))
- def get_link_args(self, language=None, **kwargs):
+ def get_link_args(self, language: T.Optional[str] = None, raw: bool = False) -> T.List[str]:
'''
External libraries detected using a compiler must only be used with
compatible code. For instance, Vala libraries (.vapi files) cannot be
@@ -2056,11 +435,11 @@
if (self.language == 'vala' and language != 'vala') or \
(language == 'vala' and self.language != 'vala'):
return []
- return super().get_link_args(**kwargs)
+ return super().get_link_args(language=language, raw=raw)
def get_partial_dependency(self, *, compile_args: bool = False,
link_args: bool = False, links: bool = False,
- includes: bool = False, sources: bool = False):
+ includes: bool = False, sources: bool = False) -> 'ExternalLibrary':
# External library only has link_args, so ignore the rest of the
# interface.
new = copy.copy(self)
@@ -2069,279 +448,6 @@
return new
-class ExtraFrameworkDependency(ExternalDependency):
- system_framework_paths = None
-
- def __init__(self, name, required, paths, env, lang, kwargs):
- super().__init__('extraframeworks', env, lang, kwargs)
- self.name = name
- self.required = required
- # Full path to framework directory
- self.framework_path = None
- if not self.clib_compiler:
- raise DependencyException('No C-like compilers are available')
- if self.system_framework_paths is None:
- try:
- self.system_framework_paths = self.clib_compiler.find_framework_paths(self.env)
- except MesonException as e:
- if 'non-clang' in str(e):
- # Apple frameworks can only be found (and used) with the
- # system compiler. It is not available so bail immediately.
- self.is_found = False
- return
- raise
- self.detect(name, paths)
-
- def detect(self, name, paths):
- if not paths:
- paths = self.system_framework_paths
- for p in paths:
- mlog.debug('Looking for framework {} in {}'.format(name, p))
- # We need to know the exact framework path because it's used by the
- # Qt5 dependency class, and for setting the include path. We also
- # want to avoid searching in an invalid framework path which wastes
- # time and can cause a false positive.
- framework_path = self._get_framework_path(p, name)
- if framework_path is None:
- continue
- # We want to prefer the specified paths (in order) over the system
- # paths since these are "extra" frameworks.
- # For example, Python2's framework is in /System/Library/Frameworks and
- # Python3's framework is in /Library/Frameworks, but both are called
- # Python.framework. We need to know for sure that the framework was
- # found in the path we expect.
- allow_system = p in self.system_framework_paths
- args = self.clib_compiler.find_framework(name, self.env, [p], allow_system)
- if args is None:
- continue
- self.link_args = args
- self.framework_path = framework_path.as_posix()
- self.compile_args = ['-F' + self.framework_path]
- # We need to also add -I includes to the framework because all
- # cross-platform projects such as OpenGL, Python, Qt, GStreamer,
- # etc do not use "framework includes":
- # https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPFrameworks/Tasks/IncludingFrameworks.html
- incdir = self._get_framework_include_path(framework_path)
- if incdir:
- self.compile_args += ['-I' + incdir]
- self.is_found = True
- return
-
- def _get_framework_path(self, path, name):
- p = Path(path)
- lname = name.lower()
- for d in p.glob('*.framework/'):
- if lname == d.name.rsplit('.', 1)[0].lower():
- return d
- return None
-
- def _get_framework_latest_version(self, path):
- versions = []
- for each in path.glob('Versions/*'):
- # macOS filesystems are usually case-insensitive
- if each.name.lower() == 'current':
- continue
- versions.append(Version(each.name))
- if len(versions) == 0:
- # most system frameworks do not have a 'Versions' directory
- return 'Headers'
- return 'Versions/{}/Headers'.format(sorted(versions)[-1]._s)
-
- def _get_framework_include_path(self, path):
- # According to the spec, 'Headers' must always be a symlink to the
- # Headers directory inside the currently-selected version of the
- # framework, but sometimes frameworks are broken. Look in 'Versions'
- # for the currently-selected version or pick the latest one.
- trials = ('Headers', 'Versions/Current/Headers',
- self._get_framework_latest_version(path))
- for each in trials:
- trial = path / each
- if trial.is_dir():
- return trial.as_posix()
- return None
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.EXTRAFRAMEWORK]
-
- def log_info(self):
- return self.framework_path
-
- def log_tried(self):
- return 'framework'
-
-
-def get_dep_identifier(name, kwargs) -> T.Tuple:
- identifier = (name, )
- 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' subprojects cannot be cached -- they must be initialized
- # 'default_options' is only used in fallback case
- if key in ('version', 'native', 'required', 'fallback', 'default_options'):
- continue
- # All keyword arguments are strings, ints, or lists (or lists of lists)
- if isinstance(value, list):
- value = frozenset(listify(value))
- 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, env, kwargs):
- 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('%s dependency does not accept "language" keyword argument' % (name, ))
- 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, kwargs)
-
- pkg_exc = []
- pkgdep = []
- 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 = []
- 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'),
- '(tried {})'.format(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, env: Environment, kwargs: T.Dict[str, T.Any]) -> list:
- # 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 getattr(packages[lname], '_factory', None):
- dep = packages[lname]._factory(env, kwargs)
- else:
- dep = [functools.partial(packages[lname], env, kwargs)]
- return dep
-
- candidates = []
-
- # 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 mesonlib.is_osx():
- candidates.append(functools.partial(ExtraFrameworkDependency, name,
- False, None, env, None, 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 mesonlib.is_osx():
- candidates.append(functools.partial(ExtraFrameworkDependency, name,
- False, None, env, None, 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
-
-
def sort_libpaths(libpaths: T.List[str], refpaths: T.List[str]) -> T.List[str]:
"""Sort according to
@@ -2351,11 +457,11 @@
if len(refpaths) == 0:
return list(libpaths)
- def key_func(libpath):
- common_lengths = []
+ def key_func(libpath: str) -> T.Tuple[int, int]:
+ common_lengths: T.List[int] = []
for refpath in refpaths:
try:
- common_path = os.path.commonpath([libpath, refpath])
+ common_path: str = os.path.commonpath([libpath, refpath])
except ValueError:
common_path = ''
common_lengths.append(len(common_path))
@@ -2365,13 +471,92 @@
return (max_index, reversed_max_length)
return sorted(libpaths, key=key_func)
-
-def strip_system_libdirs(environment, for_machine: MachineChoice, link_args):
+def strip_system_libdirs(environment: 'Environment', for_machine: MachineChoice, link_args: T.List[str]) -> T.List[str]:
"""Remove -L arguments.
leaving these in will break builds where a user has a version of a library
in the system path, and a different version not in the system path if they
want to link against the non-system path version.
"""
- exclude = {'-L{}'.format(p) for p in environment.get_compiler_system_dirs(for_machine)}
+ exclude = {f'-L{p}' for p in environment.get_compiler_system_dirs(for_machine)}
return [l for l in link_args if l not in exclude]
+
+def process_method_kw(possible: T.Iterable[DependencyMethods], kwargs: T.Dict[str, T.Any]) -> T.List[DependencyMethods]:
+ method = kwargs.get('method', 'auto') # type: T.Union[DependencyMethods, str]
+ if isinstance(method, DependencyMethods):
+ return [method]
+ # TODO: try/except?
+ if method not in [e.value for e in DependencyMethods]:
+ raise DependencyException(f'method {method!r} is invalid')
+ method = DependencyMethods(method)
+
+ # This sets per-tool config methods which are deprecated to to the new
+ # generic CONFIG_TOOL value.
+ if method in [DependencyMethods.SDLCONFIG, DependencyMethods.CUPSCONFIG,
+ DependencyMethods.PCAPCONFIG, DependencyMethods.LIBWMFCONFIG]:
+ FeatureDeprecated.single_use(f'Configuration method {method.value}', '0.44', 'Use "config-tool" instead.')
+ method = DependencyMethods.CONFIG_TOOL
+ if method is DependencyMethods.QMAKE:
+ FeatureDeprecated.single_use('Configuration method "qmake"', '0.58', 'Use "config-tool" instead.')
+ method = DependencyMethods.CONFIG_TOOL
+
+ # Set the detection method. If the method is set to auto, use any available method.
+ # If method is set to a specific string, allow only that detection method.
+ if method == DependencyMethods.AUTO:
+ methods = list(possible)
+ elif method in possible:
+ methods = [method]
+ else:
+ raise DependencyException(
+ 'Unsupported detection method: {}, allowed methods are {}'.format(
+ method.value,
+ mlog.format_list([x.value for x in [DependencyMethods.AUTO] + list(possible)])))
+
+ return methods
+
+def detect_compiler(name: str, env: 'Environment', for_machine: MachineChoice,
+ language: T.Optional[str]) -> T.Optional['Compiler']:
+ """Given a language and environment find the compiler used."""
+ compilers = env.coredata.compilers[for_machine]
+
+ # Set the compiler for this dependency if a language is specified,
+ # else try to pick something that looks usable.
+ if language:
+ if language not in compilers:
+ m = name.capitalize() + ' requires a {0} compiler, but ' \
+ '{0} is not in the list of project languages'
+ raise DependencyException(m.format(language.capitalize()))
+ return compilers[language]
+ else:
+ for lang in clib_langs:
+ try:
+ return compilers[lang]
+ except KeyError:
+ continue
+ return None
+
+
+class SystemDependency(ExternalDependency):
+
+ """Dependency base for System type dependencies."""
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ language: T.Optional[str] = None) -> None:
+ super().__init__(DependencyTypeName('system'), env, kwargs, language=language)
+ self.name = name
+
+ def log_tried(self) -> str:
+ return 'system'
+
+
+class BuiltinDependency(ExternalDependency):
+
+ """Dependency base for Builtin type dependencies."""
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ language: T.Optional[str] = None) -> None:
+ super().__init__(DependencyTypeName('builtin'), env, kwargs, language=language)
+ self.name = name
+
+ def log_tried(self) -> str:
+ return 'builtin'
diff -Nru meson-0.53.2/mesonbuild/dependencies/boost.py meson-0.61.2/mesonbuild/dependencies/boost.py
--- meson-0.53.2/mesonbuild/dependencies/boost.py 2019-08-28 17:15:39.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/boost.py 2021-11-02 19:58:07.000000000 +0000
@@ -1,4 +1,4 @@
-# Copyright 2013-2017 The Meson development team
+# Copyright 2013-2020 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.
@@ -12,17 +12,21 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-# This file contains the detection logic for miscellaneous external dependencies.
-
-import glob
-import os
+import re
+import functools
+import typing as T
+from pathlib import Path
from .. import mlog
from .. import mesonlib
-from ..environment import detect_cpu_family
+from ..environment import Environment
+
+from .base import DependencyException, SystemDependency
+from .pkgconfig import PkgConfigDependency
+from .misc import threads_factory
-from .base import (DependencyException, ExternalDependency)
-from .misc import ThreadDependency
+if T.TYPE_CHECKING:
+ from ..environment import Properties
# On windows 3 directory layouts are supported:
# * The default layout (versioned) installed:
@@ -39,16 +43,6 @@
# mingw-w64 / Windows : libboost_-mt.a (location = /mingw64/lib/)
# libboost_-mt.dll.a
#
-# Library names supported:
-# - libboost_--mt-gd-x_x.lib (static)
-# - boost_--mt-gd-x_x.lib|.dll (shared)
-# - libboost_.lib (static)
-# - boost_.lib|.dll (shared)
-# where compiler is vc141 for example.
-#
-# NOTE: -gd means runtime and build time debugging is on
-# -mt means threading=multi
-#
# The `modules` argument accept library names. This is because every module that
# has libraries to link against also has multiple options regarding how to
# link. See for example:
@@ -78,614 +72,1007 @@
# Furthermore, the boost documentation for unix above uses examples from windows like
# "libboost_regex-vc71-mt-d-x86-1_34.lib", so apparently the abi tags may be more aimed at windows.
#
-# Probably we should use the linker search path to decide which libraries to use. This will
-# make it possible to find the macports boost libraries without setting BOOST_ROOT, and will
-# also mean that it would be possible to use user-installed boost libraries when official
-# packages are installed.
-#
-# We thus follow the following strategy:
-# 1. Look for libraries using compiler.find_library( )
-# 1.1 On Linux, just look for boost_
-# 1.2 On other systems (e.g. Mac) look for boost_-mt if multithreading.
-# 1.3 Otherwise look for boost_
-# 2. Fall back to previous approach
-# 2.1. Search particular directories.
-# 2.2. Find boost libraries with unknown suffixes using file-name globbing.
-
-# TODO: Unix: Don't assume we know where the boost dir is, rely on -Idir and -Ldir being set.
-# TODO: Allow user to specify suffix in BOOST_SUFFIX, or add specific options like BOOST_DEBUG for 'd' for debug.
-
-class BoostDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('boost', environment, 'cpp', 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")
- self.is_multithreading = threading == "multi"
-
- self.requested_modules = self.get_requested(kwargs)
- if 'thread' in self.requested_modules:
- self._add_sub_dependency(ThreadDependency, environment, kwargs)
-
- self.boost_root = None
- self.boost_roots = []
- self.incdir = None
- self.libdir = None
-
- if 'BOOST_ROOT' in os.environ:
- self.boost_root = os.environ['BOOST_ROOT']
- self.boost_roots = [self.boost_root]
- if not os.path.isabs(self.boost_root):
- raise DependencyException('BOOST_ROOT must be an absolute path.')
- if 'BOOST_INCLUDEDIR' in os.environ:
- self.incdir = os.environ['BOOST_INCLUDEDIR']
- if 'BOOST_LIBRARYDIR' in os.environ:
- self.libdir = os.environ['BOOST_LIBRARYDIR']
-
- if self.boost_root is None:
- if self.env.machines[self.for_machine].is_windows():
- self.boost_roots = self.detect_win_roots()
- else:
- self.boost_roots = self.detect_nix_roots()
-
- if self.incdir is None:
- if self.env.machines[self.for_machine].is_windows():
- self.incdir = self.detect_win_incdir()
- else:
- self.incdir = self.detect_nix_incdir()
-
- mlog.debug('Boost library root dir is', mlog.bold(self.boost_root))
- mlog.debug('Boost include directory is', mlog.bold(self.incdir))
-
- # 1. check if we can find BOOST headers.
- self.detect_headers_and_version()
-
- if not self.is_found:
- return # if we can not find 'boost/version.hpp'
-
- # 2. check if we can find BOOST libraries.
- self.detect_lib_modules()
- mlog.debug('Boost library directory is', mlog.bold(self.libdir))
-
- mlog.debug('Installed Boost libraries: ')
- for key in sorted(self.lib_modules.keys()):
- mlog.debug(key, self.lib_modules[key])
+# We follow the following strategy for finding modules:
+# A) Detect potential boost root directories (uses also BOOST_ROOT env var)
+# B) Foreach candidate
+# 1. Look for the boost headers (boost/version.pp)
+# 2. Find all boost libraries
+# 2.1 Add all libraries in lib*
+# 2.2 Filter out non boost libraries
+# 2.3 Filter the renaining libraries based on the meson requirements (static/shared, etc.)
+# 2.4 Ensure that all libraries have the same boost tag (and are thus compatible)
+# 3. Select the libraries matching the requested modules
+
+@functools.total_ordering
+class BoostIncludeDir():
+ def __init__(self, path: Path, version_int: int):
+ self.path = path
+ self.version_int = version_int
+ major = int(self.version_int / 100000)
+ minor = int((self.version_int / 100) % 1000)
+ patch = int(self.version_int % 100)
+ self.version = f'{major}.{minor}.{patch}'
+ self.version_lib = f'{major}_{minor}'
+
+ def __repr__(self) -> str:
+ return f''
+
+ def __lt__(self, other: object) -> bool:
+ if isinstance(other, BoostIncludeDir):
+ return (self.version_int, self.path) < (other.version_int, other.path)
+ return NotImplemented
+
+@functools.total_ordering
+class BoostLibraryFile():
+ # Python libraries are special because of the included
+ # minor version in the module name.
+ boost_python_libs = ['boost_python', 'boost_numpy']
+ reg_python_mod_split = re.compile(r'(boost_[a-zA-Z]+)([0-9]*)')
+
+ reg_abi_tag = re.compile(r'^s?g?y?d?p?n?$')
+ reg_ver_tag = re.compile(r'^[0-9_]+$')
+
+ def __init__(self, path: Path):
+ self.path = path
+ self.name = self.path.name
+
+ # Initialize default properties
+ self.static = False
+ self.toolset = ''
+ self.arch = ''
+ self.version_lib = ''
+ self.mt = True
+
+ self.runtime_static = False
+ self.runtime_debug = False
+ self.python_debug = False
+ self.debug = False
+ self.stlport = False
+ self.deprecated_iostreams = False
+
+ # Post process the library name
+ name_parts = self.name.split('.')
+ self.basename = name_parts[0]
+ self.suffixes = name_parts[1:]
+ self.vers_raw = [x for x in self.suffixes if x.isdigit()]
+ self.suffixes = [x for x in self.suffixes if not x.isdigit()]
+ self.nvsuffix = '.'.join(self.suffixes) # Used for detecting the library type
+ self.nametags = self.basename.split('-')
+ self.mod_name = self.nametags[0]
+ if self.mod_name.startswith('lib'):
+ self.mod_name = self.mod_name[3:]
+
+ # Set library version if possible
+ if len(self.vers_raw) >= 2:
+ self.version_lib = '{}_{}'.format(self.vers_raw[0], self.vers_raw[1])
+
+ # Detecting library type
+ if self.nvsuffix in ['so', 'dll', 'dll.a', 'dll.lib', 'dylib']:
+ self.static = False
+ elif self.nvsuffix in ['a', 'lib']:
+ self.static = True
+ else:
+ raise DependencyException(f'Unable to process library extension "{self.nvsuffix}" ({self.path})')
- # 3. check if requested modules are valid, that is, either found or in the list of known boost libraries
- self.check_invalid_modules()
+ # boost_.lib is the dll import library
+ if self.basename.startswith('boost_') and self.nvsuffix == 'lib':
+ self.static = False
+
+ # Process tags
+ tags = self.nametags[1:]
+ # Filter out the python version tag and fix modname
+ if self.is_python_lib():
+ tags = self.fix_python_name(tags)
+ if not tags:
+ return
- # 4. final check whether or not we find all requested and valid modules
- self.check_find_requested_modules()
+ # Without any tags mt is assumed, however, an absence of mt in the name
+ # with tags present indicates that the lib was built without mt support
+ self.mt = False
+ for i in tags:
+ if i == 'mt':
+ self.mt = True
+ elif len(i) == 3 and i[1:] in ['32', '64']:
+ self.arch = i
+ elif BoostLibraryFile.reg_abi_tag.match(i):
+ self.runtime_static = 's' in i
+ self.runtime_debug = 'g' in i
+ self.python_debug = 'y' in i
+ self.debug = 'd' in i
+ self.stlport = 'p' in i
+ self.deprecated_iostreams = 'n' in i
+ elif BoostLibraryFile.reg_ver_tag.match(i):
+ self.version_lib = i
+ else:
+ self.toolset = i
- def check_invalid_modules(self):
- invalid_modules = [c for c in self.requested_modules if 'boost_' + c not in self.lib_modules and 'boost_' + c not in BOOST_LIBS]
+ def __repr__(self) -> str:
+ return f''
- # previous versions of meson allowed include dirs as modules
- remove = []
- for m in invalid_modules:
- if m in BOOST_DIRS:
- mlog.warning('Requested boost library', mlog.bold(m), 'that doesn\'t exist. '
- 'This will be an error in the future')
- remove.append(m)
+ def __lt__(self, other: object) -> bool:
+ if isinstance(other, BoostLibraryFile):
+ return (
+ self.mod_name, self.static, self.version_lib, self.arch,
+ not self.mt, not self.runtime_static,
+ not self.debug, self.runtime_debug, self.python_debug,
+ self.stlport, self.deprecated_iostreams,
+ self.name,
+ ) < (
+ other.mod_name, other.static, other.version_lib, other.arch,
+ not other.mt, not other.runtime_static,
+ not other.debug, other.runtime_debug, other.python_debug,
+ other.stlport, other.deprecated_iostreams,
+ other.name,
+ )
+ return NotImplemented
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, BoostLibraryFile):
+ return self.name == other.name
+ return NotImplemented
+
+ def __hash__(self) -> int:
+ return hash(self.name)
+
+ @property
+ def abitag(self) -> str:
+ abitag = ''
+ abitag += 'S' if self.static else '-'
+ abitag += 'M' if self.mt else '-'
+ abitag += ' '
+ abitag += 's' if self.runtime_static else '-'
+ abitag += 'g' if self.runtime_debug else '-'
+ abitag += 'y' if self.python_debug else '-'
+ abitag += 'd' if self.debug else '-'
+ abitag += 'p' if self.stlport else '-'
+ abitag += 'n' if self.deprecated_iostreams else '-'
+ abitag += ' ' + (self.arch or '???')
+ abitag += ' ' + (self.toolset or '?')
+ abitag += ' ' + (self.version_lib or 'x_xx')
+ return abitag
+
+ def is_boost(self) -> bool:
+ return any([self.name.startswith(x) for x in ['libboost_', 'boost_']])
+
+ def is_python_lib(self) -> bool:
+ return any([self.mod_name.startswith(x) for x in BoostLibraryFile.boost_python_libs])
+
+ def fix_python_name(self, tags: T.List[str]) -> T.List[str]:
+ # Handle the boost_python naming madeness.
+ # See https://github.com/mesonbuild/meson/issues/4788 for some distro
+ # specific naming variations.
+ other_tags = [] # type: T.List[str]
+
+ # Split the current modname into the base name and the version
+ m_cur = BoostLibraryFile.reg_python_mod_split.match(self.mod_name)
+ cur_name = m_cur.group(1)
+ cur_vers = m_cur.group(2)
+
+ # Update the current version string if the new version string is longer
+ def update_vers(new_vers: str) -> None:
+ nonlocal cur_vers
+ new_vers = new_vers.replace('_', '')
+ new_vers = new_vers.replace('.', '')
+ if not new_vers.isdigit():
+ return
+ if len(new_vers) > len(cur_vers):
+ cur_vers = new_vers
+
+ for i in tags:
+ if i.startswith('py'):
+ update_vers(i[2:])
+ elif i.isdigit():
+ update_vers(i)
+ elif len(i) >= 3 and i[0].isdigit and i[2].isdigit() and i[1] == '.':
+ update_vers(i)
+ else:
+ other_tags += [i]
- self.requested_modules = [x for x in self.requested_modules if x not in remove]
- invalid_modules = [x for x in invalid_modules if x not in remove]
+ self.mod_name = cur_name + cur_vers
+ return other_tags
- if invalid_modules:
- mlog.error('Invalid Boost modules: ' + ', '.join(invalid_modules))
+ def mod_name_matches(self, mod_name: str) -> bool:
+ if self.mod_name == mod_name:
return True
- else:
+ if not self.is_python_lib():
return False
- def log_details(self):
- module_str = ', '.join(self.requested_modules)
- return module_str
+ m_cur = BoostLibraryFile.reg_python_mod_split.match(self.mod_name)
+ m_arg = BoostLibraryFile.reg_python_mod_split.match(mod_name)
- def log_info(self):
- if self.boost_root:
- return self.boost_root
- return ''
+ if not m_cur or not m_arg:
+ return False
- def detect_nix_roots(self):
- return [os.path.abspath(os.path.join(x, '..'))
- for x in self.clib_compiler.get_default_include_dirs()]
-
- def detect_win_roots(self):
- res = []
- # Where boost documentation says it should be
- globtext = 'C:\\Program Files\\boost\\boost_*'
- files = glob.glob(globtext)
- res.extend(files)
-
- # Where boost built from source actually installs it
- if os.path.isdir('C:\\Boost'):
- res.append('C:\\Boost')
-
- # Where boost prebuilt binaries are
- globtext = 'C:\\local\\boost_*'
- files = glob.glob(globtext)
- res.extend(files)
- return res
+ if m_cur.group(1) != m_arg.group(1):
+ return False
- def detect_nix_incdir(self):
- if self.boost_root:
- return os.path.join(self.boost_root, 'include')
- return None
+ cur_vers = m_cur.group(2)
+ arg_vers = m_arg.group(2)
+
+ # Always assume python 2 if nothing is specified
+ if not arg_vers:
+ arg_vers = '2'
+
+ return cur_vers.startswith(arg_vers)
+
+ def version_matches(self, version_lib: str) -> bool:
+ # If no version tag is present, assume that it fits
+ if not self.version_lib or not version_lib:
+ return True
+ return self.version_lib == version_lib
- # FIXME: Should pick a version that matches the requested version
- # Returns the folder that contains the boost folder.
- def detect_win_incdir(self):
- for root in self.boost_roots:
- globtext = os.path.join(root, 'include', 'boost-*')
- incdirs = glob.glob(globtext)
- if incdirs:
- return incdirs[0]
- incboostdir = os.path.join(root, 'include', 'boost')
- if os.path.isdir(incboostdir):
- return os.path.join(root, 'include')
- incboostdir = os.path.join(root, 'boost')
- if os.path.isdir(incboostdir):
- return root
- return None
-
- def get_compile_args(self):
- args = []
- include_dir = self.incdir
-
- # Use "-isystem" when including boost headers instead of "-I"
- # to avoid compiler warnings/failures when "-Werror" is used
-
- # Careful not to use "-isystem" on default include dirs as it
- # breaks some of the headers for certain gcc versions
-
- # For example, doing g++ -isystem /usr/include on a simple
- # "int main()" source results in the error:
- # "/usr/include/c++/6.3.1/cstdlib:75:25: fatal error: stdlib.h: No such file or directory"
-
- # See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70129
- # and http://stackoverflow.com/questions/37218953/isystem-on-a-system-include-directory-causes-errors
- # for more details
+ def arch_matches(self, arch: str) -> bool:
+ # If no version tag is present, assume that it fits
+ if not self.arch or not arch:
+ return True
+ return self.arch == arch
- if include_dir and include_dir not in self.clib_compiler.get_default_include_dirs():
- args.append("".join(self.clib_compiler.get_include_args(include_dir, True)))
+ def vscrt_matches(self, vscrt: str) -> bool:
+ # If no vscrt tag present, assume that it fits ['/MD', '/MDd', '/MT', '/MTd']
+ if not vscrt:
+ return True
+ if vscrt in ['/MD', '-MD']:
+ return not self.runtime_static and not self.runtime_debug
+ elif vscrt in ['/MDd', '-MDd']:
+ return not self.runtime_static and self.runtime_debug
+ elif vscrt in ['/MT', '-MT']:
+ return (self.runtime_static or not self.static) and not self.runtime_debug
+ elif vscrt in ['/MTd', '-MTd']:
+ return (self.runtime_static or not self.static) and self.runtime_debug
+
+ mlog.warning(f'Boost: unknown vscrt tag {vscrt}. This may cause the compilation to fail. Please consider reporting this as a bug.', once=True)
+ return True
+
+ def get_compiler_args(self) -> T.List[str]:
+ args = [] # type: T.List[str]
+ if self.mod_name in boost_libraries:
+ libdef = boost_libraries[self.mod_name] # type: BoostLibrary
+ if self.static:
+ args += libdef.static
+ else:
+ args += libdef.shared
+ if self.mt:
+ args += libdef.multi
+ else:
+ args += libdef.single
return args
- def get_requested(self, kwargs):
- candidates = mesonlib.extract_as_list(kwargs, 'modules')
- for c in candidates:
- if not isinstance(c, str):
+ def get_link_args(self) -> T.List[str]:
+ return [self.path.as_posix()]
+
+class BoostDependency(SystemDependency):
+ def __init__(self, environment: Environment, kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__('boost', environment, kwargs, language='cpp')
+ buildtype = environment.coredata.get_option(mesonlib.OptionKey('buildtype'))
+ assert isinstance(buildtype, str)
+ self.debug = buildtype.startswith('debug')
+ self.multithreading = kwargs.get('threading', 'multi') == 'multi'
+
+ self.boost_root = None # type: T.Optional[Path]
+ self.explicit_static = 'static' in kwargs
+
+ # Extract and validate modules
+ self.modules = mesonlib.extract_as_list(kwargs, 'modules') # type: T.List[str]
+ for i in self.modules:
+ if not isinstance(i, str):
raise DependencyException('Boost module argument is not a string.')
- return candidates
+ if i.startswith('boost_'):
+ raise DependencyException('Boost modules must be passed without the boost_ prefix')
- def detect_headers_and_version(self):
- try:
- version = self.clib_compiler.get_define('BOOST_LIB_VERSION', '#include ', self.env, self.get_compile_args(), [], disable_cache=True)[0]
- except mesonlib.EnvironmentException:
- return
- except TypeError:
- return
- # Remove quotes
- version = version[1:-1]
- # Fix version string
- self.version = version.replace('_', '.')
- self.is_found = True
-
- def detect_lib_modules(self):
- self.lib_modules = {}
- # 1. Try to find modules using compiler.find_library( )
- if self.find_libraries_with_abi_tags(self.abi_tags()):
- pass
- # 2. Fall back to the old method
- else:
- if self.env.machines[self.for_machine].is_windows():
- self.detect_lib_modules_win()
- else:
- self.detect_lib_modules_nix()
+ self.modules_found = [] # type: T.List[str]
+ self.modules_missing = [] # type: T.List[str]
- def check_find_requested_modules(self):
- # 3. Check if we can find the modules
- for m in self.requested_modules:
- if 'boost_' + m not in self.lib_modules:
- mlog.debug('Requested Boost library {!r} not found'.format(m))
+ # Do we need threads?
+ if 'thread' in self.modules:
+ if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
self.is_found = False
+ return
- def modname_from_filename(self, filename):
- modname = os.path.basename(filename)
- modname = modname.split('.', 1)[0]
- modname = modname.split('-', 1)[0]
- if modname.startswith('libboost'):
- modname = modname[3:]
- return modname
-
- def compiler_tag(self):
- tag = None
- compiler = self.env.detect_cpp_compiler(self.for_machine)
- if self.env.machines[self.for_machine].is_windows():
- if compiler.get_id() in ['msvc', 'clang-cl']:
- comp_ts_version = compiler.get_toolset_version()
- compiler_ts = comp_ts_version.split('.')
- # FIXME - what about other compilers?
- tag = '-vc{}{}'.format(compiler_ts[0], compiler_ts[1])
- else:
- tag = ''
- return tag
+ # Try figuring out the architecture tag
+ self.arch = environment.machines[self.for_machine].cpu_family
+ self.arch = boost_arch_map.get(self.arch, None)
+
+ # First, look for paths specified in a machine file
+ props = self.env.properties[self.for_machine]
+ if any(x in self.env.properties[self.for_machine] for x in
+ ['boost_includedir', 'boost_librarydir', 'boost_root']):
+ self.detect_boost_machine_file(props)
+ return
- def threading_tag(self):
- if not self.is_multithreading:
- return ''
-
- if self.env.machines[self.for_machine].is_darwin():
- # - Mac: requires -mt for multithreading, so should not fall back to non-mt libraries.
- return '-mt'
- elif self.env.machines[self.for_machine].is_windows():
- # - Windows: requires -mt for multithreading, so should not fall back to non-mt libraries.
- return '-mt'
- else:
- # - Linux: leaves off -mt but libraries are multithreading-aware.
- # - Cygwin: leaves off -mt but libraries are multithreading-aware.
- return ''
-
- def version_tag(self):
- return '-' + self.version.replace('.', '_')
-
- def debug_tag(self):
- return '-gd' if self.is_debug else ''
-
- def arch_tag(self):
- # currently only applies to windows msvc installed binaries
- if self.env.detect_cpp_compiler(self.for_machine).get_id() not in ['msvc', 'clang-cl']:
- return ''
- # pre-compiled binaries only added arch tag for versions > 1.64
- if float(self.version) < 1.65:
- return ''
- arch = detect_cpu_family(self.env.coredata.compilers.host)
- if arch == 'x86':
- return '-x32'
- elif arch == 'x86_64':
- return '-x64'
- return ''
+ # Finally, look for paths from .pc files and from searching the filesystem
+ self.detect_roots()
- def versioned_abi_tag(self):
- return self.compiler_tag() + self.threading_tag() + self.debug_tag() + self.arch_tag() + self.version_tag()
+ def check_and_set_roots(self, roots: T.List[Path], use_system: bool) -> None:
+ roots = list(mesonlib.OrderedSet(roots))
+ for j in roots:
+ # 1. Look for the boost headers (boost/version.hpp)
+ mlog.debug(f'Checking potential boost root {j.as_posix()}')
+ inc_dirs = self.detect_inc_dirs(j)
+ inc_dirs = sorted(inc_dirs, reverse=True) # Prefer the newer versions
+
+ # Early abort when boost is not found
+ if not inc_dirs:
+ continue
+
+ lib_dirs = self.detect_lib_dirs(j, use_system)
+ self.is_found = self.run_check(inc_dirs, lib_dirs)
+ if self.is_found:
+ self.boost_root = j
+ break
+
+ def detect_boost_machine_file(self, props: 'Properties') -> None:
+ """Detect boost with values in the machine file or environment.
+
+ The machine file values are defaulted to the environment values.
+ """
+ # XXX: if we had a TypedDict we wouldn't need this
+ incdir = props.get('boost_includedir')
+ assert incdir is None or isinstance(incdir, str)
+ libdir = props.get('boost_librarydir')
+ assert libdir is None or isinstance(libdir, str)
+
+ if incdir and libdir:
+ inc_dir = Path(incdir)
+ lib_dir = Path(libdir)
+
+ if not inc_dir.is_absolute() or not lib_dir.is_absolute():
+ raise DependencyException('Paths given for boost_includedir and boost_librarydir in machine file must be absolute')
+
+ mlog.debug('Trying to find boost with:')
+ mlog.debug(f' - boost_includedir = {inc_dir}')
+ mlog.debug(f' - boost_librarydir = {lib_dir}')
+
+ return self.detect_split_root(inc_dir, lib_dir)
+
+ elif incdir or libdir:
+ raise DependencyException('Both boost_includedir *and* boost_librarydir have to be set in your machine file (one is not enough)')
+
+ rootdir = props.get('boost_root')
+ # It shouldn't be possible to get here without something in boost_root
+ assert rootdir
+
+ raw_paths = mesonlib.stringlistify(rootdir)
+ paths = [Path(x) for x in raw_paths]
+ if paths and any([not x.is_absolute() for x in paths]):
+ raise DependencyException('boost_root path given in machine file must be absolute')
+
+ self.check_and_set_roots(paths, use_system=False)
+
+ def run_check(self, inc_dirs: T.List[BoostIncludeDir], lib_dirs: T.List[Path]) -> bool:
+ mlog.debug(' - potential library dirs: {}'.format([x.as_posix() for x in lib_dirs]))
+ mlog.debug(' - potential include dirs: {}'.format([x.path.as_posix() for x in inc_dirs]))
+
+ # 2. Find all boost libraries
+ libs = [] # type: T.List[BoostLibraryFile]
+ for i in lib_dirs:
+ libs = self.detect_libraries(i)
+ if libs:
+ mlog.debug(f' - found boost library dir: {i}')
+ # mlog.debug(' - raw library list:')
+ # for j in libs:
+ # mlog.debug(' - {}'.format(j))
+ break
+ libs = sorted(set(libs))
+
+ modules = ['boost_' + x for x in self.modules]
+ for inc in inc_dirs:
+ mlog.debug(f' - found boost {inc.version} include dir: {inc.path}')
+ f_libs = self.filter_libraries(libs, inc.version_lib)
+
+ mlog.debug(' - filtered library list:')
+ for j in f_libs:
+ mlog.debug(f' - {j}')
+
+ # 3. Select the libraries matching the requested modules
+ not_found = [] # type: T.List[str]
+ selected_modules = [] # type: T.List[BoostLibraryFile]
+ for mod in modules:
+ found = False
+ for l in f_libs:
+ if l.mod_name_matches(mod):
+ selected_modules += [l]
+ found = True
+ break
+ if not found:
+ not_found += [mod]
- # FIXME - how to handle different distributions, e.g. for Mac? Currently we handle homebrew and macports, but not fink.
- def abi_tags(self):
- if self.env.machines[self.for_machine].is_windows():
- return [self.versioned_abi_tag(), self.threading_tag()]
- else:
- return [self.threading_tag()]
+ # log the result
+ mlog.debug(' - found:')
+ comp_args = [] # type: T.List[str]
+ link_args = [] # type: T.List[str]
+ for j in selected_modules:
+ c_args = j.get_compiler_args()
+ l_args = j.get_link_args()
+ mlog.debug(' - {:<24} link={} comp={}'.format(j.mod_name, str(l_args), str(c_args)))
+ comp_args += c_args
+ link_args += l_args
+
+ comp_args = list(set(comp_args))
+ link_args = list(set(link_args))
+
+ self.modules_found = [x.mod_name for x in selected_modules]
+ self.modules_found = [x[6:] for x in self.modules_found]
+ self.modules_found = sorted(set(self.modules_found))
+ self.modules_missing = not_found
+ self.modules_missing = [x[6:] for x in self.modules_missing]
+ self.modules_missing = sorted(set(self.modules_missing))
+
+ # if we found all modules we are done
+ if not not_found:
+ self.version = inc.version
+ self.compile_args = ['-I' + inc.path.as_posix()]
+ self.compile_args += comp_args
+ self.compile_args += self._extra_compile_args()
+ self.compile_args = list(mesonlib.OrderedSet(self.compile_args))
+ self.link_args = link_args
+ mlog.debug(f' - final compile args: {self.compile_args}')
+ mlog.debug(f' - final link args: {self.link_args}')
+ return True
- def sourceforge_dir(self):
- if self.env.detect_cpp_compiler(self.for_machine).get_id() != 'msvc':
- return None
- comp_ts_version = self.env.detect_cpp_compiler(self.for_machine).get_toolset_version()
- arch = detect_cpu_family(self.env.coredata.compilers.host)
- if arch == 'x86':
- return 'lib32-msvc-{}'.format(comp_ts_version)
- elif arch == 'x86_64':
- return 'lib64-msvc-{}'.format(comp_ts_version)
- else:
- # Does anyone do Boost cross-compiling to other archs on Windows?
- return None
+ # in case we missed something log it and try again
+ mlog.debug(' - NOT found:')
+ for mod in not_found:
+ mlog.debug(f' - {mod}')
- def find_libraries_with_abi_tag(self, tag):
+ return False
- # All modules should have the same tag
- self.lib_modules = {}
+ def detect_inc_dirs(self, root: Path) -> T.List[BoostIncludeDir]:
+ candidates = [] # type: T.List[Path]
+ inc_root = root / 'include'
+
+ candidates += [root / 'boost']
+ candidates += [inc_root / 'boost']
+ if inc_root.is_dir():
+ for i in inc_root.iterdir():
+ if not i.is_dir() or not i.name.startswith('boost-'):
+ continue
+ candidates += [i / 'boost']
+ candidates = [x for x in candidates if x.is_dir()]
+ candidates = [x / 'version.hpp' for x in candidates]
+ candidates = [x for x in candidates if x.exists()]
+ return [self._include_dir_from_version_header(x) for x in candidates]
+
+ def detect_lib_dirs(self, root: Path, use_system: bool) -> T.List[Path]:
+ # First check the system include paths. Only consider those within the
+ # given root path
+
+ if use_system:
+ system_dirs_t = self.clib_compiler.get_library_dirs(self.env)
+ system_dirs = [Path(x) for x in system_dirs_t]
+ system_dirs = [x.resolve() for x in system_dirs if x.exists()]
+ system_dirs = [x for x in system_dirs if mesonlib.path_is_in_root(x, root)]
+ system_dirs = list(mesonlib.OrderedSet(system_dirs))
+
+ if system_dirs:
+ return system_dirs
+
+ # No system include paths were found --> fall back to manually looking
+ # for library dirs in root
+ dirs = [] # type: T.List[Path]
+ subdirs = [] # type: T.List[Path]
+ for i in root.iterdir():
+ if i.is_dir() and i.name.startswith('lib'):
+ dirs += [i]
+
+ # Some distros put libraries not directly inside /usr/lib but in /usr/lib/x86_64-linux-gnu
+ for i in dirs:
+ for j in i.iterdir():
+ if j.is_dir() and j.name.endswith('-linux-gnu'):
+ subdirs += [j]
+
+ # Filter out paths that don't match the target arch to avoid finding
+ # the wrong libraries. See https://github.com/mesonbuild/meson/issues/7110
+ if not self.arch:
+ return dirs + subdirs
+
+ arch_list_32 = ['32', 'i386']
+ arch_list_64 = ['64']
+
+ raw_list = dirs + subdirs
+ no_arch = [x for x in raw_list if not any([y in x.name for y in arch_list_32 + arch_list_64])]
+
+ matching_arch = [] # type: T.List[Path]
+ if '32' in self.arch:
+ matching_arch = [x for x in raw_list if any([y in x.name for y in arch_list_32])]
+ elif '64' in self.arch:
+ matching_arch = [x for x in raw_list if any([y in x.name for y in arch_list_64])]
+
+ return sorted(matching_arch) + sorted(no_arch)
+
+ def filter_libraries(self, libs: T.List[BoostLibraryFile], lib_vers: str) -> T.List[BoostLibraryFile]:
+ # MSVC is very picky with the library tags
+ vscrt = ''
+ try:
+ crt_val = self.env.coredata.options[mesonlib.OptionKey('b_vscrt')].value
+ buildtype = self.env.coredata.options[mesonlib.OptionKey('buildtype')].value
+ vscrt = self.clib_compiler.get_crt_compile_args(crt_val, buildtype)[0]
+ except (KeyError, IndexError, AttributeError):
+ pass
- all_found = True
+ # mlog.debug(' - static: {}'.format(self.static))
+ # mlog.debug(' - not explicit static: {}'.format(not self.explicit_static))
+ # mlog.debug(' - mt: {}'.format(self.multithreading))
+ # mlog.debug(' - version: {}'.format(lib_vers))
+ # mlog.debug(' - arch: {}'.format(self.arch))
+ # mlog.debug(' - vscrt: {}'.format(vscrt))
+ libs = [x for x in libs if x.static == self.static or not self.explicit_static]
+ libs = [x for x in libs if x.mt == self.multithreading]
+ libs = [x for x in libs if x.version_matches(lib_vers)]
+ libs = [x for x in libs if x.arch_matches(self.arch)]
+ libs = [x for x in libs if x.vscrt_matches(vscrt)]
+ libs = [x for x in libs if x.nvsuffix != 'dll'] # Only link to import libraries
+
+ # Only filter by debug when we are building in release mode. Debug
+ # libraries are automatically preferred through sorting otherwise.
+ if not self.debug:
+ libs = [x for x in libs if not x.debug]
+
+ # Take the abitag from the first library and filter by it. This
+ # ensures that we have a set of libraries that are always compatible.
+ if not libs:
+ return []
+ abitag = libs[0].abitag
+ libs = [x for x in libs if x.abitag == abitag]
+
+ return libs
+
+ def detect_libraries(self, libdir: Path) -> T.List[BoostLibraryFile]:
+ libs = set() # type: T.Set[BoostLibraryFile]
+ for i in libdir.iterdir():
+ if not i.is_file():
+ continue
+ if not any([i.name.startswith(x) for x in ['libboost_', 'boost_']]):
+ continue
+
+ libs.add(BoostLibraryFile(i.resolve()))
+
+ return [x for x in libs if x.is_boost()] # Filter out no boost libraries
+
+ def detect_split_root(self, inc_dir: Path, lib_dir: Path) -> None:
+ boost_inc_dir = None
+ for j in [inc_dir / 'version.hpp', inc_dir / 'boost' / 'version.hpp']:
+ if j.is_file():
+ boost_inc_dir = self._include_dir_from_version_header(j)
+ break
+ if not boost_inc_dir:
+ self.is_found = False
+ return
- for module in self.requested_modules:
- libname = 'boost_' + module + tag
+ self.is_found = self.run_check([boost_inc_dir], [lib_dir])
- args = self.clib_compiler.find_library(libname, self.env, self.extra_lib_dirs())
- if args is None:
- mlog.debug("Couldn\'t find library '{}' for boost module '{}' (ABI tag = '{}')".format(libname, module, tag))
- all_found = False
- else:
- mlog.debug('Link args for boost module "{}" are {}'.format(module, args))
- self.lib_modules['boost_' + module] = args
+ def detect_roots(self) -> None:
+ roots = [] # type: T.List[Path]
- return all_found
+ # Try getting the BOOST_ROOT from a boost.pc if it exists. This primarily
+ # allows BoostDependency to find boost from Conan. See #5438
+ try:
+ boost_pc = PkgConfigDependency('boost', self.env, {'required': False})
+ if boost_pc.found():
+ boost_root = boost_pc.get_pkgconfig_variable('prefix', {'default': None})
+ if boost_root:
+ roots += [Path(boost_root)]
+ except DependencyException:
+ pass
- def find_libraries_with_abi_tags(self, tags):
- for tag in tags:
- if self.find_libraries_with_abi_tag(tag):
- return True
- return False
+ # Add roots from system paths
+ inc_paths = [Path(x) for x in self.clib_compiler.get_default_include_dirs()]
+ inc_paths = [x.parent for x in inc_paths if x.exists()]
+ inc_paths = [x.resolve() for x in inc_paths]
+ roots += inc_paths
- def detect_lib_modules_win(self):
- if not self.libdir:
- # The libdirs in the distributed binaries (from sf)
- lib_sf = self.sourceforge_dir()
+ # Add system paths
+ if self.env.machines[self.for_machine].is_windows():
+ # Where boost built from source actually installs it
+ c_root = Path('C:/Boost')
+ if c_root.is_dir():
+ roots += [c_root]
+
+ # Where boost documentation says it should be
+ prog_files = Path('C:/Program Files/boost')
+ # Where boost prebuilt binaries are
+ local_boost = Path('C:/local')
+
+ candidates = [] # type: T.List[Path]
+ if prog_files.is_dir():
+ candidates += [*prog_files.iterdir()]
+ if local_boost.is_dir():
+ candidates += [*local_boost.iterdir()]
- if self.boost_root:
- roots = [self.boost_root]
- else:
- roots = self.boost_roots
- for root in roots:
- # The default libdir when building
- libdir = os.path.join(root, 'lib')
- if os.path.isdir(libdir):
- self.libdir = libdir
- break
- if lib_sf:
- full_path = os.path.join(root, lib_sf)
- if os.path.isdir(full_path):
- self.libdir = full_path
- break
+ roots += [x for x in candidates if x.name.lower().startswith('boost') and x.is_dir()]
+ else:
+ tmp = [] # type: T.List[Path]
- if not self.libdir:
- return
+ # Add some default system paths
+ tmp += [Path('/opt/local')]
+ tmp += [Path('/usr/local/opt/boost')]
+ tmp += [Path('/usr/local')]
+ tmp += [Path('/usr')]
+
+ # Cleanup paths
+ tmp = [x for x in tmp if x.is_dir()]
+ tmp = [x.resolve() for x in tmp]
+ roots += tmp
+
+ self.check_and_set_roots(roots, use_system=True)
+
+ def log_details(self) -> str:
+ res = ''
+ if self.modules_found:
+ res += 'found: ' + ', '.join(self.modules_found)
+ if self.modules_missing:
+ if res:
+ res += ' | '
+ res += 'missing: ' + ', '.join(self.modules_missing)
+ return res
- for name in self.need_static_link:
- # FIXME - why are we only looking for *.lib? Mingw provides *.dll.a and *.a
- libname = 'lib' + name + self.versioned_abi_tag() + '.lib'
- if os.path.isfile(os.path.join(self.libdir, libname)):
- self.lib_modules[self.modname_from_filename(libname)] = [libname]
- else:
- libname = "lib{}.lib".format(name)
- if os.path.isfile(os.path.join(self.libdir, libname)):
- self.lib_modules[name[3:]] = [libname]
-
- # globber1 applies to a layout=system installation
- # globber2 applies to a layout=versioned installation
- globber1 = 'libboost_*' if self.static else 'boost_*'
- globber2 = globber1 + self.versioned_abi_tag()
- # FIXME - why are we only looking for *.lib? Mingw provides *.dll.a and *.a
- globber2_matches = glob.glob(os.path.join(self.libdir, globber2 + '.lib'))
- for entry in globber2_matches:
- fname = os.path.basename(entry)
- self.lib_modules[self.modname_from_filename(fname)] = [fname]
- if not globber2_matches:
- # FIXME - why are we only looking for *.lib? Mingw provides *.dll.a and *.a
- for entry in glob.glob(os.path.join(self.libdir, globber1 + '.lib')):
- if self.static:
- fname = os.path.basename(entry)
- self.lib_modules[self.modname_from_filename(fname)] = [fname]
-
- def detect_lib_modules_nix(self):
- if self.static:
- libsuffix = 'a'
- elif self.env.machines[self.for_machine].is_darwin():
- libsuffix = 'dylib'
- else:
- libsuffix = 'so'
+ def log_info(self) -> str:
+ if self.boost_root:
+ return self.boost_root.as_posix()
+ return ''
- globber = 'libboost_*.{}'.format(libsuffix)
- if self.libdir:
- libdirs = [self.libdir]
- elif self.boost_root is None:
- libdirs = mesonlib.get_library_dirs()
- else:
- libdirs = [os.path.join(self.boost_root, 'lib')]
- for libdir in libdirs:
- for name in self.need_static_link:
- libname = 'lib{}.a'.format(name)
- if os.path.isfile(os.path.join(libdir, libname)):
- self.lib_modules[name] = [libname]
- for entry in glob.glob(os.path.join(libdir, globber)):
- # I'm not 100% sure what to do here. Some distros
- # have modules such as thread only as -mt versions.
- # On debian all packages are built threading=multi
- # but not suffixed with -mt.
- # FIXME: implement detect_lib_modules_{debian, redhat, ...}
- # FIXME: this wouldn't work with -mt-gd either. -BDR
- if self.is_multithreading and mesonlib.is_debianlike():
- pass
- elif self.is_multithreading and entry.endswith('-mt.{}'.format(libsuffix)):
- pass
- elif not entry.endswith('-mt.{}'.format(libsuffix)):
- pass
- else:
- continue
- modname = self.modname_from_filename(entry)
- if modname not in self.lib_modules:
- self.lib_modules[modname] = [entry]
-
- def extra_lib_dirs(self):
- if self.libdir:
- return [self.libdir]
- elif self.boost_root:
- return [os.path.join(self.boost_root, 'lib')]
- return []
-
- def get_link_args(self, **kwargs):
- args = []
- for d in self.extra_lib_dirs():
- args += self.clib_compiler.get_linker_search_args(d)
- for lib in self.requested_modules:
- args += self.lib_modules['boost_' + lib]
- return args
+ def _include_dir_from_version_header(self, hfile: Path) -> BoostIncludeDir:
+ # Extract the version with a regex. Using clib_compiler.get_define would
+ # also work, however, this is slower (since it the compiler has to be
+ # invoked) and overkill since the layout of the header is always the same.
+ assert hfile.exists()
+ raw = hfile.read_text(encoding='utf-8')
+ m = re.search(r'#define\s+BOOST_VERSION\s+([0-9]+)', raw)
+ if not m:
+ mlog.debug(f'Failed to extract version information from {hfile}')
+ return BoostIncludeDir(hfile.parents[1], 0)
+ return BoostIncludeDir(hfile.parents[1], int(m.group(1)))
+
+ def _extra_compile_args(self) -> T.List[str]:
+ # BOOST_ALL_DYN_LINK should not be required with the known defines below
+ return ['-DBOOST_ALL_NO_LIB'] # Disable automatic linking
+
+
+# See https://www.boost.org/doc/libs/1_72_0/more/getting_started/unix-variants.html#library-naming
+# See https://mesonbuild.com/Reference-tables.html#cpu-families
+boost_arch_map = {
+ 'aarch64': 'a64',
+ 'arc': 'a32',
+ 'arm': 'a32',
+ 'ia64': 'i64',
+ 'mips': 'm32',
+ 'mips64': 'm64',
+ 'ppc': 'p32',
+ 'ppc64': 'p64',
+ 'sparc': 's32',
+ 'sparc64': 's64',
+ 'x86': 'x32',
+ 'x86_64': 'x64',
+}
+
+
+#### ---- BEGIN GENERATED ---- ####
+# #
+# Generated with tools/boost_names.py:
+# - boost version: 1.73.0
+# - modules found: 159
+# - libraries found: 43
+#
- def get_sources(self):
- return []
+class BoostLibrary():
+ def __init__(self, name: str, shared: T.List[str], static: T.List[str], single: T.List[str], multi: T.List[str]):
+ self.name = name
+ self.shared = shared
+ self.static = static
+ self.single = single
+ self.multi = multi
+
+class BoostModule():
+ def __init__(self, name: str, key: str, desc: str, libs: T.List[str]):
+ self.name = name
+ self.key = key
+ self.desc = desc
+ self.libs = libs
+
+
+# dict of all know libraries with additional compile options
+boost_libraries = {
+ 'boost_atomic': BoostLibrary(
+ name='boost_atomic',
+ shared=['-DBOOST_ATOMIC_DYN_LINK=1'],
+ static=['-DBOOST_ATOMIC_STATIC_LINK=1'],
+ single=[],
+ multi=[],
+ ),
+ 'boost_chrono': BoostLibrary(
+ name='boost_chrono',
+ shared=['-DBOOST_CHRONO_DYN_LINK=1'],
+ static=['-DBOOST_CHRONO_STATIC_LINK=1'],
+ single=['-DBOOST_CHRONO_THREAD_DISABLED'],
+ multi=[],
+ ),
+ 'boost_container': BoostLibrary(
+ name='boost_container',
+ shared=['-DBOOST_CONTAINER_DYN_LINK=1'],
+ static=['-DBOOST_CONTAINER_STATIC_LINK=1'],
+ single=[],
+ multi=[],
+ ),
+ 'boost_context': BoostLibrary(
+ name='boost_context',
+ shared=['-DBOOST_CONTEXT_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_contract': BoostLibrary(
+ name='boost_contract',
+ shared=['-DBOOST_CONTRACT_DYN_LINK'],
+ static=['-DBOOST_CONTRACT_STATIC_LINK'],
+ single=['-DBOOST_CONTRACT_DISABLE_THREADS'],
+ multi=[],
+ ),
+ 'boost_coroutine': BoostLibrary(
+ name='boost_coroutine',
+ shared=['-DBOOST_COROUTINES_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_date_time': BoostLibrary(
+ name='boost_date_time',
+ shared=['-DBOOST_DATE_TIME_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_exception': BoostLibrary(
+ name='boost_exception',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_fiber': BoostLibrary(
+ name='boost_fiber',
+ shared=['-DBOOST_FIBERS_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_fiber_numa': BoostLibrary(
+ name='boost_fiber_numa',
+ shared=['-DBOOST_FIBERS_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_filesystem': BoostLibrary(
+ name='boost_filesystem',
+ shared=['-DBOOST_FILESYSTEM_DYN_LINK=1'],
+ static=['-DBOOST_FILESYSTEM_STATIC_LINK=1'],
+ single=[],
+ multi=[],
+ ),
+ 'boost_graph': BoostLibrary(
+ name='boost_graph',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_iostreams': BoostLibrary(
+ name='boost_iostreams',
+ shared=['-DBOOST_IOSTREAMS_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_locale': BoostLibrary(
+ name='boost_locale',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_log': BoostLibrary(
+ name='boost_log',
+ shared=['-DBOOST_LOG_DYN_LINK=1'],
+ static=[],
+ single=['-DBOOST_LOG_NO_THREADS'],
+ multi=[],
+ ),
+ 'boost_log_setup': BoostLibrary(
+ name='boost_log_setup',
+ shared=['-DBOOST_LOG_SETUP_DYN_LINK=1'],
+ static=[],
+ single=['-DBOOST_LOG_NO_THREADS'],
+ multi=[],
+ ),
+ 'boost_math_c99': BoostLibrary(
+ name='boost_math_c99',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_math_c99f': BoostLibrary(
+ name='boost_math_c99f',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_math_c99l': BoostLibrary(
+ name='boost_math_c99l',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_math_tr1': BoostLibrary(
+ name='boost_math_tr1',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_math_tr1f': BoostLibrary(
+ name='boost_math_tr1f',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_math_tr1l': BoostLibrary(
+ name='boost_math_tr1l',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_mpi': BoostLibrary(
+ name='boost_mpi',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_nowide': BoostLibrary(
+ name='boost_nowide',
+ shared=['-DBOOST_NOWIDE_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_prg_exec_monitor': BoostLibrary(
+ name='boost_prg_exec_monitor',
+ shared=['-DBOOST_TEST_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_program_options': BoostLibrary(
+ name='boost_program_options',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_random': BoostLibrary(
+ name='boost_random',
+ shared=['-DBOOST_RANDOM_DYN_LINK'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_regex': BoostLibrary(
+ name='boost_regex',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_serialization': BoostLibrary(
+ name='boost_serialization',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_stacktrace_addr2line': BoostLibrary(
+ name='boost_stacktrace_addr2line',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_stacktrace_backtrace': BoostLibrary(
+ name='boost_stacktrace_backtrace',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_stacktrace_basic': BoostLibrary(
+ name='boost_stacktrace_basic',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_stacktrace_noop': BoostLibrary(
+ name='boost_stacktrace_noop',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_stacktrace_windbg': BoostLibrary(
+ name='boost_stacktrace_windbg',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_stacktrace_windbg_cached': BoostLibrary(
+ name='boost_stacktrace_windbg_cached',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_system': BoostLibrary(
+ name='boost_system',
+ shared=['-DBOOST_SYSTEM_DYN_LINK=1'],
+ static=['-DBOOST_SYSTEM_STATIC_LINK=1'],
+ single=[],
+ multi=[],
+ ),
+ 'boost_test_exec_monitor': BoostLibrary(
+ name='boost_test_exec_monitor',
+ shared=['-DBOOST_TEST_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_thread': BoostLibrary(
+ name='boost_thread',
+ shared=['-DBOOST_THREAD_BUILD_DLL=1', '-DBOOST_THREAD_USE_DLL=1'],
+ static=['-DBOOST_THREAD_BUILD_LIB=1', '-DBOOST_THREAD_USE_LIB=1'],
+ single=[],
+ multi=[],
+ ),
+ 'boost_timer': BoostLibrary(
+ name='boost_timer',
+ shared=['-DBOOST_TIMER_DYN_LINK=1'],
+ static=['-DBOOST_TIMER_STATIC_LINK=1'],
+ single=[],
+ multi=[],
+ ),
+ 'boost_type_erasure': BoostLibrary(
+ name='boost_type_erasure',
+ shared=['-DBOOST_TYPE_ERASURE_DYN_LINK'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_unit_test_framework': BoostLibrary(
+ name='boost_unit_test_framework',
+ shared=['-DBOOST_TEST_DYN_LINK=1'],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_wave': BoostLibrary(
+ name='boost_wave',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+ 'boost_wserialization': BoostLibrary(
+ name='boost_wserialization',
+ shared=[],
+ static=[],
+ single=[],
+ multi=[],
+ ),
+}
-# Generated with boost_names.py
-BOOST_LIBS = [
- 'boost_atomic',
- 'boost_chrono',
- 'boost_chrono',
- 'boost_container',
- 'boost_context',
- 'boost_coroutine',
- 'boost_date_time',
- 'boost_exception',
- 'boost_fiber',
- 'boost_filesystem',
- 'boost_graph',
- 'boost_iostreams',
- 'boost_locale',
- 'boost_log',
- 'boost_log_setup',
- 'boost_math_tr1',
- 'boost_math_tr1f',
- 'boost_math_tr1l',
- 'boost_math_c99',
- 'boost_math_c99f',
- 'boost_math_c99l',
- 'boost_math_tr1',
- 'boost_math_tr1f',
- 'boost_math_tr1l',
- 'boost_math_c99',
- 'boost_math_c99f',
- 'boost_math_c99l',
- 'boost_math_tr1',
- 'boost_math_tr1f',
- 'boost_math_tr1l',
- 'boost_math_c99',
- 'boost_math_c99f',
- 'boost_math_c99l',
- 'boost_math_tr1',
- 'boost_math_tr1f',
- 'boost_math_tr1l',
- 'boost_math_c99',
- 'boost_math_c99f',
- 'boost_math_c99l',
- 'boost_math_tr1',
- 'boost_math_tr1f',
- 'boost_math_tr1l',
- 'boost_math_c99',
- 'boost_math_c99f',
- 'boost_math_c99l',
- 'boost_math_tr1',
- 'boost_math_tr1f',
- 'boost_math_tr1l',
- 'boost_math_c99',
- 'boost_math_c99f',
- 'boost_math_c99l',
- 'boost_mpi',
- 'boost_program_options',
- 'boost_random',
- 'boost_regex',
- 'boost_serialization',
- 'boost_wserialization',
- 'boost_signals',
- 'boost_stacktrace_noop',
- 'boost_stacktrace_backtrace',
- 'boost_stacktrace_addr2line',
- 'boost_stacktrace_basic',
- 'boost_stacktrace_windbg',
- 'boost_stacktrace_windbg_cached',
- 'boost_system',
- 'boost_prg_exec_monitor',
- 'boost_test_exec_monitor',
- 'boost_unit_test_framework',
- 'boost_thread',
- 'boost_timer',
- 'boost_type_erasure',
- 'boost_wave'
-]
-
-BOOST_DIRS = [
- 'lambda',
- 'optional',
- 'convert',
- 'system',
- 'uuid',
- 'archive',
- 'align',
- 'timer',
- 'chrono',
- 'gil',
- 'logic',
- 'signals',
- 'predef',
- 'tr1',
- 'multi_index',
- 'property_map',
- 'multi_array',
- 'context',
- 'random',
- 'endian',
- 'circular_buffer',
- 'proto',
- 'assign',
- 'format',
- 'math',
- 'phoenix',
- 'graph',
- 'locale',
- 'mpl',
- 'pool',
- 'unordered',
- 'core',
- 'exception',
- 'ptr_container',
- 'flyweight',
- 'range',
- 'typeof',
- 'thread',
- 'move',
- 'spirit',
- 'dll',
- 'compute',
- 'serialization',
- 'ratio',
- 'msm',
- 'config',
- 'metaparse',
- 'coroutine2',
- 'qvm',
- 'program_options',
- 'concept',
- 'detail',
- 'hana',
- 'concept_check',
- 'compatibility',
- 'variant',
- 'type_erasure',
- 'mpi',
- 'test',
- 'fusion',
- 'log',
- 'sort',
- 'local_function',
- 'units',
- 'functional',
- 'preprocessor',
- 'integer',
- 'container',
- 'polygon',
- 'interprocess',
- 'numeric',
- 'iterator',
- 'wave',
- 'lexical_cast',
- 'multiprecision',
- 'utility',
- 'tti',
- 'asio',
- 'dynamic_bitset',
- 'algorithm',
- 'xpressive',
- 'bimap',
- 'signals2',
- 'type_traits',
- 'regex',
- 'statechart',
- 'parameter',
- 'icl',
- 'python',
- 'lockfree',
- 'intrusive',
- 'io',
- 'pending',
- 'geometry',
- 'tuple',
- 'iostreams',
- 'heap',
- 'atomic',
- 'filesystem',
- 'smart_ptr',
- 'function',
- 'fiber',
- 'type_index',
- 'accumulators',
- 'function_types',
- 'coroutine',
- 'vmd',
- 'date_time',
- 'property_tree',
- 'bind'
-]
+# #
+#### ---- END GENERATED ---- ####
diff -Nru meson-0.53.2/mesonbuild/dependencies/cmake.py meson-0.61.2/mesonbuild/dependencies/cmake.py
--- meson-0.53.2/mesonbuild/dependencies/cmake.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/cmake.py 2022-01-17 10:50:45.000000000 +0000
@@ -0,0 +1,644 @@
+# 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 ExternalDependency, DependencyException, DependencyTypeName
+from ..mesonlib import is_windows, MesonException, OptionKey, PerMachine, stringlistify, extract_as_list
+from ..mesondata import mesondata
+from ..cmake import CMakeExecutor, CMakeTraceParser, CMakeException, CMakeToolchain, CMakeExecScope, check_cmake_args, CMakeTarget, resolve_cmake_trace_targets, cmake_is_debug
+from .. import mlog
+from pathlib import Path
+import functools
+import re
+import os
+import shutil
+import textwrap
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+ from ..envconfig import MachineInfo
+
+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) -> None:
+ # Gather a list of all languages to support
+ self.language_list = [] # type: T.List[str]
+ if language is None:
+ 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())
+
+ 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())
+ 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 , /cmake, /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 /(lib/|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 /(lib/|lib*|share)/cmake/*/
+ 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
+
+ # /(lib/|lib*|share)/*/
+ # /(lib/|lib*|share)/*/(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 = [] # type: 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 += 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}::', ...])
+
+ 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 vraiables. 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 implizitly `general`
+ cfg_matches = True
+
+ # Try to use old style variables if no module is specified
+ if len(libs) > 0:
+ self.compile_args = list(map(lambda x: f'-I{x}', 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 = mesondata['dependencies/data/' + cmake_file].data
+
+ # 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)
+
+ def log_tried(self) -> str:
+ return self.type_name
+
+ 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: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
+ if cmake and self.traceparser is not None:
+ try:
+ v = self.traceparser.vars[cmake]
+ except KeyError:
+ pass
+ else:
+ if len(v) == 1:
+ return v[0]
+ elif v:
+ return 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}')
diff -Nru meson-0.53.2/mesonbuild/dependencies/coarrays.py meson-0.61.2/mesonbuild/dependencies/coarrays.py
--- meson-0.53.2/mesonbuild/dependencies/coarrays.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/coarrays.py 2021-11-02 19:58:07.000000000 +0000
@@ -12,11 +12,47 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from ..mesonlib import listify
-from .base import CMakeDependency, DependencyMethods, ExternalDependency, PkgConfigDependency
+import functools
+import typing as T
+from .base import DependencyMethods, detect_compiler, SystemDependency
+from .cmake import CMakeDependency
+from .pkgconfig import PkgConfigDependency
+from .factory import factory_methods
+
+if T.TYPE_CHECKING:
+ from . factory import DependencyGenerator
+ from ..environment import Environment, MachineChoice
+
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE, DependencyMethods.SYSTEM})
+def coarray_factory(env: 'Environment',
+ for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any],
+ methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ fcid = detect_compiler('coarray', env, for_machine, 'fortran').get_id()
+ candidates: T.List['DependencyGenerator'] = []
+
+ if fcid == 'gcc':
+ # OpenCoarrays is the most commonly used method for Fortran Coarray with GCC
+ if DependencyMethods.PKGCONFIG in methods:
+ for pkg in ['caf-openmpi', 'caf']:
+ candidates.append(functools.partial(
+ PkgConfigDependency, pkg, env, kwargs, language='fortran'))
+
+ if DependencyMethods.CMAKE in methods:
+ if 'modules' not in kwargs:
+ kwargs['modules'] = 'OpenCoarrays::caf_mpi'
+ candidates.append(functools.partial(
+ CMakeDependency, 'OpenCoarrays', env, kwargs, language='fortran'))
-class CoarrayDependency(ExternalDependency):
+ if DependencyMethods.SYSTEM in methods:
+ candidates.append(functools.partial(CoarrayDependency, env, kwargs))
+
+ return candidates
+
+
+class CoarrayDependency(SystemDependency):
"""
Coarrays are a Fortran 2008 feature.
@@ -25,59 +61,26 @@
Coarrays may be thought of as a high-level language abstraction of
low-level MPI calls.
"""
- def __init__(self, environment, kwargs: dict):
- super().__init__('coarray', environment, 'fortran', kwargs)
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__('coarray', environment, kwargs, language='fortran')
kwargs['required'] = False
kwargs['silent'] = True
- self.is_found = False
- methods = listify(self.methods)
cid = self.get_compiler().get_id()
if cid == 'gcc':
- """ OpenCoarrays is the most commonly used method for Fortran Coarray with GCC """
-
- if set([DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]).intersection(methods):
- for pkg in ['caf-openmpi', 'caf']:
- pkgdep = PkgConfigDependency(pkg, environment, kwargs, language=self.language)
- if pkgdep.found():
- self.compile_args = pkgdep.get_compile_args()
- self.link_args = pkgdep.get_link_args()
- self.version = pkgdep.get_version()
- self.is_found = True
- self.pcdep = pkgdep
- return
-
- if set([DependencyMethods.AUTO, DependencyMethods.CMAKE]).intersection(methods):
- if not kwargs.get('modules'):
- kwargs['modules'] = 'OpenCoarrays::caf_mpi'
- cmakedep = CMakeDependency('OpenCoarrays', environment, kwargs, language=self.language)
- if cmakedep.found():
- self.compile_args = cmakedep.get_compile_args()
- self.link_args = cmakedep.get_link_args()
- self.version = cmakedep.get_version()
- self.is_found = True
- return
-
- if DependencyMethods.AUTO in methods:
- # fallback to single image
- self.compile_args = ['-fcoarray=single']
- self.version = 'single image (fallback)'
- self.is_found = True
- return
-
+ # Fallback to single image
+ self.compile_args = ['-fcoarray=single']
+ self.version = 'single image (fallback)'
+ self.is_found = True
elif cid == 'intel':
- """ Coarrays are built into Intel compilers, no external library needed """
+ # Coarrays are built into Intel compilers, no external library needed
self.is_found = True
self.link_args = ['-coarray=shared']
self.compile_args = self.link_args
elif cid == 'intel-cl':
- """ Coarrays are built into Intel compilers, no external library needed """
+ # Coarrays are built into Intel compilers, no external library needed
self.is_found = True
self.compile_args = ['/Qcoarray:shared']
elif cid == 'nagfor':
- """ NAG doesn't require any special arguments for Coarray """
+ # NAG doesn't require any special arguments for Coarray
self.is_found = True
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.CMAKE, DependencyMethods.PKGCONFIG]
diff -Nru meson-0.53.2/mesonbuild/dependencies/configtool.py meson-0.61.2/mesonbuild/dependencies/configtool.py
--- meson-0.53.2/mesonbuild/dependencies/configtool.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/configtool.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,174 @@
+# 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 ExternalDependency, DependencyException, DependencyTypeName
+from ..mesonlib import listify, Popen_safe, split_args, version_compare, version_compare_many
+from ..programs import find_external_program
+from .. import mlog
+import re
+import typing as T
+
+from mesonbuild import mesonlib
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
+class ConfigToolDependency(ExternalDependency):
+
+ """Class representing dependencies found using a config tool.
+
+ Takes the following extra keys in kwargs that it uses internally:
+ :tools List[str]: A list of tool names to use
+ :version_arg str: The argument to pass to the tool to get it's version
+ :returncode_value int: The value of the correct returncode
+ Because some tools are stupid and don't return 0
+ """
+
+ tools: T.Optional[T.List[str]] = None
+ tool_name: T.Optional[str] = None
+ version_arg = '--version'
+ __strip_version = re.compile(r'^[0-9][0-9.]+')
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None):
+ super().__init__(DependencyTypeName('config-tool'), environment, kwargs, language=language)
+ self.name = name
+ # You may want to overwrite the class version in some cases
+ self.tools = listify(kwargs.get('tools', self.tools))
+ if not self.tool_name:
+ self.tool_name = self.tools[0]
+ if 'version_arg' in kwargs:
+ self.version_arg = kwargs['version_arg']
+
+ req_version_raw = kwargs.get('version', None)
+ if req_version_raw is not None:
+ req_version = mesonlib.stringlistify(req_version_raw)
+ else:
+ req_version = []
+ tool, version = self.find_config(req_version, kwargs.get('returncode_value', 0))
+ self.config = tool
+ self.is_found = self.report_config(version, req_version)
+ if not self.is_found:
+ self.config = None
+ return
+ self.version = version
+
+ def _sanitize_version(self, version: str) -> str:
+ """Remove any non-numeric, non-point version suffixes."""
+ m = self.__strip_version.match(version)
+ if m:
+ # Ensure that there isn't a trailing '.', such as an input like
+ # `1.2.3.git-1234`
+ return m.group(0).rstrip('.')
+ return version
+
+ def find_config(self, versions: T.List[str], returncode: int = 0) \
+ -> T.Tuple[T.Optional[T.List[str]], T.Optional[str]]:
+ """Helper method that searches for config tool binaries in PATH and
+ returns the one that best matches the given version requirements.
+ """
+ best_match: T.Tuple[T.Optional[T.List[str]], T.Optional[str]] = (None, None)
+ for potential_bin in find_external_program(
+ self.env, self.for_machine, self.tool_name,
+ self.tool_name, self.tools, allow_default_for_cross=False):
+ if not potential_bin.found():
+ continue
+ tool = potential_bin.get_command()
+ try:
+ p, out = Popen_safe(tool + [self.version_arg])[:2]
+ except (FileNotFoundError, PermissionError):
+ continue
+ if p.returncode != returncode:
+ continue
+
+ out = self._sanitize_version(out.strip())
+ # Some tools, like pcap-config don't supply a version, but also
+ # don't fail with --version, in that case just assume that there is
+ # only one version and return it.
+ if not out:
+ return (tool, None)
+ if versions:
+ is_found = version_compare_many(out, versions)[0]
+ # This allows returning a found version without a config tool,
+ # which is useful to inform the user that you found version x,
+ # but y was required.
+ if not is_found:
+ tool = None
+ if best_match[1]:
+ if version_compare(out, '> {}'.format(best_match[1])):
+ best_match = (tool, out)
+ else:
+ best_match = (tool, out)
+
+ return best_match
+
+ def report_config(self, version: T.Optional[str], req_version: T.List[str]) -> bool:
+ """Helper method to print messages about the tool."""
+
+ found_msg: T.List[T.Union[str, mlog.AnsiDecorator]] = [mlog.bold(self.tool_name), 'found:']
+
+ if self.config is None:
+ found_msg.append(mlog.red('NO'))
+ if version is not None and req_version:
+ found_msg.append(f'found {version!r} but need {req_version!r}')
+ elif req_version:
+ found_msg.append(f'need {req_version!r}')
+ else:
+ found_msg += [mlog.green('YES'), '({})'.format(' '.join(self.config)), version]
+
+ mlog.log(*found_msg)
+
+ return self.config is not None
+
+ def get_config_value(self, args: T.List[str], stage: str) -> T.List[str]:
+ p, out, err = Popen_safe(self.config + args)
+ if p.returncode != 0:
+ if self.required:
+ raise DependencyException(f'Could not generate {stage} for {self.name}.\n{err}')
+ return []
+ return split_args(out)
+
+ def get_configtool_variable(self, variable_name: str) -> str:
+ p, out, _ = Popen_safe(self.config + [f'--{variable_name}'])
+ if p.returncode != 0:
+ if self.required:
+ raise DependencyException(
+ 'Could not get variable "{}" for dependency {}'.format(
+ variable_name, self.name))
+ variable = out.strip()
+ mlog.debug(f'Got config-tool variable {variable_name} : {variable}')
+ return variable
+
+ def log_tried(self) -> str:
+ return self.type_name
+
+ 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: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
+ if configtool:
+ # In the not required case '' (empty string) will be returned if the
+ # variable is not found. Since '' is a valid value to return we
+ # set required to True here to force and error, and use the
+ # finally clause to ensure it's restored.
+ restore = self.required
+ self.required = True
+ try:
+ return self.get_configtool_variable(configtool)
+ except DependencyException:
+ pass
+ finally:
+ self.required = restore
+ if default_value is not None:
+ return default_value
+ raise DependencyException(f'Could not get config-tool variable and no default provided for {self!r}')
diff -Nru meson-0.53.2/mesonbuild/dependencies/cuda.py meson-0.61.2/mesonbuild/dependencies/cuda.py
--- meson-0.53.2/mesonbuild/dependencies/cuda.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/cuda.py 2021-11-02 19:58:07.000000000 +0000
@@ -15,25 +15,33 @@
import glob
import re
import os
+import typing as T
+from pathlib import Path
-from .. import mlog
from .. import mesonlib
+from .. import mlog
from ..environment import detect_cpu_family
+from .base import DependencyException, SystemDependency
+
-from .base import (DependencyException, ExternalDependency)
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+ from ..compilers import Compiler
+TV_ResultTuple = T.Tuple[T.Optional[str], T.Optional[str], bool]
-class CudaDependency(ExternalDependency):
+class CudaDependency(SystemDependency):
supported_languages = ['cuda', 'cpp', 'c'] # see also _default_language
- def __init__(self, environment, kwargs):
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
compilers = environment.coredata.compilers[self.get_for_machine_from_kwargs(kwargs)]
language = self._detect_language(compilers)
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))
+ raise DependencyException(f'Language \'{language}\' is not supported by the CUDA Toolkit. Supported languages are {self.supported_languages}.')
- super().__init__('cuda', environment, language, kwargs)
+ super().__init__('cuda', environment, kwargs, language=language)
+ self.lib_modules: T.Dict[str, T.List[str]] = {}
self.requested_modules = self.get_requested(kwargs)
if 'cudart' not in self.requested_modules:
self.requested_modules = ['cudart'] + self.requested_modules
@@ -43,13 +51,13 @@
return
if not os.path.isabs(self.cuda_path):
- raise DependencyException('CUDA Toolkit path must be absolute, got \'{}\'.'.format(self.cuda_path))
+ raise DependencyException(f'CUDA Toolkit path must be absolute, got \'{self.cuda_path}\'.')
# nvcc already knows where to find the CUDA Toolkit, but if we're compiling
# a mixed C/C++/CUDA project, we still need to make the include dir searchable
if self.language != 'cuda' or len(compilers) > 1:
self.incdir = os.path.join(self.cuda_path, 'include')
- self.compile_args += ['-I{}'.format(self.incdir)]
+ self.compile_args += [f'-I{self.incdir}']
if self.language != 'cuda':
arch_libdir = self._detect_arch_libdir()
@@ -61,13 +69,13 @@
self.is_found = self._find_requested_libraries()
@classmethod
- def _detect_language(cls, compilers):
+ def _detect_language(cls, compilers: T.Dict[str, 'Compiler']) -> str:
for lang in cls.supported_languages:
if lang in compilers:
return lang
return list(compilers.keys())[0]
- def _detect_cuda_path_and_version(self):
+ def _detect_cuda_path_and_version(self) -> TV_ResultTuple:
self.env_var = self._default_path_env_var()
mlog.debug('Default path env var:', mlog.bold(self.env_var))
@@ -79,11 +87,11 @@
# make sure nvcc version satisfies specified version requirements
(found_some, not_found, found) = mesonlib.version_compare_many(nvcc_version, version_reqs)
if not_found:
- msg = 'The current nvcc version {} does not satisfy the specified CUDA Toolkit version requirements {}.'.format(nvcc_version, version_reqs)
+ msg = f'The current nvcc version {nvcc_version} does not satisfy the specified CUDA Toolkit version requirements {version_reqs}.'
return self._report_dependency_error(msg, (None, None, False))
# use nvcc version to find a matching CUDA Toolkit
- version_reqs = ['={}'.format(nvcc_version)]
+ version_reqs = [f'={nvcc_version}']
else:
nvcc_version = None
@@ -97,19 +105,20 @@
platform_msg = 'set the CUDA_PATH environment variable' if self._is_windows() \
else 'set the CUDA_PATH environment variable/create the \'/usr/local/cuda\' symbolic link'
- msg = 'Please specify the desired CUDA Toolkit version (e.g. dependency(\'cuda\', version : \'>=10.1\')) or {} to point to the location of your desired version.'.format(platform_msg)
+ msg = f'Please specify the desired CUDA Toolkit version (e.g. dependency(\'cuda\', version : \'>=10.1\')) or {platform_msg} to point to the location of your desired version.'
return self._report_dependency_error(msg, (None, None, False))
- def _find_matching_toolkit(self, paths, version_reqs, nvcc_version):
+ def _find_matching_toolkit(self, paths: T.List[TV_ResultTuple], version_reqs: T.List[str], nvcc_version: T.Optional[str]) -> TV_ResultTuple:
# keep the default paths order intact, sort the rest in the descending order
# according to the toolkit version
- defaults, rest = mesonlib.partition(lambda t: not t[2], paths)
- defaults = list(defaults)
- paths = defaults + sorted(rest, key=lambda t: mesonlib.Version(t[1]), reverse=True)
- mlog.debug('Search paths: {}'.format(paths))
+ part_func: T.Callable[[TV_ResultTuple], bool] = lambda t: not t[2]
+ defaults_it, rest_it = mesonlib.partition(part_func, paths)
+ defaults = list(defaults_it)
+ paths = defaults + sorted(rest_it, key=lambda t: mesonlib.Version(t[1]), reverse=True)
+ mlog.debug(f'Search paths: {paths}')
if nvcc_version and defaults:
- default_src = "the {} environment variable".format(self.env_var) if self.env_var else "the \'/usr/local/cuda\' symbolic link"
+ default_src = f"the {self.env_var} environment variable" if self.env_var else "the \'/usr/local/cuda\' symbolic link"
nvcc_warning = 'The default CUDA Toolkit as designated by {} ({}) doesn\'t match the current nvcc version {} and will be ignored.'.format(default_src, os.path.realpath(defaults[0][0]), nvcc_version)
else:
nvcc_warning = None
@@ -125,23 +134,23 @@
mlog.warning(nvcc_warning)
return (None, None, False)
- def _default_path_env_var(self):
+ def _default_path_env_var(self) -> T.Optional[str]:
env_vars = ['CUDA_PATH'] if self._is_windows() else ['CUDA_PATH', 'CUDA_HOME', 'CUDA_ROOT']
env_vars = [var for var in env_vars if var in os.environ]
- user_defaults = set([os.environ[var] for var in env_vars])
+ user_defaults = {os.environ[var] for var in env_vars}
if len(user_defaults) > 1:
mlog.warning('Environment variables {} point to conflicting toolkit locations ({}). Toolkit selection might produce unexpected results.'.format(', '.join(env_vars), ', '.join(user_defaults)))
return env_vars[0] if env_vars else None
- def _cuda_paths(self):
+ def _cuda_paths(self) -> T.List[T.Tuple[str, bool]]:
return ([(os.environ[self.env_var], True)] if self.env_var else []) \
+ (self._cuda_paths_win() if self._is_windows() else self._cuda_paths_nix())
- def _cuda_paths_win(self):
+ def _cuda_paths_win(self) -> T.List[T.Tuple[str, bool]]:
env_vars = os.environ.keys()
return [(os.environ[var], False) for var in env_vars if var.startswith('CUDA_PATH_')]
- def _cuda_paths_nix(self):
+ def _cuda_paths_nix(self) -> T.List[T.Tuple[str, bool]]:
# include /usr/local/cuda default only if no env_var was found
pattern = '/usr/local/cuda-*' if self.env_var else '/usr/local/cuda*'
return [(path, os.path.basename(path) == 'cuda') for path in glob.iglob(pattern)]
@@ -149,40 +158,65 @@
toolkit_version_regex = re.compile(r'^CUDA Version\s+(.*)$')
path_version_win_regex = re.compile(r'^v(.*)$')
path_version_nix_regex = re.compile(r'^cuda-(.*)$')
+ cudart_version_regex = re.compile(r'#define\s+CUDART_VERSION\s+([0-9]+)')
- def _cuda_toolkit_version(self, path):
+ def _cuda_toolkit_version(self, path: str) -> str:
version = self._read_toolkit_version_txt(path)
if version:
return version
+ version = self._read_cuda_runtime_api_version(path)
+ if version:
+ return version
mlog.debug('Falling back to extracting version from path')
path_version_regex = self.path_version_win_regex if self._is_windows() else self.path_version_nix_regex
- m = path_version_regex.match(os.path.basename(path))
- if m:
- return m[1]
+ try:
+ m = path_version_regex.match(os.path.basename(path))
+ if m:
+ return m.group(1)
+ else:
+ mlog.warning(f'Could not detect CUDA Toolkit version for {path}')
+ except Exception as e:
+ mlog.warning(f'Could not detect CUDA Toolkit version for {path}: {e!s}')
- mlog.warning('Could not detect CUDA Toolkit version for {}'.format(path))
return '0.0'
- def _read_toolkit_version_txt(self, path):
- # Read 'version.txt' at the root of the CUDA Toolkit directory to determine the tookit version
+ def _read_cuda_runtime_api_version(self, path_str: str) -> T.Optional[str]:
+ path = Path(path_str)
+ for i in path.rglob('cuda_runtime_api.h'):
+ raw = i.read_text(encoding='utf-8')
+ m = self.cudart_version_regex.search(raw)
+ if not m:
+ continue
+ try:
+ vers_int = int(m.group(1))
+ except ValueError:
+ continue
+ # use // for floor instead of / which produces a float
+ major = vers_int // 1000 # type: int
+ minor = (vers_int - major * 1000) // 10 # type: int
+ return f'{major}.{minor}'
+ return None
+
+ def _read_toolkit_version_txt(self, path: str) -> T.Optional[str]:
+ # Read 'version.txt' at the root of the CUDA Toolkit directory to determine the toolkit version
version_file_path = os.path.join(path, 'version.txt')
try:
- with open(version_file_path) as version_file:
+ with open(version_file_path, encoding='utf-8') as version_file:
version_str = version_file.readline() # e.g. 'CUDA Version 10.1.168'
m = self.toolkit_version_regex.match(version_str)
if m:
- return self._strip_patch_version(m[1])
+ return self._strip_patch_version(m.group(1))
except Exception as e:
- mlog.debug('Could not read CUDA Toolkit\'s version file {}: {}'.format(version_file_path, str(e)))
+ mlog.debug(f'Could not read CUDA Toolkit\'s version file {version_file_path}: {e!s}')
return None
@classmethod
- def _strip_patch_version(cls, version):
+ def _strip_patch_version(cls, version: str) -> str:
return '.'.join(version.split('.')[:2])
- def _detect_arch_libdir(self):
+ def _detect_arch_libdir(self) -> str:
arch = detect_cpu_family(self.env.coredata.compilers.host)
machine = self.env.machines[self.for_machine]
msg = '{} architecture is not supported in {} version of the CUDA Toolkit.'
@@ -192,11 +226,11 @@
raise DependencyException(msg.format(arch, 'Windows'))
return os.path.join('lib', libdirs[arch])
elif machine.is_linux():
- libdirs = {'x86_64': 'lib64', 'ppc64': 'lib'}
+ libdirs = {'x86_64': 'lib64', 'ppc64': 'lib', 'aarch64': 'lib64', 'loongarch64': 'lib64'}
if arch not in libdirs:
raise DependencyException(msg.format(arch, 'Linux'))
return libdirs[arch]
- elif machine.is_osx():
+ elif machine.is_darwin():
libdirs = {'x86_64': 'lib64'}
if arch not in libdirs:
raise DependencyException(msg.format(arch, 'macOS'))
@@ -204,46 +238,51 @@
else:
raise DependencyException('CUDA Toolkit: unsupported platform.')
- def _find_requested_libraries(self):
- self.lib_modules = {}
+ def _find_requested_libraries(self) -> bool:
all_found = True
for module in self.requested_modules:
args = self.clib_compiler.find_library(module, self.env, [self.libdir] if self.libdir else [])
if args is None:
- self._report_dependency_error('Couldn\'t find requested CUDA module \'{}\''.format(module))
+ self._report_dependency_error(f'Couldn\'t find requested CUDA module \'{module}\'')
all_found = False
else:
- mlog.debug('Link args for CUDA module \'{}\' are {}'.format(module, args))
+ mlog.debug(f'Link args for CUDA module \'{module}\' are {args}')
self.lib_modules[module] = args
return all_found
- def _is_windows(self):
+ def _is_windows(self) -> bool:
return self.env.machines[self.for_machine].is_windows()
- def _report_dependency_error(self, msg, ret_val=None):
+ @T.overload
+ def _report_dependency_error(self, msg: str) -> None: ...
+
+ @T.overload
+ def _report_dependency_error(self, msg: str, ret_val: TV_ResultTuple) -> TV_ResultTuple: ... # noqa: F811
+
+ def _report_dependency_error(self, msg: str, ret_val: T.Optional[TV_ResultTuple] = None) -> T.Optional[TV_ResultTuple]: # noqa: F811
if self.required:
raise DependencyException(msg)
mlog.debug(msg)
return ret_val
- def log_details(self):
+ def log_details(self) -> str:
module_str = ', '.join(self.requested_modules)
return 'modules: ' + module_str
- def log_info(self):
+ def log_info(self) -> str:
return self.cuda_path if self.cuda_path else ''
- def get_requested(self, kwargs):
+ def get_requested(self, kwargs: T.Dict[str, T.Any]) -> T.List[str]:
candidates = mesonlib.extract_as_list(kwargs, 'modules')
for c in candidates:
if not isinstance(c, str):
raise DependencyException('CUDA module argument is not a string.')
return candidates
- def get_link_args(self, **kwargs):
+ def get_link_args(self, language: T.Optional[str] = None, raw: bool = False) -> T.List[str]:
args = []
if self.libdir:
args += self.clib_compiler.get_linker_search_args(self.libdir)
diff -Nru meson-0.53.2/mesonbuild/dependencies/data/CMakeLists.txt meson-0.61.2/mesonbuild/dependencies/data/CMakeLists.txt
--- meson-0.53.2/mesonbuild/dependencies/data/CMakeLists.txt 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/data/CMakeLists.txt 2021-04-01 21:13:00.000000000 +0000
@@ -9,7 +9,11 @@
string(TOUPPER "${_packageName}" PACKAGE_NAME)
while(TRUE)
- find_package("${NAME}" QUIET)
+ if ("${VERSION}" STREQUAL "")
+ find_package("${NAME}" QUIET COMPONENTS ${COMPS})
+ else()
+ find_package("${NAME}" "${VERSION}" QUIET COMPONENTS ${COMPS})
+ endif()
# ARCHS has to be set via the CMD interface
if(${_packageName}_FOUND OR ${PACKAGE_NAME}_FOUND OR "${ARCHS}" STREQUAL "")
diff -Nru meson-0.53.2/mesonbuild/dependencies/detect.py meson-0.61.2/mesonbuild/dependencies/detect.py
--- meson-0.53.2/mesonbuild/dependencies/detect.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/detect.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,226 @@
+# 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 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):
+ for i in value:
+ assert isinstance(i, str)
+ value = tuple(frozenset(listify(value)))
+ else:
+ assert isinstance(value, (str, bool, int))
+ identifier = (*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 = 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(f'Dependency "{name}" not found' +
+ (f', tried {tried}' if tried else ''))
+
+ return NotFoundDependency(name, 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
diff -Nru meson-0.53.2/mesonbuild/dependencies/dev.py meson-0.61.2/mesonbuild/dependencies/dev.py
--- meson-0.53.2/mesonbuild/dependencies/dev.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/dev.py 2021-11-25 22:00:46.000000000 +0000
@@ -15,24 +15,30 @@
# This file contains the detection logic for external dependencies useful for
# development purposes, such as testing, debugging, etc..
-import functools
import glob
import os
import re
+import pathlib
+import shutil
+import typing as T
from .. import mesonlib, mlog
-from ..mesonlib import version_compare, stringlistify, extract_as_list, MachineChoice
+from ..compilers import AppleClangCCompiler, AppleClangCPPCompiler, detect_compiler_for
from ..environment import get_llvm_tool_names
-from .base import (
- DependencyException, DependencyMethods, ExternalDependency, PkgConfigDependency,
- strip_system_libdirs, ConfigToolDependency, CMakeDependency
-)
-from .misc import ThreadDependency
-
-import typing as T
+from ..mesonlib import version_compare, stringlistify, extract_as_list, MachineChoice
+from .base import DependencyException, DependencyMethods, strip_system_libdirs, SystemDependency
+from .cmake import CMakeDependency
+from .configtool import ConfigToolDependency
+from .factory import DependencyFactory
+from .misc import threads_factory
+from .pkgconfig import PkgConfigDependency
+
+if T.TYPE_CHECKING:
+ from ..envconfig import MachineInfo
+ from .. environment import Environment
-def get_shared_library_suffix(environment, for_machine: MachineChoice):
+def get_shared_library_suffix(environment: 'Environment', for_machine: MachineChoice) -> str:
"""This is only guaranteed to work for languages that compile to machine
code, not for languages like C# that use a bytecode and always end in .dll
"""
@@ -44,15 +50,17 @@
return '.so'
-class GTestDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('gtest', environment, 'cpp', kwargs)
+class GTestDependencySystem(SystemDependency):
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__(name, environment, kwargs, language='cpp')
self.main = kwargs.get('main', False)
self.src_dirs = ['/usr/src/gtest/src', '/usr/src/googletest/googletest/src']
+ if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+ self.is_found = False
+ return
self.detect()
- self._add_sub_dependency(ThreadDependency, environment, kwargs)
- def detect(self):
+ def detect(self) -> None:
gtest_detect = self.clib_compiler.find_library("gtest", self.env, [])
gtest_main_detect = self.clib_compiler.find_library("gtest_main", self.env, [])
if gtest_detect and (not self.main or gtest_main_detect):
@@ -75,7 +83,7 @@
else:
self.is_found = False
- def detect_srcdir(self):
+ def detect_srcdir(self) -> bool:
for s in self.src_dirs:
if os.path.exists(s):
self.src_dir = s
@@ -89,39 +97,32 @@
return True
return False
- def log_info(self):
+ def log_info(self) -> str:
if self.prebuilt:
return 'prebuilt'
else:
return 'building self'
- def log_tried(self):
+ def log_tried(self) -> str:
return 'system'
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- pcname = 'gtest_main' if kwargs.get('main', False) else 'gtest'
- candidates.append(functools.partial(PkgConfigDependency, pcname, environment, kwargs))
-
- if DependencyMethods.SYSTEM in methods:
- candidates.append(functools.partial(GTestDependency, environment, kwargs))
- return candidates
+class GTestDependencyPC(PkgConfigDependency):
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM]
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ assert name == 'gtest'
+ if kwargs.get('main'):
+ name = 'gtest_main'
+ super().__init__(name, environment, kwargs)
-class GMockDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('gmock', environment, 'cpp', kwargs)
+class GMockDependencySystem(SystemDependency):
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__(name, environment, kwargs, language='cpp')
self.main = kwargs.get('main', False)
- self._add_sub_dependency(ThreadDependency, environment, kwargs)
+ if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+ self.is_found = False
+ return
# If we are getting main() from GMock, we definitely
# want to avoid linking in main() from GTest
@@ -132,11 +133,10 @@
# GMock without GTest is pretty much useless
# this also mimics the structure given in WrapDB,
# where GMock always pulls in GTest
- gtest_dep = GTestDependency(environment, gtest_kwargs)
- if not gtest_dep.is_found:
+ found = self._add_sub_dependency(gtest_factory(environment, self.for_machine, gtest_kwargs))
+ if not found:
self.is_found = False
return
- self.ext_deps.append(gtest_dep)
# GMock may be a library or just source.
# Work with both.
@@ -168,32 +168,23 @@
self.is_found = False
- def log_info(self):
+ def log_info(self) -> str:
if self.prebuilt:
return 'prebuilt'
else:
return 'building self'
- def log_tried(self):
+ def log_tried(self) -> str:
return 'system'
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- pcname = 'gmock_main' if kwargs.get('main', False) else 'gmock'
- candidates.append(functools.partial(PkgConfigDependency, pcname, environment, kwargs))
- if DependencyMethods.SYSTEM in methods:
- candidates.append(functools.partial(GMockDependency, environment, kwargs))
+class GMockDependencyPC(PkgConfigDependency):
- return candidates
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM]
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ assert name == 'gmock'
+ if kwargs.get('main'):
+ name = 'gmock_main'
+ super().__init__(name, environment, kwargs)
class LLVMDependencyConfigTool(ConfigToolDependency):
@@ -204,7 +195,7 @@
tool_name = 'llvm-config'
__cpp_blacklist = {'-DNDEBUG'}
- def __init__(self, environment, kwargs):
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
self.tools = get_llvm_tool_names('llvm-config')
# Fedora starting with Fedora 30 adds a suffix of the number
@@ -218,13 +209,12 @@
# 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.
- super().__init__('LLVM', environment, 'cpp', kwargs)
- self.provided_modules = []
- self.required_modules = set()
- self.module_details = []
+ super().__init__(name, environment, kwargs, language='cpp')
+ self.provided_modules: T.List[str] = []
+ self.required_modules: mesonlib.OrderedSet[str] = mesonlib.OrderedSet()
+ self.module_details: T.List[str] = []
if not self.is_found:
return
- self.static = kwargs.get('static', False)
self.provided_modules = self.get_config_value(['--components'], 'modules')
modules = stringlistify(extract_as_list(kwargs, 'modules'))
@@ -232,7 +222,7 @@
opt_modules = stringlistify(extract_as_list(kwargs, 'optional_modules'))
self.check_components(opt_modules, required=False)
- cargs = set(self.get_config_value(['--cppflags'], 'compile_args'))
+ cargs = mesonlib.OrderedSet(self.get_config_value(['--cppflags'], 'compile_args'))
self.compile_args = list(cargs.difference(self.__cpp_blacklist))
if version_compare(self.version, '>= 3.9'):
@@ -241,9 +231,11 @@
self._set_old_link_args()
self.link_args = strip_system_libdirs(environment, self.for_machine, self.link_args)
self.link_args = self.__fix_bogus_link_args(self.link_args)
- self._add_sub_dependency(ThreadDependency, environment, kwargs)
+ if not self._add_sub_dependency(threads_factory(environment, self.for_machine, {})):
+ self.is_found = False
+ return
- def __fix_bogus_link_args(self, args):
+ def __fix_bogus_link_args(self, args: T.List[str]) -> T.List[str]:
"""This function attempts to fix bogus link arguments that llvm-config
generates.
@@ -254,19 +246,19 @@
"-L IBPATH:...", if we're using an msvc like compilers convert
that to "/LIBPATH", otherwise to "-L ..."
"""
- cpp = self.env.coredata.compilers[self.for_machine]['cpp']
new_args = []
for arg in args:
if arg.startswith('-l') and arg.endswith('.so'):
new_args.append(arg.lstrip('-l'))
elif arg.startswith('-LIBPATH:'):
+ cpp = self.env.coredata.compilers[self.for_machine]['cpp']
new_args.extend(cpp.get_linker_search_args(arg.lstrip('-LIBPATH:')))
else:
new_args.append(arg)
return new_args
- def __check_libfiles(self, shared):
+ def __check_libfiles(self, shared: bool) -> None:
"""Use llvm-config's --libfiles to check if libraries exist."""
mode = '--link-shared' if shared else '--link-static'
@@ -282,9 +274,15 @@
finally:
self.required = restore
- def _set_new_link_args(self, environment):
+ def _set_new_link_args(self, environment: 'Environment') -> None:
"""How to set linker args for LLVM versions >= 3.9"""
- mode = self.get_config_value(['--shared-mode'], 'link_args')[0]
+ try:
+ mode = self.get_config_value(['--shared-mode'], 'link_args')[0]
+ except IndexError:
+ mlog.debug('llvm-config --shared-mode returned an error')
+ self.is_found = False
+ return
+
if not self.static and mode == 'static':
# If llvm is configured with LLVM_BUILD_LLVM_DYLIB but not with
# LLVM_LINK_LLVM_DYLIB and not LLVM_BUILD_SHARED_LIBS (which
@@ -302,7 +300,7 @@
lib_ext = get_shared_library_suffix(environment, self.for_machine)
libdir = self.get_config_value(['--libdir'], 'link_args')[0]
# Sort for reproducibility
- matches = sorted(glob.iglob(os.path.join(libdir, 'libLLVM*{}'.format(lib_ext))))
+ matches = sorted(glob.iglob(os.path.join(libdir, f'libLLVM*{lib_ext}')))
if not matches:
if self.required:
raise
@@ -311,7 +309,7 @@
self.link_args = self.get_config_value(['--ldflags'], 'link_args')
libname = os.path.basename(matches[0]).rstrip(lib_ext).lstrip('lib')
- self.link_args.append('-l{}'.format(libname))
+ self.link_args.append(f'-l{libname}')
return
elif self.static and mode == 'shared':
# If, however LLVM_BUILD_SHARED_LIBS is true # (*cough* gentoo *cough*)
@@ -331,7 +329,7 @@
['--libs', '--ldflags'] + link_args + list(self.required_modules),
'link_args')
- def _set_old_link_args(self):
+ def _set_old_link_args(self) -> None:
"""Setting linker args for older versions of llvm.
Old versions of LLVM bring an extra level of insanity with them.
@@ -350,19 +348,19 @@
# called libLLVM-.(so|dylib|dll)
libdir = self.get_config_value(['--libdir'], 'link_args')[0]
- expected_name = 'libLLVM-{}'.format(self.version)
- re_name = re.compile(r'{}.(so|dll|dylib)$'.format(expected_name))
+ expected_name = f'libLLVM-{self.version}'
+ re_name = re.compile(fr'{expected_name}.(so|dll|dylib)$')
for file_ in os.listdir(libdir):
if re_name.match(file_):
- self.link_args = ['-L{}'.format(libdir),
+ self.link_args = [f'-L{libdir}',
'-l{}'.format(os.path.splitext(file_.lstrip('lib'))[0])]
break
else:
raise DependencyException(
'Could not find a dynamically linkable library for LLVM.')
- def check_components(self, modules, required=True):
+ def check_components(self, modules: T.List[str], required: bool = True) -> None:
"""Check for llvm components (modules in meson terms).
The required option is whether the module is required, not whether LLVM
@@ -376,7 +374,7 @@
self.is_found = False
if self.required:
raise DependencyException(
- 'Could not find required LLVM Component: {}'.format(mod))
+ f'Could not find required LLVM Component: {mod}')
status = '(missing)'
else:
status = '(missing but optional)'
@@ -385,23 +383,38 @@
self.module_details.append(mod + status)
- def log_details(self):
+ def log_details(self) -> str:
if self.module_details:
return 'modules: ' + ', '.join(self.module_details)
return ''
class LLVMDependencyCMake(CMakeDependency):
- def __init__(self, env, kwargs):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
self.llvm_modules = stringlistify(extract_as_list(kwargs, 'modules'))
self.llvm_opt_modules = stringlistify(extract_as_list(kwargs, 'optional_modules'))
- super().__init__(name='LLVM', environment=env, language='cpp', kwargs=kwargs)
+ super().__init__(name, env, kwargs, language='cpp')
+
+ # Cmake will always create a statically linked binary, so don't use
+ # cmake if dynamic is required
+ if not self.static:
+ self.is_found = False
+ mlog.warning('Ignoring LLVM CMake dependency because dynamic was requested')
+ return
+
+ if self.traceparser is None:
+ return
# Extract extra include directories and definitions
inc_dirs = self.traceparser.get_cmake_var('PACKAGE_INCLUDE_DIRS')
defs = self.traceparser.get_cmake_var('PACKAGE_DEFINITIONS')
+ # LLVM explicitly uses space-separated variables rather than semicolon lists
+ if len(defs) == 1:
+ defs = defs[0].split(' ')
temp = ['-I' + x for x in inc_dirs] + defs
self.compile_args += [x for x in temp if x not in self.compile_args]
- self._add_sub_dependency(ThreadDependency, env, kwargs)
+ if not self._add_sub_dependency(threads_factory(env, self.for_machine, {})):
+ self.is_found = False
+ return
def _main_cmake_file(self) -> str:
# Use a custom CMakeLists.txt for LLVM
@@ -410,13 +423,13 @@
def _extra_cmake_opts(self) -> T.List[str]:
return ['-DLLVM_MESON_MODULES={}'.format(';'.join(self.llvm_modules + self.llvm_opt_modules))]
- def _map_module_list(self, modules: T.List[T.Tuple[str, bool]]) -> T.List[T.Tuple[str, bool]]:
+ 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]]:
res = []
for mod, required in modules:
- cm_targets = self.traceparser.get_cmake_var('MESON_LLVM_TARGETS_{}'.format(mod))
+ cm_targets = self.traceparser.get_cmake_var(f'MESON_LLVM_TARGETS_{mod}')
if not cm_targets:
if required:
- raise self._gen_exception('LLVM module {} was not found'.format(mod))
+ raise self._gen_exception(f'LLVM module {mod} was not found')
else:
mlog.warning('Optional LLVM module', mlog.bold(mod), 'was not found')
continue
@@ -425,39 +438,140 @@
return res
def _original_module_name(self, module: str) -> str:
- orig_name = self.traceparser.get_cmake_var('MESON_TARGET_TO_LLVM_{}'.format(module))
+ orig_name = self.traceparser.get_cmake_var(f'MESON_TARGET_TO_LLVM_{module}')
if orig_name:
return orig_name[0]
return module
-class LLVMDependency(ExternalDependency):
- def __init__(self, env, kwargs):
- super().__init__('LLVM', env, 'cpp', kwargs)
-
- @classmethod
- def _factory(cls, env, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(LLVMDependencyConfigTool, env, kwargs))
-
- if DependencyMethods.CMAKE in methods:
- candidates.append(functools.partial(LLVMDependencyCMake, env, kwargs))
-
- return candidates
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.CMAKE, DependencyMethods.CONFIG_TOOL]
class ValgrindDependency(PkgConfigDependency):
'''
Consumers of Valgrind usually only need the compile args and do not want to
link to its (static) libraries.
'''
- def __init__(self, env, kwargs):
+ def __init__(self, env: 'Environment', kwargs: T.Dict[str, T.Any]):
super().__init__('valgrind', env, kwargs)
- def get_link_args(self, **kwargs):
+ def get_link_args(self, language: T.Optional[str] = None, raw: bool = False) -> T.List[str]:
return []
+
+
+class ZlibSystemDependency(SystemDependency):
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+
+ m = self.env.machines[self.for_machine]
+
+ # I'm not sure this is entirely correct. What if we're cross compiling
+ # from something to macOS?
+ if ((m.is_darwin() and isinstance(self.clib_compiler, (AppleClangCCompiler, AppleClangCPPCompiler))) or
+ m.is_freebsd() or m.is_dragonflybsd() or m.is_android()):
+ # No need to set includes,
+ # on macos xcode/clang will do that for us.
+ # on freebsd zlib.h is in /usr/include
+
+ self.is_found = True
+ self.link_args = ['-lz']
+ else:
+ # Without a clib_compiler we can't find zlib, so just give up.
+ if self.clib_compiler is None:
+ self.is_found = False
+ return
+
+ if self.clib_compiler.get_argument_syntax() == 'msvc':
+ libs = ['zlib1' 'zlib']
+ else:
+ libs = ['z']
+ for lib in libs:
+ l = self.clib_compiler.find_library(lib, environment, [])
+ h = self.clib_compiler.has_header('zlib.h', '', environment, dependencies=[self])
+ if l and h[0]:
+ self.is_found = True
+ self.link_args = l
+ break
+ else:
+ return
+
+ v, _ = self.clib_compiler.get_define('ZLIB_VERSION', '#include ', self.env, [], [self])
+ self.version = v.strip('"')
+
+
+class JDKSystemDependency(SystemDependency):
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__('jdk', environment, kwargs)
+
+ m = self.env.machines[self.for_machine]
+
+ if 'java' not in environment.coredata.compilers[self.for_machine]:
+ detect_compiler_for(environment, 'java', self.for_machine)
+ self.javac = environment.coredata.compilers[self.for_machine]['java']
+ self.version = self.javac.version
+
+ if 'version' in kwargs and not version_compare(self.version, kwargs['version']):
+ mlog.error(f'Incorrect JDK version found ({self.version}), wanted {kwargs["version"]}')
+ self.is_found = False
+ return
+
+ self.java_home = environment.properties[self.for_machine].get_java_home()
+ if not self.java_home:
+ self.java_home = pathlib.Path(shutil.which(self.javac.exelist[0])).resolve().parents[1]
+
+ platform_include_dir = self.__machine_info_to_platform_include_dir(m)
+ if platform_include_dir is None:
+ mlog.error("Could not find a JDK platform include directory for your OS, please open an issue or provide a pull request.")
+ self.is_found = False
+ return
+
+ java_home_include = self.java_home / 'include'
+ self.compile_args.append(f'-I{java_home_include}')
+ self.compile_args.append(f'-I{java_home_include / platform_include_dir}')
+ self.is_found = True
+
+ @staticmethod
+ def __machine_info_to_platform_include_dir(m: 'MachineInfo') -> T.Optional[str]:
+ """Translates the machine information to the platform-dependent include directory
+
+ When inspecting a JDK release tarball or $JAVA_HOME, inside the `include/` directory is a
+ platform dependent folder that must be on the target's include path in addition to the
+ parent `include/` directory.
+ """
+ if m.is_linux():
+ return 'linux'
+ elif m.is_windows():
+ return 'win32'
+ elif m.is_darwin():
+ return 'darwin'
+ elif m.is_sunos():
+ return 'solaris'
+
+ return None
+
+
+llvm_factory = DependencyFactory(
+ 'LLVM',
+ [DependencyMethods.CMAKE, DependencyMethods.CONFIG_TOOL],
+ cmake_class=LLVMDependencyCMake,
+ configtool_class=LLVMDependencyConfigTool,
+)
+
+gtest_factory = DependencyFactory(
+ 'gtest',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
+ pkgconfig_class=GTestDependencyPC,
+ system_class=GTestDependencySystem,
+)
+
+gmock_factory = DependencyFactory(
+ 'gmock',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
+ pkgconfig_class=GMockDependencyPC,
+ system_class=GMockDependencySystem,
+)
+
+zlib_factory = DependencyFactory(
+ 'zlib',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE, DependencyMethods.SYSTEM],
+ cmake_name='ZLIB',
+ system_class=ZlibSystemDependency,
+)
diff -Nru meson-0.53.2/mesonbuild/dependencies/dub.py meson-0.61.2/mesonbuild/dependencies/dub.py
--- meson-0.53.2/mesonbuild/dependencies/dub.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/dub.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,236 @@
+# 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 ExternalDependency, DependencyException, DependencyTypeName
+from .pkgconfig import PkgConfigDependency
+from ..mesonlib import Popen_safe
+from ..programs import ExternalProgram
+from ..compilers import DCompiler
+from .. import mlog
+import re
+import os
+import copy
+import json
+import platform
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
+class DubDependency(ExternalDependency):
+ class_dubbin = None
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(DependencyTypeName('dub'), environment, kwargs, language='d')
+ self.name = name
+ self.module_path: T.Optional[str] = None
+
+ _temp_comp = super().get_compiler()
+ assert isinstance(_temp_comp, DCompiler)
+ self.compiler = _temp_comp
+
+ if 'required' in kwargs:
+ self.required = kwargs.get('required')
+
+ if DubDependency.class_dubbin is None:
+ self.dubbin = self._check_dub()
+ DubDependency.class_dubbin = self.dubbin
+ else:
+ self.dubbin = DubDependency.class_dubbin
+
+ if not self.dubbin:
+ if self.required:
+ raise DependencyException('DUB not found.')
+ self.is_found = False
+ return
+
+ assert isinstance(self.dubbin, ExternalProgram)
+ mlog.debug('Determining dependency {!r} with DUB executable '
+ '{!r}'.format(name, self.dubbin.get_path()))
+
+ # we need to know the target architecture
+ arch = self.compiler.arch
+
+ # Ask dub for the package
+ ret, res = self._call_dubbin(['describe', name, '--arch=' + arch])
+
+ if ret != 0:
+ self.is_found = False
+ return
+
+ comp = self.compiler.get_id().replace('llvm', 'ldc').replace('gcc', 'gdc')
+ packages = []
+ description = json.loads(res)
+ for package in description['packages']:
+ packages.append(package['name'])
+ if package['name'] == name:
+ self.is_found = True
+
+ not_lib = True
+ if 'targetType' in package:
+ if package['targetType'] in ['library', 'sourceLibrary', 'staticLibrary', 'dynamicLibrary']:
+ not_lib = False
+
+ if not_lib:
+ mlog.error(mlog.bold(name), "found but it isn't a library")
+ self.is_found = False
+ return
+
+ self.module_path = self._find_right_lib_path(package['path'], comp, description, True, package['targetFileName'])
+ if not os.path.exists(self.module_path):
+ # check if the dependency was built for other archs
+ archs = [['x86_64'], ['x86'], ['x86', 'x86_mscoff']]
+ for a in archs:
+ description_a = copy.deepcopy(description)
+ description_a['architecture'] = a
+ arch_module_path = self._find_right_lib_path(package['path'], comp, description_a, True, package['targetFileName'])
+ if arch_module_path:
+ mlog.error(mlog.bold(name), "found but it wasn't compiled for", mlog.bold(arch))
+ self.is_found = False
+ return
+
+ mlog.error(mlog.bold(name), "found but it wasn't compiled with", mlog.bold(comp))
+ self.is_found = False
+ return
+
+ self.version = package['version']
+ self.pkg = package
+
+ if self.pkg['targetFileName'].endswith('.a'):
+ self.static = True
+
+ self.compile_args = []
+ for flag in self.pkg['dflags']:
+ self.link_args.append(flag)
+ for path in self.pkg['importPaths']:
+ self.compile_args.append('-I' + os.path.join(self.pkg['path'], path))
+
+ self.link_args = self.raw_link_args = []
+ for flag in self.pkg['lflags']:
+ self.link_args.append(flag)
+
+ self.link_args.append(os.path.join(self.module_path, self.pkg['targetFileName']))
+
+ # Handle dependencies
+ libs = []
+
+ def add_lib_args(field_name: str, target: T.Dict[str, T.Dict[str, str]]) -> None:
+ if field_name in target['buildSettings']:
+ for lib in target['buildSettings'][field_name]:
+ if lib not in libs:
+ libs.append(lib)
+ if os.name != 'nt':
+ pkgdep = PkgConfigDependency(lib, environment, {'required': 'true', 'silent': 'true'})
+ for arg in pkgdep.get_compile_args():
+ self.compile_args.append(arg)
+ for arg in pkgdep.get_link_args():
+ self.link_args.append(arg)
+ for arg in pkgdep.get_link_args(raw=True):
+ self.raw_link_args.append(arg)
+
+ for target in description['targets']:
+ if target['rootPackage'] in packages:
+ add_lib_args('libs', target)
+ add_lib_args(f'libs-{platform.machine()}', target)
+ for file in target['buildSettings']['linkerFiles']:
+ lib_path = self._find_right_lib_path(file, comp, description)
+ if lib_path:
+ self.link_args.append(lib_path)
+ else:
+ self.is_found = False
+
+ def _find_right_lib_path(self,
+ default_path: str,
+ comp: str,
+ description: T.Dict[str, str],
+ folder_only: bool = False,
+ file_name: str = '') -> T.Optional[str]:
+ module_path = lib_file_name = ''
+ if folder_only:
+ module_path = default_path
+ lib_file_name = file_name
+ else:
+ module_path = os.path.dirname(default_path)
+ lib_file_name = os.path.basename(default_path)
+ module_build_path = os.path.join(module_path, '.dub', 'build')
+
+ # If default_path is a path to lib file and
+ # directory of lib don't have subdir '.dub/build'
+ if not os.path.isdir(module_build_path) and os.path.isfile(default_path):
+ if folder_only:
+ return module_path
+ else:
+ return default_path
+
+ # Get D version implemented in the compiler
+ # gdc doesn't support this
+ ret, res = self._call_dubbin(['--version'])
+
+ if ret != 0:
+ mlog.error('Failed to run {!r}', mlog.bold(comp))
+ return None
+
+ d_ver_reg = re.search('v[0-9].[0-9][0-9][0-9].[0-9]', res) # Ex.: v2.081.2
+ if d_ver_reg is not None:
+ d_ver = d_ver_reg.group().rsplit('.', 1)[0].replace('v', '').replace('.', '') # Fix structure. Ex.: 2081
+ else:
+ d_ver = '' # gdc
+
+ if not os.path.isdir(module_build_path):
+ return ''
+
+ # Ex.: library-debug-linux.posix-x86_64-ldc_2081-EF934983A3319F8F8FF2F0E107A363BA
+ build_name = '-{}-{}-{}-{}_{}'.format(description['buildType'], '.'.join(description['platform']), '.'.join(description['architecture']), comp, d_ver)
+ for entry in os.listdir(module_build_path):
+ if build_name in entry:
+ for file in os.listdir(os.path.join(module_build_path, entry)):
+ if file == lib_file_name:
+ if folder_only:
+ return os.path.join(module_build_path, entry)
+ else:
+ return os.path.join(module_build_path, entry, lib_file_name)
+
+ return ''
+
+ def _call_dubbin(self, args: T.List[str], env: T.Optional[T.Dict[str, str]] = None) -> T.Tuple[int, str]:
+ assert isinstance(self.dubbin, ExternalProgram)
+ p, out = Popen_safe(self.dubbin.get_command() + args, env=env)[0:2]
+ return p.returncode, out.strip()
+
+ def _call_copmbin(self, args: T.List[str], env: T.Optional[T.Dict[str, str]] = None) -> T.Tuple[int, str]:
+ p, out = Popen_safe(self.compiler.get_exelist() + args, env=env)[0:2]
+ return p.returncode, out.strip()
+
+ def _check_dub(self) -> T.Union[bool, ExternalProgram]:
+ dubbin: T.Union[bool, ExternalProgram] = ExternalProgram('dub', silent=True)
+ assert isinstance(dubbin, ExternalProgram)
+ if dubbin.found():
+ try:
+ p, out = Popen_safe(dubbin.get_command() + ['--version'])[0:2]
+ if p.returncode != 0:
+ mlog.warning('Found dub {!r} but couldn\'t run it'
+ ''.format(' '.join(dubbin.get_command())))
+ # Set to False instead of None to signify that we've already
+ # searched for it and not found it
+ dubbin = False
+ except (FileNotFoundError, PermissionError):
+ dubbin = False
+ else:
+ dubbin = False
+ if isinstance(dubbin, ExternalProgram):
+ mlog.log('Found DUB:', mlog.bold(dubbin.get_path()),
+ '(%s)' % out.strip())
+ else:
+ mlog.log('Found DUB:', mlog.red('NO'))
+ return dubbin
diff -Nru meson-0.53.2/mesonbuild/dependencies/factory.py meson-0.61.2/mesonbuild/dependencies/factory.py
--- meson-0.53.2/mesonbuild/dependencies/factory.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/factory.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,151 @@
+# Copyright 2013-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# 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.
+
+import functools
+import typing as T
+
+from ..mesonlib import MachineChoice
+from .base import DependencyException, DependencyMethods
+from .base import ExternalDependency
+from .base import process_method_kw
+from .base import BuiltinDependency, SystemDependency
+from .cmake import CMakeDependency
+from .framework import ExtraFrameworkDependency
+from .pkgconfig import PkgConfigDependency
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+ from .configtool import ConfigToolDependency
+
+ DependencyGenerator = T.Callable[[], ExternalDependency]
+ FactoryFunc = T.Callable[
+ [
+ 'Environment',
+ MachineChoice,
+ T.Dict[str, T.Any],
+ T.List[DependencyMethods]
+ ],
+ T.List[DependencyGenerator]
+ ]
+
+ WrappedFactoryFunc = T.Callable[
+ [
+ 'Environment',
+ MachineChoice,
+ T.Dict[str, T.Any]
+ ],
+ T.List[DependencyGenerator]
+ ]
+
+class DependencyFactory:
+
+ """Factory to get dependencies from multiple sources.
+
+ This class provides an initializer that takes a set of names and classes
+ for various kinds of dependencies. When the initialized object is called
+ it returns a list of callables return Dependency objects to try in order.
+
+ :name: The name of the dependency. This will be passed as the name
+ parameter of the each dependency unless it is overridden on a per
+ type basis.
+ :methods: An ordered list of DependencyMethods. This is the order
+ dependencies will be returned in unless they are removed by the
+ _process_method function
+ :*_name: This will overwrite the name passed to the corresponding class.
+ For example, if the name is 'zlib', but cmake calls the dependency
+ 'Z', then using `cmake_name='Z'` will pass the name as 'Z' to cmake.
+ :*_class: A *type* or callable that creates a class, and has the
+ signature of an ExternalDependency
+ :system_class: If you pass DependencyMethods.SYSTEM in methods, you must
+ set this argument.
+ """
+
+ def __init__(self, name: str, methods: T.List[DependencyMethods], *,
+ extra_kwargs: T.Optional[T.Dict[str, T.Any]] = None,
+ pkgconfig_name: T.Optional[str] = None,
+ pkgconfig_class: 'T.Type[PkgConfigDependency]' = PkgConfigDependency,
+ cmake_name: T.Optional[str] = None,
+ cmake_class: 'T.Type[CMakeDependency]' = CMakeDependency,
+ configtool_class: 'T.Optional[T.Type[ConfigToolDependency]]' = None,
+ framework_name: T.Optional[str] = None,
+ framework_class: 'T.Type[ExtraFrameworkDependency]' = ExtraFrameworkDependency,
+ builtin_class: 'T.Type[BuiltinDependency]' = BuiltinDependency,
+ system_class: 'T.Type[SystemDependency]' = SystemDependency):
+
+ if DependencyMethods.CONFIG_TOOL in methods and not configtool_class:
+ raise DependencyException('A configtool must have a custom class')
+
+ self.extra_kwargs = extra_kwargs or {}
+ self.methods = methods
+ self.classes: T.Dict[
+ DependencyMethods,
+ T.Callable[['Environment', T.Dict[str, T.Any]], ExternalDependency]
+ ] = {
+ # Just attach the correct name right now, either the generic name
+ # or the method specific name.
+ DependencyMethods.EXTRAFRAMEWORK: lambda env, kwargs: framework_class(framework_name or name, env, kwargs),
+ DependencyMethods.PKGCONFIG: lambda env, kwargs: pkgconfig_class(pkgconfig_name or name, env, kwargs),
+ DependencyMethods.CMAKE: lambda env, kwargs: cmake_class(cmake_name or name, env, kwargs),
+ DependencyMethods.SYSTEM: lambda env, kwargs: system_class(name, env, kwargs),
+ DependencyMethods.BUILTIN: lambda env, kwargs: builtin_class(name, env, kwargs),
+ DependencyMethods.CONFIG_TOOL: None,
+ }
+ if configtool_class is not None:
+ self.classes[DependencyMethods.CONFIG_TOOL] = lambda env, kwargs: configtool_class(name, env, kwargs)
+
+ @staticmethod
+ def _process_method(method: DependencyMethods, env: 'Environment', for_machine: MachineChoice) -> bool:
+ """Report whether a method is valid or not.
+
+ If the method is valid, return true, otherwise return false. This is
+ used in a list comprehension to filter methods that are not possible.
+
+ By default this only remove EXTRAFRAMEWORK dependencies for non-mac platforms.
+ """
+ # Extra frameworks are only valid for macOS and other apple products
+ if (method is DependencyMethods.EXTRAFRAMEWORK and
+ not env.machines[for_machine].is_darwin()):
+ return False
+ return True
+
+ def __call__(self, env: 'Environment', for_machine: MachineChoice,
+ kwargs: T.Dict[str, T.Any]) -> T.List['DependencyGenerator']:
+ """Return a list of Dependencies with the arguments already attached."""
+ methods = process_method_kw(self.methods, kwargs)
+ nwargs = self.extra_kwargs.copy()
+ nwargs.update(kwargs)
+
+ return [functools.partial(self.classes[m], env, nwargs) for m in methods
+ if self._process_method(m, env, for_machine)]
+
+
+def factory_methods(methods: T.Set[DependencyMethods]) -> T.Callable[['FactoryFunc'], 'WrappedFactoryFunc']:
+ """Decorator for handling methods for dependency factory functions.
+
+ This helps to make factory functions self documenting
+ >>> @factory_methods([DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE])
+ >>> def factory(env: Environment, for_machine: MachineChoice, kwargs: T.Dict[str, T.Any], methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ >>> pass
+ """
+
+ def inner(func: 'FactoryFunc') -> 'WrappedFactoryFunc':
+
+ @functools.wraps(func)
+ def wrapped(env: 'Environment', for_machine: MachineChoice, kwargs: T.Dict[str, T.Any]) -> T.List['DependencyGenerator']:
+ return func(env, for_machine, kwargs, process_method_kw(methods, kwargs))
+
+ return wrapped
+
+ return inner
diff -Nru meson-0.53.2/mesonbuild/dependencies/framework.py meson-0.61.2/mesonbuild/dependencies/framework.py
--- meson-0.53.2/mesonbuild/dependencies/framework.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/framework.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,119 @@
+# 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 DependencyTypeName, ExternalDependency, DependencyException
+from ..mesonlib import MesonException, Version, stringlistify
+from .. import mlog
+from pathlib import Path
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
+class ExtraFrameworkDependency(ExternalDependency):
+ system_framework_paths: T.Optional[T.List[str]] = None
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None) -> None:
+ paths = stringlistify(kwargs.get('paths', []))
+ super().__init__(DependencyTypeName('extraframeworks'), env, kwargs, language=language)
+ self.name = name
+ # Full path to framework directory
+ self.framework_path: T.Optional[str] = None
+ if not self.clib_compiler:
+ raise DependencyException('No C-like compilers are available')
+ if self.system_framework_paths is None:
+ try:
+ self.system_framework_paths = self.clib_compiler.find_framework_paths(self.env)
+ except MesonException as e:
+ if 'non-clang' in str(e):
+ # Apple frameworks can only be found (and used) with the
+ # system compiler. It is not available so bail immediately.
+ self.is_found = False
+ return
+ raise
+ self.detect(name, paths)
+
+ def detect(self, name: str, paths: T.List[str]) -> None:
+ if not paths:
+ paths = self.system_framework_paths
+ for p in paths:
+ mlog.debug(f'Looking for framework {name} in {p}')
+ # We need to know the exact framework path because it's used by the
+ # Qt5 dependency class, and for setting the include path. We also
+ # want to avoid searching in an invalid framework path which wastes
+ # time and can cause a false positive.
+ framework_path = self._get_framework_path(p, name)
+ if framework_path is None:
+ continue
+ # We want to prefer the specified paths (in order) over the system
+ # paths since these are "extra" frameworks.
+ # For example, Python2's framework is in /System/Library/Frameworks and
+ # Python3's framework is in /Library/Frameworks, but both are called
+ # Python.framework. We need to know for sure that the framework was
+ # found in the path we expect.
+ allow_system = p in self.system_framework_paths
+ args = self.clib_compiler.find_framework(name, self.env, [p], allow_system)
+ if args is None:
+ continue
+ self.link_args = args
+ self.framework_path = framework_path.as_posix()
+ self.compile_args = ['-F' + self.framework_path]
+ # We need to also add -I includes to the framework because all
+ # cross-platform projects such as OpenGL, Python, Qt, GStreamer,
+ # etc do not use "framework includes":
+ # https://developer.apple.com/library/archive/documentation/MacOSX/Conceptual/BPFrameworks/Tasks/IncludingFrameworks.html
+ incdir = self._get_framework_include_path(framework_path)
+ if incdir:
+ self.compile_args += ['-I' + incdir]
+ self.is_found = True
+ return
+
+ def _get_framework_path(self, path: str, name: str) -> T.Optional[Path]:
+ p = Path(path)
+ lname = name.lower()
+ for d in p.glob('*.framework/'):
+ if lname == d.name.rsplit('.', 1)[0].lower():
+ return d
+ return None
+
+ def _get_framework_latest_version(self, path: Path) -> str:
+ versions = []
+ for each in path.glob('Versions/*'):
+ # macOS filesystems are usually case-insensitive
+ if each.name.lower() == 'current':
+ continue
+ versions.append(Version(each.name))
+ if len(versions) == 0:
+ # most system frameworks do not have a 'Versions' directory
+ return 'Headers'
+ return 'Versions/{}/Headers'.format(sorted(versions)[-1]._s)
+
+ def _get_framework_include_path(self, path: Path) -> T.Optional[str]:
+ # According to the spec, 'Headers' must always be a symlink to the
+ # Headers directory inside the currently-selected version of the
+ # framework, but sometimes frameworks are broken. Look in 'Versions'
+ # for the currently-selected version or pick the latest one.
+ trials = ('Headers', 'Versions/Current/Headers',
+ self._get_framework_latest_version(path))
+ for each in trials:
+ trial = path / each
+ if trial.is_dir():
+ return trial.as_posix()
+ return None
+
+ def log_info(self) -> str:
+ return self.framework_path or ''
+
+ def log_tried(self) -> str:
+ return 'framework'
diff -Nru meson-0.53.2/mesonbuild/dependencies/hdf5.py meson-0.61.2/mesonbuild/dependencies/hdf5.py
--- meson-0.53.2/mesonbuild/dependencies/hdf5.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/hdf5.py 2022-01-17 10:50:45.000000000 +0000
@@ -14,117 +14,166 @@
# This file contains the detection logic for miscellaneous external dependencies.
-import subprocess
+import functools
+import os
+import re
import shutil
+import subprocess
from pathlib import Path
-from .. import mlog
-from ..mesonlib import split_args, listify
-from .base import (DependencyException, DependencyMethods, ExternalDependency, ExternalProgram,
- PkgConfigDependency)
-
-class HDF5Dependency(ExternalDependency):
-
- def __init__(self, environment, kwargs):
- language = kwargs.get('language', 'c')
- super().__init__('hdf5', environment, language, kwargs)
- kwargs['required'] = False
- kwargs['silent'] = True
- self.is_found = False
- methods = listify(self.methods)
-
- if language not in ('c', 'cpp', 'fortran'):
- raise DependencyException('Language {} is not supported with HDF5.'.format(language))
-
- if set([DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]).intersection(methods):
- pkgconfig_files = ['hdf5', 'hdf5-serial']
- PCEXE = shutil.which('pkg-config')
- if PCEXE:
- # some distros put hdf5-1.2.3.pc with version number in .pc filename.
- ret = subprocess.run([PCEXE, '--list-all'], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
- universal_newlines=True)
- if ret.returncode == 0:
- for pkg in ret.stdout.split('\n'):
- if pkg.startswith(('hdf5')):
- pkgconfig_files.append(pkg.split(' ', 1)[0])
- pkgconfig_files = list(set(pkgconfig_files)) # dedupe
-
- for pkg in pkgconfig_files:
- pkgdep = PkgConfigDependency(pkg, environment, kwargs, language=self.language)
- if not pkgdep.found():
- continue
-
- self.compile_args = pkgdep.get_compile_args()
- # some broken pkgconfig don't actually list the full path to the needed includes
- newinc = []
- for arg in self.compile_args:
- if arg.startswith('-I'):
- stem = 'static' if kwargs.get('static', False) else 'shared'
- if (Path(arg[2:]) / stem).is_dir():
- newinc.append('-I' + str(Path(arg[2:]) / stem))
- self.compile_args += newinc
-
- # derive needed libraries by language
- pd_link_args = pkgdep.get_link_args()
- link_args = []
- for larg in pd_link_args:
- lpath = Path(larg)
- # some pkg-config hdf5.pc (e.g. Ubuntu) don't include the commonly-used HL HDF5 libraries,
- # so let's add them if they exist
- # additionally, some pkgconfig HDF5 HL files are malformed so let's be sure to find HL anyway
- if lpath.is_file():
- hl = []
- if language == 'cpp':
- hl += ['_hl_cpp', '_cpp']
- elif language == 'fortran':
- hl += ['_hl_fortran', 'hl_fortran', '_fortran']
- hl += ['_hl'] # C HL library, always needed
-
- suffix = '.' + lpath.name.split('.', 1)[1] # in case of .dll.a
- for h in hl:
- hlfn = lpath.parent / (lpath.name.split('.', 1)[0] + h + suffix)
- if hlfn.is_file():
- link_args.append(str(hlfn))
- # HDF5 C libs are required by other HDF5 languages
- link_args.append(larg)
- else:
- link_args.append(larg)
-
- self.link_args = link_args
- self.version = pkgdep.get_version()
- self.is_found = True
- self.pcdep = pkgdep
- return
-
- if DependencyMethods.AUTO in methods:
- wrappers = {'c': 'h5cc', 'cpp': 'h5c++', 'fortran': 'h5fc'}
- comp_args = []
- link_args = []
- # have to always do C as well as desired language
- for lang in set([language, 'c']):
- prog = ExternalProgram(wrappers[lang], silent=True)
- if not prog.found():
- return
- cmd = prog.get_command() + ['-show']
- p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=15)
- if p.returncode != 0:
- mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
- mlog.debug(mlog.bold('Standard output\n'), p.stdout)
- mlog.debug(mlog.bold('Standard error\n'), p.stderr)
- return
- args = split_args(p.stdout)
- for arg in args[1:]:
- if arg.startswith(('-I', '-f', '-D')) or arg == '-pthread':
- comp_args.append(arg)
- elif arg.startswith(('-L', '-l', '-Wl')):
- link_args.append(arg)
- elif Path(arg).is_file():
- link_args.append(arg)
- self.compile_args = comp_args
- self.link_args = link_args
- self.is_found = True
+from ..mesonlib import OrderedSet, join_args
+from .base import DependencyException, DependencyMethods
+from .configtool import ConfigToolDependency
+from .pkgconfig import PkgConfigDependency
+from .factory import factory_methods
+import typing as T
+
+if T.TYPE_CHECKING:
+ from .factory import DependencyGenerator
+ from ..environment import Environment
+ from ..mesonlib import MachineChoice
+
+
+class HDF5PkgConfigDependency(PkgConfigDependency):
+
+ """Handle brokenness in the HDF5 pkg-config files."""
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None) -> None:
+ language = language or 'c'
+ if language not in {'c', 'cpp', 'fortran'}:
+ raise DependencyException(f'Language {language} is not supported with HDF5.')
+
+ super().__init__(name, environment, kwargs, language)
+ if not self.is_found:
+ return
+
+ # some broken pkgconfig don't actually list the full path to the needed includes
+ newinc = [] # type: T.List[str]
+ for arg in self.compile_args:
+ if arg.startswith('-I'):
+ stem = 'static' if kwargs.get('static', False) else 'shared'
+ if (Path(arg[2:]) / stem).is_dir():
+ newinc.append('-I' + str(Path(arg[2:]) / stem))
+ self.compile_args += newinc
+
+ link_args = [] # type: T.List[str]
+ for larg in self.get_link_args():
+ lpath = Path(larg)
+ # some pkg-config hdf5.pc (e.g. Ubuntu) don't include the commonly-used HL HDF5 libraries,
+ # so let's add them if they exist
+ # additionally, some pkgconfig HDF5 HL files are malformed so let's be sure to find HL anyway
+ if lpath.is_file():
+ hl = []
+ if language == 'cpp':
+ hl += ['_hl_cpp', '_cpp']
+ elif language == 'fortran':
+ hl += ['_hl_fortran', 'hl_fortran', '_fortran']
+ hl += ['_hl'] # C HL library, always needed
+
+ suffix = '.' + lpath.name.split('.', 1)[1] # in case of .dll.a
+ for h in hl:
+ hlfn = lpath.parent / (lpath.name.split('.', 1)[0] + h + suffix)
+ if hlfn.is_file():
+ link_args.append(str(hlfn))
+ # HDF5 C libs are required by other HDF5 languages
+ link_args.append(larg)
+ else:
+ link_args.append(larg)
+
+ self.link_args = link_args
+
+
+class HDF5ConfigToolDependency(ConfigToolDependency):
+
+ """Wrapper around hdf5 binary config tools."""
+
+ version_arg = '-showconfig'
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None) -> None:
+ language = language or 'c'
+ if language not in {'c', 'cpp', 'fortran'}:
+ raise DependencyException(f'Language {language} is not supported with HDF5.')
+
+ if language == 'c':
+ cenv = 'CC'
+ tools = ['h5cc', 'h5pcc']
+ elif language == 'cpp':
+ cenv = 'CXX'
+ tools = ['h5c++', 'h5pc++']
+ elif language == 'fortran':
+ cenv = 'FC'
+ tools = ['h5fc', 'h5pfc']
+ else:
+ raise DependencyException('How did you get here?')
+
+ # We need this before we call super()
+ for_machine = self.get_for_machine_from_kwargs(kwargs)
+
+ nkwargs = kwargs.copy()
+ nkwargs['tools'] = tools
+
+ # Override the compiler that the config tools are going to use by
+ # setting the environment variables that they use for the compiler and
+ # linkers.
+ compiler = environment.coredata.compilers[for_machine][language]
+ try:
+ os.environ[f'HDF5_{cenv}'] = join_args(compiler.get_exelist())
+ os.environ[f'HDF5_{cenv}LINKER'] = join_args(compiler.get_linker_exelist())
+ super().__init__(name, environment, nkwargs, language)
+ finally:
+ del os.environ[f'HDF5_{cenv}']
+ del os.environ[f'HDF5_{cenv}LINKER']
+ if not self.is_found:
return
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]
+ # We first need to call the tool with -c to get the compile arguments
+ # and then without -c to get the link arguments.
+ args = self.get_config_value(['-show', '-c'], 'args')[1:]
+ args += self.get_config_value(['-show', '-noshlib' if kwargs.get('static', False) else '-shlib'], 'args')[1:]
+ for arg in args:
+ if arg.startswith(('-I', '-f', '-D')) or arg == '-pthread':
+ self.compile_args.append(arg)
+ elif arg.startswith(('-L', '-l', '-Wl')):
+ self.link_args.append(arg)
+ elif Path(arg).is_file():
+ self.link_args.append(arg)
+
+ # If the language is not C we need to add C as a subdependency
+ if language != 'c':
+ nkwargs = kwargs.copy()
+ nkwargs['language'] = 'c'
+ # I'm being too clever for mypy and pylint
+ self.is_found = self._add_sub_dependency(hdf5_factory(environment, for_machine, nkwargs)) # pylint: disable=no-value-for-parameter
+
+ def _sanitize_version(self, ver: str) -> str:
+ v = re.search(r'\s*HDF5 Version: (\d+\.\d+\.\d+)', ver)
+ return v.group(1)
+
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL})
+def hdf5_factory(env: 'Environment', for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any], methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ language = kwargs.get('language')
+ candidates: T.List['DependencyGenerator'] = []
+
+ if DependencyMethods.PKGCONFIG in methods:
+ # Use an ordered set so that these remain the first tried pkg-config files
+ pkgconfig_files = OrderedSet(['hdf5', 'hdf5-serial'])
+ # FIXME: This won't honor pkg-config paths, and cross-native files
+ PCEXE = shutil.which('pkg-config')
+ if PCEXE:
+ # some distros put hdf5-1.2.3.pc with version number in .pc filename.
+ ret = subprocess.run([PCEXE, '--list-all'], stdout=subprocess.PIPE, stderr=subprocess.DEVNULL,
+ universal_newlines=True)
+ if ret.returncode == 0:
+ for pkg in ret.stdout.split('\n'):
+ if pkg.startswith('hdf5'):
+ pkgconfig_files.add(pkg.split(' ', 1)[0])
+
+ for pkg in pkgconfig_files:
+ candidates.append(functools.partial(HDF5PkgConfigDependency, pkg, env, kwargs, language))
+
+ if DependencyMethods.CONFIG_TOOL in methods:
+ candidates.append(functools.partial(HDF5ConfigToolDependency, 'hdf5', env, kwargs, language))
+
+ return candidates
diff -Nru meson-0.53.2/mesonbuild/dependencies/__init__.py meson-0.61.2/mesonbuild/dependencies/__init__.py
--- meson-0.53.2/mesonbuild/dependencies/__init__.py 2020-01-23 22:29:05.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/__init__.py 2021-11-02 19:58:07.000000000 +0000
@@ -14,60 +14,259 @@
from .boost import BoostDependency
from .cuda import CudaDependency
-from .hdf5 import HDF5Dependency
-from .base import ( # noqa: F401
- Dependency, DependencyException, DependencyMethods, ExternalProgram, EmptyExternalProgram, NonExistingExternalProgram,
- ExternalDependency, NotFoundDependency, ExternalLibrary, ExtraFrameworkDependency, InternalDependency,
- PkgConfigDependency, CMakeDependency, find_external_dependency, get_dep_identifier, packages, _packages_accept_language)
-from .dev import GMockDependency, GTestDependency, LLVMDependency, ValgrindDependency
-from .coarrays import CoarrayDependency
-from .mpi import MPIDependency
-from .scalapack import ScalapackDependency
-from .misc import (BlocksDependency, NetCDFDependency, OpenMPDependency, Python3Dependency, ThreadDependency, PcapDependency, CupsDependency, LibWmfDependency, LibGCryptDependency, GpgmeDependency, ShadercDependency)
+from .hdf5 import hdf5_factory
+from .base import Dependency, InternalDependency, ExternalDependency, NotFoundDependency
+from .base import (
+ ExternalLibrary, DependencyException, DependencyMethods,
+ BuiltinDependency, SystemDependency)
+from .cmake import CMakeDependency
+from .configtool import ConfigToolDependency
+from .dub import DubDependency
+from .framework import ExtraFrameworkDependency
+from .pkgconfig import PkgConfigDependency
+from .factory import DependencyFactory
+from .detect import find_external_dependency, get_dep_identifier, packages, _packages_accept_language
+from .dev import (
+ ValgrindDependency, JDKSystemDependency, gmock_factory, gtest_factory,
+ llvm_factory, zlib_factory)
+from .coarrays import coarray_factory
+from .mpi import mpi_factory
+from .scalapack import scalapack_factory
+from .misc import (
+ BlocksDependency, OpenMPDependency, cups_factory, curses_factory, gpgme_factory,
+ libgcrypt_factory, libwmf_factory, netcdf_factory, pcap_factory, python3_factory,
+ shaderc_factory, threads_factory, ThreadDependency, iconv_factory, intl_factory,
+)
from .platform import AppleFrameworks
-from .ui import GLDependency, GnuStepDependency, Qt4Dependency, Qt5Dependency, SDL2Dependency, WxDependency, VulkanDependency
+from .qt import qt4_factory, qt5_factory, qt6_factory
+from .ui import GnuStepDependency, WxDependency, gl_factory, sdl2_factory, vulkan_factory
+__all__ = [
+ 'Dependency',
+ 'InternalDependency',
+ 'ExternalDependency',
+ 'SystemDependency',
+ 'BuiltinDependency',
+ 'NotFoundDependency',
+ 'ExternalLibrary',
+ 'DependencyException',
+ 'DependencyMethods',
+ 'CMakeDependency',
+ 'ConfigToolDependency',
+ 'DubDependency',
+ 'ExtraFrameworkDependency',
+ 'PkgConfigDependency',
+
+ 'DependencyFactory',
+
+ 'ThreadDependency',
+
+ 'find_external_dependency',
+ 'get_dep_identifier',
+]
+
+"""Dependency representations and discovery logic.
+
+Meson attempts to largely abstract away dependency discovery information, and
+to encapsulate that logic itself so that the DSL doesn't have too much direct
+information. There are some cases where this is impossible/undesirable, such
+as the `get_variable()` method.
+
+Meson has four primary dependency types:
+ 1. pkg-config
+ 2. apple frameworks
+ 3. CMake
+ 4. system
+
+Plus a few more niche ones.
+
+When a user calls `dependency('foo')` Meson creates a list of candidates, and
+tries those candidates in order to find one that matches the criteria
+provided by the user (such as version requirements, or optional components
+that are required.)
+
+Except to work around bugs or handle odd corner cases, pkg-config and CMake
+generally just workâ„¢, though there are exceptions. Most of this package is
+concerned with dependencies that don't (always) provide CMake and/or
+pkg-config files.
+
+For these cases one needs to write a `system` dependency. These dependencies
+descend directly from `ExternalDependency`, in their constructor they
+manually set up the necessary link and compile args (and additional
+dependencies as necessary).
+
+For example, imagine a dependency called Foo, it uses an environment variable
+called `$FOO_ROOT` to point to its install root, which looks like this:
+```txt
+$FOOROOT
+→ include/
+→ lib/
+```
+To use Foo, you need its include directory, and you need to link to
+`lib/libfoo.ext`.
+
+You could write code that looks like:
+
+```python
+class FooSystemDependency(ExternalDependency):
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ root = os.environ.get('FOO_ROOT')
+ if root is None:
+ mlog.debug('$FOO_ROOT is unset.')
+ self.is_found = False
+ return
+
+ lib = self.clib_compiler.find_library('foo', environment, [os.path.join(root, 'lib')])
+ if lib is None:
+ mlog.debug('Could not find lib.')
+ self.is_found = False
+ return
+
+ self.compile_args.append(f'-I{os.path.join(root, "include")}')
+ self.link_args.append(lib)
+ self.is_found = True
+```
+
+This code will look for `FOO_ROOT` in the environment, handle `FOO_ROOT` being
+undefined gracefully, then set its `compile_args` and `link_args` gracefully.
+It will also gracefully handle not finding the required lib (hopefully that
+doesn't happen, but it could if, for example, the lib is only static and
+shared linking is requested).
+
+There are a couple of things about this that still aren't ideal. For one, we
+don't want to be reading random environment variables at this point. Those
+should actually be added to `envconfig.Properties` and read in
+`environment.Environment._set_default_properties_from_env` (see how
+`BOOST_ROOT` is handled). We can also handle the `static` keyword. So
+now that becomes:
+
+```python
+class FooSystemDependency(ExternalDependency):
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ root = environment.properties[self.for_machine].foo_root
+ if root is None:
+ mlog.debug('foo_root is unset.')
+ self.is_found = False
+ return
+
+ static = Mesonlib.LibType.STATIC if kwargs.get('static', False) else Mesonlib.LibType.SHARED
+ lib = self.clib_compiler.find_library(
+ 'foo', environment, [os.path.join(root, 'lib')], libtype=static)
+ if lib is None:
+ mlog.debug('Could not find lib.')
+ self.is_found = False
+ return
+
+ self.compile_args.append(f'-I{os.path.join(root, "include")}')
+ self.link_args.append(lib)
+ self.is_found = True
+```
+
+This is nicer in a couple of ways. First we can properly cross compile as we
+are allowed to set `FOO_ROOT` for both the build and host machines, it also
+means that users can override this in their machine files, and if that
+environment variables changes during a Meson reconfigure Meson won't re-read
+it, this is important for reproducibility. Finally, Meson will figure out
+whether it should be finding `libfoo.so` or `libfoo.a` (or the platform
+specific names). Things are looking pretty good now, so it can be added to
+the `packages` dict below:
+
+```python
+packages.update({
+ 'foo': FooSystemDependency,
+})
+```
+
+Now, what if foo also provides pkg-config, but it's only shipped on Unices,
+or only included in very recent versions of the dependency? We can use the
+`DependencyFactory` class:
+
+```python
+foo_factory = DependencyFactory(
+ 'foo',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
+ system_class=FooSystemDependency,
+)
+```
+
+This is a helper function that will generate a default pkg-config based
+dependency, and use the `FooSystemDependency` as well. It can also handle
+custom finders for pkg-config and cmake based dependencies that need some
+extra help. You would then add the `foo_factory` to packages instead of
+`FooSystemDependency`:
+
+```python
+packages.update({
+ 'foo': foo_factory,
+})
+```
+
+If you have a dependency that is very complicated, (such as having multiple
+implementations) you may need to write your own factory function. There are a
+number of examples in this package.
+
+_Note_ before we moved to factory functions it was common to use an
+`ExternalDependency` class that would instantiate different types of
+dependencies and hold the one it found. There are a number of drawbacks to
+this approach, and no new dependencies should do this.
+"""
+
+# This is a dict where the keys should be strings, and the values must be one
+# of:
+# - An ExternalDependency subclass
+# - A DependencyFactory object
+# - A callable with a signature of (Environment, MachineChoice, Dict[str, Any]) -> List[Callable[[], ExternalDependency]]
packages.update({
# From dev:
- 'gtest': GTestDependency,
- 'gmock': GMockDependency,
- 'llvm': LLVMDependency,
+ 'gtest': gtest_factory,
+ 'gmock': gmock_factory,
+ 'llvm': llvm_factory,
'valgrind': ValgrindDependency,
+ 'zlib': zlib_factory,
+ 'jdk': JDKSystemDependency,
'boost': BoostDependency,
'cuda': CudaDependency,
# per-file
- 'coarray': CoarrayDependency,
- 'hdf5': HDF5Dependency,
- 'mpi': MPIDependency,
- 'scalapack': ScalapackDependency,
+ 'coarray': coarray_factory,
+ 'hdf5': hdf5_factory,
+ 'mpi': mpi_factory,
+ 'scalapack': scalapack_factory,
# From misc:
'blocks': BlocksDependency,
- 'netcdf': NetCDFDependency,
+ 'curses': curses_factory,
+ 'netcdf': netcdf_factory,
'openmp': OpenMPDependency,
- 'python3': Python3Dependency,
- 'threads': ThreadDependency,
- 'pcap': PcapDependency,
- 'cups': CupsDependency,
- 'libwmf': LibWmfDependency,
- 'libgcrypt': LibGCryptDependency,
- 'gpgme': GpgmeDependency,
- 'shaderc': ShadercDependency,
+ 'python3': python3_factory,
+ 'threads': threads_factory,
+ 'pcap': pcap_factory,
+ 'cups': cups_factory,
+ 'libwmf': libwmf_factory,
+ 'libgcrypt': libgcrypt_factory,
+ 'gpgme': gpgme_factory,
+ 'shaderc': shaderc_factory,
+ 'iconv': iconv_factory,
+ 'intl': intl_factory,
# From platform:
'appleframeworks': AppleFrameworks,
# From ui:
- 'gl': GLDependency,
+ 'gl': gl_factory,
'gnustep': GnuStepDependency,
- 'qt4': Qt4Dependency,
- 'qt5': Qt5Dependency,
- 'sdl2': SDL2Dependency,
+ 'qt4': qt4_factory,
+ 'qt5': qt5_factory,
+ 'qt6': qt6_factory,
+ 'sdl2': sdl2_factory,
'wxwidgets': WxDependency,
- 'vulkan': VulkanDependency,
+ 'vulkan': vulkan_factory,
})
_packages_accept_language.update({
'hdf5',
diff -Nru meson-0.53.2/mesonbuild/dependencies/misc.py meson-0.61.2/mesonbuild/dependencies/misc.py
--- meson-0.53.2/mesonbuild/dependencies/misc.py 2020-01-23 22:29:05.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/misc.py 2021-12-26 16:24:25.000000000 +0000
@@ -18,67 +18,49 @@
import functools
import re
import sysconfig
+import typing as T
-from .. import mlog
from .. import mesonlib
+from .. import mlog
from ..environment import detect_cpu_family
-from ..mesonlib import listify
-
-from .base import (
- DependencyException, DependencyMethods, ExternalDependency,
- ExtraFrameworkDependency, PkgConfigDependency,
- CMakeDependency, ConfigToolDependency,
-)
-
-
-class NetCDFDependency(ExternalDependency):
-
- def __init__(self, environment, kwargs):
- language = kwargs.get('language', 'c')
- super().__init__('netcdf', environment, language, kwargs)
- kwargs['required'] = False
- kwargs['silent'] = True
- self.is_found = False
- methods = listify(self.methods)
-
- if language not in ('c', 'cpp', 'fortran'):
- raise DependencyException('Language {} is not supported with NetCDF.'.format(language))
+from .base import DependencyException, DependencyMethods
+from .base import BuiltinDependency, SystemDependency
+from .cmake import CMakeDependency
+from .configtool import ConfigToolDependency
+from .factory import DependencyFactory, factory_methods
+from .pkgconfig import PkgConfigDependency
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment, MachineChoice
+ from .factory import DependencyGenerator
+
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE})
+def netcdf_factory(env: 'Environment',
+ for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any],
+ methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ language = kwargs.get('language', 'c')
+ if language not in ('c', 'cpp', 'fortran'):
+ raise DependencyException(f'Language {language} is not supported with NetCDF.')
+
+ candidates: T.List['DependencyGenerator'] = []
+
+ if DependencyMethods.PKGCONFIG in methods:
+ if language == 'fortran':
+ pkg = 'netcdf-fortran'
+ else:
+ pkg = 'netcdf'
- if set([DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]).intersection(methods):
- pkgconfig_files = ['netcdf']
+ candidates.append(functools.partial(PkgConfigDependency, pkg, env, kwargs, language=language))
- if language == 'fortran':
- pkgconfig_files.append('netcdf-fortran')
+ if DependencyMethods.CMAKE in methods:
+ candidates.append(functools.partial(CMakeDependency, 'NetCDF', env, kwargs, language=language))
- self.compile_args = []
- self.link_args = []
- self.pcdep = []
- for pkg in pkgconfig_files:
- pkgdep = PkgConfigDependency(pkg, environment, kwargs, language=self.language)
- if pkgdep.found():
- self.compile_args.extend(pkgdep.get_compile_args())
- self.link_args.extend(pkgdep.get_link_args())
- self.version = pkgdep.get_version()
- self.is_found = True
- self.pcdep.append(pkgdep)
- if self.is_found:
- return
+ return candidates
- if set([DependencyMethods.AUTO, DependencyMethods.CMAKE]).intersection(methods):
- cmakedep = CMakeDependency('NetCDF', environment, kwargs, language=self.language)
- if cmakedep.found():
- self.compile_args = cmakedep.get_compile_args()
- self.link_args = cmakedep.get_link_args()
- self.version = cmakedep.get_version()
- self.is_found = True
- return
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE]
-
-
-class OpenMPDependency(ExternalDependency):
+class OpenMPDependency(SystemDependency):
# Map date of specification release (which is the macro value) to a version.
VERSIONS = {
'201811': '5.0',
@@ -92,10 +74,16 @@
'199810': '1.0',
}
- def __init__(self, environment, kwargs):
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
language = kwargs.get('language')
- super().__init__('openmp', environment, language, kwargs)
+ super().__init__('openmp', environment, kwargs, language=language)
self.is_found = False
+ if self.clib_compiler.get_id() == 'nagfor':
+ # No macro defined for OpenMP, but OpenMP 3.1 is supported.
+ self.version = '3.1'
+ self.is_found = True
+ self.compile_args = self.link_args = self.clib_compiler.openmp_flags()
+ return
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.
self.version = '3.1'
@@ -111,55 +99,42 @@
openmp_date = None
if openmp_date:
- self.version = self.VERSIONS[openmp_date]
+ try:
+ self.version = self.VERSIONS[openmp_date]
+ except KeyError:
+ mlog.debug(f'Could not find an OpenMP version matching {openmp_date}')
+ if openmp_date == '_OPENMP':
+ mlog.debug('This can be caused by flags such as gcc\'s `-fdirectives-only`, which affect preprocessor behavior.')
+ return
# Flang has omp_lib.h
header_names = ('omp.h', 'omp_lib.h')
for name in header_names:
if self.clib_compiler.has_header(name, '', self.env, dependencies=[self], disable_cache=True)[0]:
self.is_found = True
- self.compile_args = self.link_args = self.clib_compiler.openmp_flags()
+ self.compile_args = self.clib_compiler.openmp_flags()
+ self.link_args = self.clib_compiler.openmp_link_flags()
break
if not self.is_found:
mlog.log(mlog.yellow('WARNING:'), 'OpenMP found but omp.h missing.')
-class ThreadDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('threads', environment, None, kwargs)
- self.name = 'threads'
- self.is_found = False
- methods = listify(self.methods)
- if DependencyMethods.AUTO in methods:
- self.is_found = True
- # Happens if you are using a language with threads
- # concept without C, such as plain Cuda.
- if self.clib_compiler is None:
- self.compile_args = []
- self.link_args = []
- else:
- self.compile_args = self.clib_compiler.thread_flags(environment)
- self.link_args = self.clib_compiler.thread_link_flags(environment)
- return
-
- if DependencyMethods.CMAKE in methods:
- # for unit tests and for those who simply want
- # dependency('threads', method: 'cmake')
- cmakedep = CMakeDependency('Threads', environment, kwargs)
- if cmakedep.found():
- self.compile_args = cmakedep.get_compile_args()
- self.link_args = cmakedep.get_link_args()
- self.version = cmakedep.get_version()
- self.is_found = True
- return
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.CMAKE]
+class ThreadDependency(SystemDependency):
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__(name, environment, kwargs)
+ self.is_found = True
+ # Happens if you are using a language with threads
+ # concept without C, such as plain Cuda.
+ if self.clib_compiler is None:
+ self.compile_args = []
+ self.link_args = []
+ else:
+ self.compile_args = self.clib_compiler.thread_flags(environment)
+ self.link_args = self.clib_compiler.thread_link_flags(environment)
-class BlocksDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('blocks', environment, None, kwargs)
+class BlocksDependency(SystemDependency):
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__('blocks', environment, kwargs)
self.name = 'blocks'
self.is_found = False
@@ -190,12 +165,14 @@
self.is_found = True
-class Python3Dependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('python3', environment, None, kwargs)
+class Python3DependencySystem(SystemDependency):
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__(name, environment, kwargs)
if not environment.machines.matches_build_machine(self.for_machine):
return
+ if not environment.machines[self.for_machine].is_windows():
+ return
self.name = 'python3'
self.static = kwargs.get('static', False)
@@ -203,30 +180,8 @@
self.version = '3'
self._find_libpy3_windows(environment)
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'python3', environment, kwargs))
-
- if DependencyMethods.SYSCONFIG in methods:
- candidates.append(functools.partial(Python3Dependency, environment, kwargs))
-
- if DependencyMethods.EXTRAFRAMEWORK in methods:
- # In OSX the Python 3 framework does not have a version
- # 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(
- ExtraFrameworkDependency, 'Python', False, ['/Library/Frameworks'],
- environment, kwargs.get('language', None), kwargs))
-
- return candidates
-
@staticmethod
- def get_windows_python_arch():
+ def get_windows_python_arch() -> T.Optional[str]:
pyplat = sysconfig.get_platform()
if pyplat == 'mingw':
pycc = sysconfig.get_config_var('CC')
@@ -235,28 +190,27 @@
elif pycc.startswith(('i686', 'i386')):
return '32'
else:
- mlog.log('MinGW Python built with unknown CC {!r}, please file'
- 'a bug'.format(pycc))
+ mlog.log(f'MinGW Python built with unknown CC {pycc!r}, please file a bug')
return None
elif pyplat == 'win32':
return '32'
elif pyplat in ('win64', 'win-amd64'):
return '64'
- mlog.log('Unknown Windows Python platform {!r}'.format(pyplat))
+ mlog.log(f'Unknown Windows Python platform {pyplat!r}')
return None
- def get_windows_link_args(self):
+ def get_windows_link_args(self) -> T.Optional[T.List[str]]:
pyplat = sysconfig.get_platform()
if pyplat.startswith('win'):
vernum = sysconfig.get_config_var('py_version_nodot')
if self.static:
- libpath = Path('libs') / 'libpython{}.a'.format(vernum)
+ libpath = Path('libs') / f'libpython{vernum}.a'
else:
comp = self.get_compiler()
if comp.id == "gcc":
- libpath = 'python{}.dll'.format(vernum)
+ libpath = Path(f'python{vernum}.dll')
else:
- libpath = Path('libs') / 'python{}.lib'.format(vernum)
+ libpath = Path('libs') / f'python{vernum}.lib'
lib = Path(sysconfig.get_config_var('base')) / libpath
elif pyplat == 'mingw':
if self.static:
@@ -269,7 +223,7 @@
return None
return [str(lib)]
- def _find_libpy3_windows(self, env):
+ def _find_libpy3_windows(self, env: 'Environment') -> None:
'''
Find python3 libraries on Windows and also verify that the arch matches
what we are building for.
@@ -285,7 +239,7 @@
arch = '64'
else:
# We can't cross-compile Python 3 dependencies on Windows yet
- mlog.log('Unknown architecture {!r} for'.format(arch),
+ mlog.log(f'Unknown architecture {arch!r} for',
mlog.bold(self.name))
self.is_found = False
return
@@ -310,250 +264,354 @@
self.version = sysconfig.get_config_var('py_version')
self.is_found = True
- @staticmethod
- def get_methods():
- if mesonlib.is_windows():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSCONFIG]
- elif mesonlib.is_osx():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.EXTRAFRAMEWORK]
- else:
- return [DependencyMethods.PKGCONFIG]
-
- def log_tried(self):
+ def log_tried(self) -> str:
return 'sysconfig'
-class PcapDependency(ExternalDependency):
+class PcapDependencyConfigTool(ConfigToolDependency):
- def __init__(self, environment, kwargs):
- super().__init__('pcap', environment, None, kwargs)
+ tools = ['pcap-config']
+ tool_name = 'pcap-config'
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'pcap', environment, kwargs))
-
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(ConfigToolDependency.factory,
- 'pcap', environment, None,
- kwargs, ['pcap-config'],
- 'pcap-config',
- PcapDependency.tool_finish_init))
-
- return candidates
-
- @staticmethod
- def tool_finish_init(ctdep):
- ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
- ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
- ctdep.version = PcapDependency.get_pcap_lib_version(ctdep)
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ if not self.is_found:
+ return
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--libs'], 'link_args')
+ self.version = self.get_pcap_lib_version()
- @staticmethod
- def get_pcap_lib_version(ctdep):
+ def get_pcap_lib_version(self) -> T.Optional[str]:
# Since we seem to need to run a program to discover the pcap version,
# we can't do that when cross-compiling
- if not ctdep.env.machines.matches_build_machine(ctdep.for_machine):
+ # FIXME: this should be handled if we have an exe_wrapper
+ if not self.env.machines.matches_build_machine(self.for_machine):
return None
- v = ctdep.clib_compiler.get_return_value('pcap_lib_version', 'string',
- '#include ', ctdep.env, [], [ctdep])
- v = re.sub(r'libpcap version ', '', v)
+ v = self.clib_compiler.get_return_value('pcap_lib_version', 'string',
+ '#include ', self.env, [], [self])
+ v = re.sub(r'libpcap version ', '', str(v))
v = re.sub(r' -- Apple version.*$', '', v)
return v
-class CupsDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('cups', environment, None, kwargs)
-
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
+class CupsDependencyConfigTool(ConfigToolDependency):
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'cups', environment, kwargs))
+ tools = ['cups-config']
+ tool_name = 'cups-config'
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(ConfigToolDependency.factory,
- 'cups', environment, None,
- kwargs, ['cups-config'],
- 'cups-config', CupsDependency.tool_finish_init))
-
- if DependencyMethods.EXTRAFRAMEWORK in methods:
- if mesonlib.is_osx():
- candidates.append(functools.partial(
- ExtraFrameworkDependency, 'cups', False, None, environment,
- kwargs.get('language', None), kwargs))
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ if not self.is_found:
+ return
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--ldflags', '--libs'], 'link_args')
- if DependencyMethods.CMAKE in methods:
- candidates.append(functools.partial(CMakeDependency, 'Cups', environment, kwargs))
- return candidates
+class LibWmfDependencyConfigTool(ConfigToolDependency):
- @staticmethod
- def tool_finish_init(ctdep):
- ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
- ctdep.link_args = ctdep.get_config_value(['--ldflags', '--libs'], 'link_args')
+ tools = ['libwmf-config']
+ tool_name = 'libwmf-config'
- @staticmethod
- def get_methods():
- if mesonlib.is_osx():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK, DependencyMethods.CMAKE]
- else:
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.CMAKE]
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ if not self.is_found:
+ return
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--libs'], 'link_args')
-class LibWmfDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('libwmf', environment, None, kwargs)
+class LibGCryptDependencyConfigTool(ConfigToolDependency):
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
+ tools = ['libgcrypt-config']
+ tool_name = 'libgcrypt-config'
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'libwmf', environment, kwargs))
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ if not self.is_found:
+ return
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--libs'], 'link_args')
+ self.version = self.get_config_value(['--version'], 'version')[0]
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(ConfigToolDependency.factory,
- 'libwmf', environment, None, kwargs, ['libwmf-config'], 'libwmf-config', LibWmfDependency.tool_finish_init))
- return candidates
+class GpgmeDependencyConfigTool(ConfigToolDependency):
- @staticmethod
- def tool_finish_init(ctdep):
- ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
- ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
+ tools = ['gpgme-config']
+ tool_name = 'gpg-config'
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ if not self.is_found:
+ return
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--libs'], 'link_args')
+ self.version = self.get_config_value(['--version'], 'version')[0]
-class LibGCryptDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('libgcrypt', environment, None, kwargs)
+class ShadercDependency(SystemDependency):
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__('shaderc', environment, kwargs)
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'libgcrypt', environment, kwargs))
+ static_lib = 'shaderc_combined'
+ shared_lib = 'shaderc_shared'
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(ConfigToolDependency.factory,
- 'libgcrypt', environment, None, kwargs, ['libgcrypt-config'],
- 'libgcrypt-config',
- LibGCryptDependency.tool_finish_init))
+ libs = [shared_lib, static_lib]
+ if self.static:
+ libs.reverse()
- return candidates
+ cc = self.get_compiler()
- @staticmethod
- def tool_finish_init(ctdep):
- ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
- ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
- ctdep.version = ctdep.get_config_value(['--version'], 'version')[0]
+ for lib in libs:
+ self.link_args = cc.find_library(lib, environment, [])
+ if self.link_args is not None:
+ self.is_found = True
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
+ if self.static and lib != static_lib:
+ mlog.warning(f'Static library {static_lib!r} not found for dependency '
+ f'{self.name!r}, may not be statically linked')
+ break
-class GpgmeDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('gpgme', environment, None, kwargs)
+ def log_tried(self) -> str:
+ return 'system'
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'gpgme', environment, kwargs))
+class CursesConfigToolDependency(ConfigToolDependency):
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(ConfigToolDependency.factory,
- 'gpgme', environment, None, kwargs, ['gpgme-config'],
- 'gpgme-config',
- GpgmeDependency.tool_finish_init))
+ """Use the curses config tools."""
- return candidates
+ tool = 'curses-config'
+ # ncurses5.4-config is for macOS Catalina
+ tools = ['ncursesw6-config', 'ncursesw5-config', 'ncurses6-config', 'ncurses5-config', 'ncurses5.4-config']
- @staticmethod
- def tool_finish_init(ctdep):
- ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
- ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
- ctdep.version = ctdep.get_config_value(['--version'], 'version')[0]
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None):
+ super().__init__(name, env, kwargs, language)
+ if not self.is_found:
+ return
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--libs'], 'link_args')
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
+class CursesSystemDependency(SystemDependency):
-class ShadercDependency(ExternalDependency):
+ """Curses dependency the hard way.
- def __init__(self, environment, kwargs):
- super().__init__('shaderc', environment, None, kwargs)
+ This replaces hand rolled find_library() and has_header() calls. We
+ provide this for portability reasons, there are a large number of curses
+ implementations, and the differences between them can be very annoying.
+ """
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, env, kwargs)
+
+ candidates = [
+ ('pdcurses', ['pdcurses/curses.h']),
+ ('ncursesw', ['ncursesw/ncurses.h', 'ncurses.h']),
+ ('ncurses', ['ncurses/ncurses.h', 'ncurses/curses.h', 'ncurses.h']),
+ ('curses', ['curses.h']),
+ ]
+
+ # Not sure how else to elegently break out of both loops
+ for lib, headers in candidates:
+ l = self.clib_compiler.find_library(lib, env, [])
+ if l:
+ for header in headers:
+ h = self.clib_compiler.has_header(header, '', env)
+ if h[0]:
+ self.is_found = True
+ self.link_args = l
+ # Not sure how to find version for non-ncurses curses
+ # implementations. The one in illumos/OpenIndiana
+ # doesn't seem to have a version defined in the header.
+ if lib.startswith('ncurses'):
+ v, _ = self.clib_compiler.get_define('NCURSES_VERSION', f'#include <{header}>', env, [], [self])
+ self.version = v.strip('"')
+ if lib.startswith('pdcurses'):
+ v_major, _ = self.clib_compiler.get_define('PDC_VER_MAJOR', f'#include <{header}>', env, [], [self])
+ v_minor, _ = self.clib_compiler.get_define('PDC_VER_MINOR', f'#include <{header}>', env, [], [self])
+ self.version = f'{v_major}.{v_minor}'
+
+ # Check the version if possible, emit a warning if we can't
+ req = kwargs.get('version')
+ if req:
+ if self.version:
+ self.is_found = mesonlib.version_compare(self.version, req)
+ else:
+ mlog.warning('Cannot determine version of curses to compare against.')
+
+ if self.is_found:
+ mlog.debug('Curses library:', l)
+ mlog.debug('Curses header:', header)
+ break
+ if self.is_found:
+ break
- static_lib = 'shaderc_combined'
- shared_lib = 'shaderc_shared'
- libs = [shared_lib, static_lib]
- if self.static:
- libs.reverse()
+class IconvBuiltinDependency(BuiltinDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, env, kwargs)
+ code = '''#include \n\nint main() {\n iconv_open("","");\n}''' # [ignore encoding] this is C, not python, Mr. Lint
- cc = self.get_compiler()
+ if self.clib_compiler.links(code, env)[0]:
+ self.is_found = True
- for lib in libs:
- self.link_args = cc.find_library(lib, environment, [])
- if self.link_args is not None:
- self.is_found = True
- if self.static and lib != static_lib:
- mlog.warning('Static library {!r} not found for dependency {!r}, may '
- 'not be statically linked'.format(static_lib, self.name))
+class IconvSystemDependency(SystemDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, env, kwargs)
- break
+ h = self.clib_compiler.has_header('iconv.h', '', env)
+ self.link_args = self.clib_compiler.find_library('iconv', env, [], self.libtype)
- def log_tried(self):
- return 'system'
+ if h[0] and self.link_args:
+ self.is_found = True
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- # ShaderC packages their shared and static libs together
- # and provides different pkg-config files for each one. We
- # smooth over this difference by handling the static
- # keyword before handing off to the pkg-config handler.
- shared_libs = ['shaderc']
- static_libs = ['shaderc_combined', 'shaderc_static']
-
- if kwargs.get('static', False):
- c = [functools.partial(PkgConfigDependency, name, environment, kwargs)
- for name in static_libs + shared_libs]
- else:
- c = [functools.partial(PkgConfigDependency, name, environment, kwargs)
- for name in shared_libs + static_libs]
- candidates.extend(c)
+
+class IntlBuiltinDependency(BuiltinDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, env, kwargs)
+
+ if self.clib_compiler.has_function('ngettext', '', env)[0]:
+ self.is_found = True
+
+
+class IntlSystemDependency(SystemDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, env, kwargs)
+
+ h = self.clib_compiler.has_header('libintl.h', '', env)
+ self.link_args = self.clib_compiler.find_library('intl', env, [], self.libtype)
+
+ if h[0] and self.link_args:
+ self.is_found = True
+
+ if self.static:
+ if not self._add_sub_dependency(iconv_factory(env, self.for_machine, {'static': True})):
+ self.is_found = False
+ return
+
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.SYSTEM})
+def curses_factory(env: 'Environment',
+ for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any],
+ methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ candidates: T.List['DependencyGenerator'] = []
+
+ if DependencyMethods.PKGCONFIG in methods:
+ pkgconfig_files = ['pdcurses', 'ncursesw', 'ncurses', 'curses']
+ for pkg in pkgconfig_files:
+ candidates.append(functools.partial(PkgConfigDependency, pkg, env, kwargs))
+
+ # There are path handling problems with these methods on msys, and they
+ # don't apply to windows otherwise (cygwin is handled separately from
+ # windows)
+ if not env.machines[for_machine].is_windows():
+ if DependencyMethods.CONFIG_TOOL in methods:
+ candidates.append(functools.partial(CursesConfigToolDependency, 'curses', env, kwargs))
if DependencyMethods.SYSTEM in methods:
- candidates.append(functools.partial(ShadercDependency, environment, kwargs))
+ candidates.append(functools.partial(CursesSystemDependency, 'curses', env, kwargs))
- return candidates
+ return candidates
- @staticmethod
- def get_methods():
- return [DependencyMethods.SYSTEM, DependencyMethods.PKGCONFIG]
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM})
+def shaderc_factory(env: 'Environment',
+ for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any],
+ methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ """Custom DependencyFactory for ShaderC.
+
+ ShaderC's odd you get three different libraries from the same build
+ thing are just easier to represent as a separate function than
+ twisting DependencyFactory even more.
+ """
+ candidates: T.List['DependencyGenerator'] = []
+
+ if DependencyMethods.PKGCONFIG in methods:
+ # ShaderC packages their shared and static libs together
+ # and provides different pkg-config files for each one. We
+ # smooth over this difference by handling the static
+ # keyword before handing off to the pkg-config handler.
+ shared_libs = ['shaderc']
+ static_libs = ['shaderc_combined', 'shaderc_static']
+
+ if kwargs.get('static', False):
+ c = [functools.partial(PkgConfigDependency, name, env, kwargs)
+ for name in static_libs + shared_libs]
+ else:
+ c = [functools.partial(PkgConfigDependency, name, env, kwargs)
+ for name in shared_libs + static_libs]
+ candidates.extend(c)
+
+ if DependencyMethods.SYSTEM in methods:
+ candidates.append(functools.partial(ShadercDependency, env, kwargs))
+
+ return candidates
+
+
+cups_factory = DependencyFactory(
+ 'cups',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK, DependencyMethods.CMAKE],
+ configtool_class=CupsDependencyConfigTool,
+ cmake_name='Cups',
+)
+
+gpgme_factory = DependencyFactory(
+ 'gpgme',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ configtool_class=GpgmeDependencyConfigTool,
+)
+
+libgcrypt_factory = DependencyFactory(
+ 'libgcrypt',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ configtool_class=LibGCryptDependencyConfigTool,
+)
+
+libwmf_factory = DependencyFactory(
+ 'libwmf',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ configtool_class=LibWmfDependencyConfigTool,
+)
+
+pcap_factory = DependencyFactory(
+ 'pcap',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ configtool_class=PcapDependencyConfigTool,
+ pkgconfig_name='libpcap',
+)
+
+python3_factory = DependencyFactory(
+ 'python3',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM, DependencyMethods.EXTRAFRAMEWORK],
+ system_class=Python3DependencySystem,
+ # There is no version number in the macOS version number
+ framework_name='Python',
+ # There is a python in /System/Library/Frameworks, but that's python 2.x,
+ # Python 3 will always be in /Library
+ extra_kwargs={'paths': ['/Library/Frameworks']},
+)
+
+threads_factory = DependencyFactory(
+ 'threads',
+ [DependencyMethods.SYSTEM, DependencyMethods.CMAKE],
+ cmake_name='Threads',
+ system_class=ThreadDependency,
+)
+
+iconv_factory = DependencyFactory(
+ 'iconv',
+ [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
+ builtin_class=IconvBuiltinDependency,
+ system_class=IconvSystemDependency,
+)
+
+intl_factory = DependencyFactory(
+ 'intl',
+ [DependencyMethods.BUILTIN, DependencyMethods.SYSTEM],
+ builtin_class=IntlBuiltinDependency,
+ system_class=IntlSystemDependency,
+)
diff -Nru meson-0.53.2/mesonbuild/dependencies/mpi.py meson-0.61.2/mesonbuild/dependencies/mpi.py
--- meson-0.53.2/mesonbuild/dependencies/mpi.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/mpi.py 2021-08-18 11:22:15.000000000 +0000
@@ -12,111 +12,95 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import functools
import typing as T
import os
import re
-import subprocess
-from .. import mlog
-from .. import mesonlib
-from ..mesonlib import split_args, listify
from ..environment import detect_cpu_family
-from .base import (DependencyException, DependencyMethods, ExternalDependency, ExternalProgram,
- PkgConfigDependency)
-
-
-class MPIDependency(ExternalDependency):
-
- def __init__(self, environment, kwargs: dict):
- language = kwargs.get('language', 'c')
- super().__init__('mpi', environment, language, kwargs)
- kwargs['required'] = False
- kwargs['silent'] = True
- self.is_found = False
- methods = listify(self.methods)
-
- env_vars = []
- default_wrappers = []
- pkgconfig_files = []
+from .base import DependencyMethods, detect_compiler, SystemDependency
+from .configtool import ConfigToolDependency
+from .factory import factory_methods
+from .pkgconfig import PkgConfigDependency
+
+if T.TYPE_CHECKING:
+ from .factory import DependencyGenerator
+ from ..environment import Environment, MachineChoice
+
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.SYSTEM})
+def mpi_factory(env: 'Environment',
+ for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any],
+ methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ language = kwargs.get('language', 'c')
+ if language not in {'c', 'cpp', 'fortran'}:
+ # OpenMPI doesn't work without any other languages
+ return []
+
+ candidates: T.List['DependencyGenerator'] = []
+ compiler = detect_compiler('mpi', env, for_machine, language)
+ if compiler is None:
+ return []
+ compiler_is_intel = compiler.get_id() in {'intel', 'intel-cl'}
+
+ # Only OpenMPI has pkg-config, and it doesn't work with the intel compilers
+ if DependencyMethods.PKGCONFIG in methods and not compiler_is_intel:
+ pkg_name = None
if language == 'c':
- cid = environment.detect_c_compiler(self.for_machine).get_id()
- if cid in ('intel', 'intel-cl'):
- env_vars.append('I_MPI_CC')
- # IntelMPI doesn't have .pc files
- default_wrappers.append('mpiicc')
- else:
- env_vars.append('MPICC')
- pkgconfig_files.append('ompi-c')
- default_wrappers.append('mpicc')
+ pkg_name = 'ompi-c'
elif language == 'cpp':
- cid = environment.detect_cpp_compiler(self.for_machine).get_id()
- if cid in ('intel', 'intel-cl'):
- env_vars.append('I_MPI_CXX')
- # IntelMPI doesn't have .pc files
- default_wrappers.append('mpiicpc')
- else:
- env_vars.append('MPICXX')
- pkgconfig_files.append('ompi-cxx')
- default_wrappers += ['mpic++', 'mpicxx', 'mpiCC'] # these are not for intelmpi
+ pkg_name = 'ompi-cxx'
elif language == 'fortran':
- cid = environment.detect_fortran_compiler(self.for_machine).get_id()
- if cid in ('intel', 'intel-cl'):
- env_vars.append('I_MPI_F90')
- # IntelMPI doesn't have .pc files
- default_wrappers.append('mpiifort')
- else:
- env_vars += ['MPIFC', 'MPIF90', 'MPIF77']
- pkgconfig_files.append('ompi-fort')
- default_wrappers += ['mpifort', 'mpif90', 'mpif77']
- else:
- raise DependencyException('Language {} is not supported with MPI.'.format(language))
+ pkg_name = 'ompi-fort'
+ candidates.append(functools.partial(
+ PkgConfigDependency, pkg_name, env, kwargs, language=language))
+
+ if DependencyMethods.CONFIG_TOOL in methods:
+ nwargs = kwargs.copy()
+
+ if compiler_is_intel:
+ if env.machines[for_machine].is_windows():
+ nwargs['version_arg'] = '-v'
+ nwargs['returncode_value'] = 3
+
+ if language == 'c':
+ tool_names = [os.environ.get('I_MPI_CC'), 'mpiicc']
+ elif language == 'cpp':
+ tool_names = [os.environ.get('I_MPI_CXX'), 'mpiicpc']
+ elif language == 'fortran':
+ tool_names = [os.environ.get('I_MPI_F90'), 'mpiifort']
+
+ cls = IntelMPIConfigToolDependency # type: T.Type[ConfigToolDependency]
+ else: # OpenMPI, which doesn't work with intel
+ #
+ # We try the environment variables for the tools first, but then
+ # fall back to the hardcoded names
+ if language == 'c':
+ tool_names = [os.environ.get('MPICC'), 'mpicc']
+ elif language == 'cpp':
+ tool_names = [os.environ.get('MPICXX'), 'mpic++', 'mpicxx', 'mpiCC']
+ elif language == 'fortran':
+ tool_names = [os.environ.get(e) for e in ['MPIFC', 'MPIF90', 'MPIF77']]
+ tool_names.extend(['mpifort', 'mpif90', 'mpif77'])
+
+ cls = OpenMPIConfigToolDependency
+
+ tool_names = [t for t in tool_names if t] # remove empty environment variables
+ assert tool_names
+
+ nwargs['tools'] = tool_names
+ candidates.append(functools.partial(
+ cls, tool_names[0], env, nwargs, language=language))
+
+ if DependencyMethods.SYSTEM in methods:
+ candidates.append(functools.partial(
+ MSMPIDependency, 'msmpi', env, kwargs, language=language))
- if set([DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]).intersection(methods):
- for pkg in pkgconfig_files:
- pkgdep = PkgConfigDependency(pkg, environment, kwargs, language=self.language)
- if pkgdep.found():
- self.compile_args = pkgdep.get_compile_args()
- self.link_args = pkgdep.get_link_args()
- self.version = pkgdep.get_version()
- self.is_found = True
- self.pcdep = pkgdep
- return
-
- if DependencyMethods.AUTO in methods:
- for var in env_vars:
- if var in os.environ:
- wrappers = [os.environ[var]]
- break
- else:
- # Or search for default wrappers.
- wrappers = default_wrappers
-
- for prog in wrappers:
- # Note: Some use OpenMPI with Intel compilers on Linux
- result = self._try_openmpi_wrapper(prog, cid)
- if result is not None:
- self.is_found = True
- self.version = result[0]
- self.compile_args = self._filter_compile_args(result[1])
- self.link_args = self._filter_link_args(result[2], cid)
- break
- result = self._try_other_wrapper(prog, cid)
- if result is not None:
- self.is_found = True
- self.version = result[0]
- self.compile_args = self._filter_compile_args(result[1])
- self.link_args = self._filter_link_args(result[2], cid)
- break
-
- if not self.is_found and mesonlib.is_windows():
- # only Intel Fortran compiler is compatible with Microsoft MPI at this time.
- if language == 'fortran' and cid != 'intel-cl':
- return
- result = self._try_msmpi()
- if result is not None:
- self.is_found = True
- self.version, self.compile_args, self.link_args = result
- return
+ return candidates
+
+
+class _MPIConfigToolDependency(ConfigToolDependency):
def _filter_compile_args(self, args: T.Sequence[str]) -> T.List[str]:
"""
@@ -124,7 +108,7 @@
Drop -O2 and everything that is not needed.
"""
result = []
- multi_args = ('-I', )
+ multi_args: T.Tuple[str, ...] = ('-I', )
if self.language == 'fortran':
fc = self.env.coredata.compilers[self.for_machine]['fortran']
multi_args += fc.get_module_incdir_args()
@@ -142,7 +126,7 @@
result.append(f)
return result
- def _filter_link_args(self, args: T.Sequence[str], cid: str) -> T.List[str]:
+ def _filter_link_args(self, args: T.Sequence[str]) -> T.List[str]:
"""
MPI wrappers return a bunch of garbage args.
Drop -O2 and everything that is not needed.
@@ -150,7 +134,7 @@
result = []
include_next = False
for f in args:
- if self._is_link_arg(f, cid):
+ if self._is_link_arg(f):
result.append(f)
if f in ('-L', '-Xlinker'):
include_next = True
@@ -159,121 +143,94 @@
result.append(f)
return result
- @staticmethod
- def _is_link_arg(f: str, cid: str) -> bool:
- if cid == 'intel-cl':
+ def _is_link_arg(self, f: str) -> bool:
+ if self.clib_compiler.id == 'intel-cl':
return f == '/link' or f.startswith('/LIBPATH') or f.endswith('.lib') # always .lib whether static or dynamic
else:
return (f.startswith(('-L', '-l', '-Xlinker')) or
f == '-pthread' or
(f.startswith('-W') and f != '-Wall' and not f.startswith('-Werror')))
- def _try_openmpi_wrapper(self, prog, cid: str):
- # https://www.open-mpi.org/doc/v4.0/man1/mpifort.1.php
- if cid == 'intel-cl': # IntelCl doesn't support OpenMPI
- return None
- prog = ExternalProgram(prog, silent=True)
- if not prog.found():
- return None
-
- # compiler args
- cmd = prog.get_command() + ['--showme:compile']
- p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=15)
- if p.returncode != 0:
- mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
- mlog.debug(mlog.bold('Standard output\n'), p.stdout)
- mlog.debug(mlog.bold('Standard error\n'), p.stderr)
- return None
- cargs = split_args(p.stdout)
- # link args
- cmd = prog.get_command() + ['--showme:link']
- p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=15)
- if p.returncode != 0:
- mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
- mlog.debug(mlog.bold('Standard output\n'), p.stdout)
- mlog.debug(mlog.bold('Standard error\n'), p.stderr)
- return None
- libs = split_args(p.stdout)
- # version
- cmd = prog.get_command() + ['--showme:version']
- p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=15)
- if p.returncode != 0:
- mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
- mlog.debug(mlog.bold('Standard output\n'), p.stdout)
- mlog.debug(mlog.bold('Standard error\n'), p.stderr)
- return None
- v = re.search(r'\d+.\d+.\d+', p.stdout)
+
+class IntelMPIConfigToolDependency(_MPIConfigToolDependency):
+
+ """Wrapper around Intel's mpiicc and friends."""
+
+ version_arg = '-v' # --version is not the same as -v
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ language: T.Optional[str] = None):
+ super().__init__(name, env, kwargs, language=language)
+ if not self.is_found:
+ return
+
+ args = self.get_config_value(['-show'], 'link and compile args')
+ self.compile_args = self._filter_compile_args(args)
+ self.link_args = self._filter_link_args(args)
+
+ def _sanitize_version(self, out: str) -> str:
+ v = re.search(r'(\d{4}) Update (\d)', out)
if v:
- version = v.group(0)
- else:
- version = None
+ return '{}.{}'.format(v.group(1), v.group(2))
+ return out
- return version, cargs, libs
- def _try_other_wrapper(self, prog, cid: str) -> T.Tuple[str, T.List[str], T.List[str]]:
- prog = ExternalProgram(prog, silent=True)
- if not prog.found():
- return None
-
- cmd = prog.get_command()
- if cid == 'intel-cl':
- cmd.append('/show')
- else:
- cmd.append('-show')
- p = subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=15)
- if p.returncode != 0:
- mlog.debug('Command', mlog.bold(cmd), 'failed to run:')
- mlog.debug(mlog.bold('Standard output\n'), p.stdout)
- mlog.debug(mlog.bold('Standard error\n'), p.stderr)
- return None
-
- version = None
- stdout = p.stdout
- if 'Intel(R) MPI Library' in p.stdout: # intel-cl: remove messy compiler logo
- out = stdout.split('\n', 2)
- version = out[0]
- stdout = out[2]
-
- if version is None:
- p = subprocess.run(cmd + ['-v'], stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True, timeout=15)
- if p.returncode == 0:
- version = p.stdout.split('\n', 1)[0]
-
- args = split_args(stdout)
-
- return version, args, args
-
- def _try_msmpi(self) -> T.Tuple[str, T.List[str], T.List[str]]:
- if self.language == 'cpp':
- # MS-MPI does not support the C++ version of MPI, only the standard C API.
- return None
- if 'MSMPI_INC' not in os.environ:
- return None
+class OpenMPIConfigToolDependency(_MPIConfigToolDependency):
+
+ """Wrapper around OpenMPI mpicc and friends."""
- incdir = os.environ['MSMPI_INC']
+ version_arg = '--showme:version'
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ language: T.Optional[str] = None):
+ super().__init__(name, env, kwargs, language=language)
+ if not self.is_found:
+ return
+
+ c_args = self.get_config_value(['--showme:compile'], 'compile_args')
+ self.compile_args = self._filter_compile_args(c_args)
+
+ l_args = self.get_config_value(['--showme:link'], 'link_args')
+ self.link_args = self._filter_link_args(l_args)
+
+ def _sanitize_version(self, out: str) -> str:
+ v = re.search(r'\d+.\d+.\d+', out)
+ if v:
+ return v.group(0)
+ return out
+
+
+class MSMPIDependency(SystemDependency):
+
+ """The Microsoft MPI."""
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ language: T.Optional[str] = None):
+ super().__init__(name, env, kwargs, language=language)
+ # MSMPI only supports the C API
+ if language not in {'c', 'fortran', None}:
+ self.is_found = False
+ return
+ # MSMPI is only for windows, obviously
+ if not self.env.machines[self.for_machine].is_windows():
+ return
+
+ incdir = os.environ.get('MSMPI_INC')
arch = detect_cpu_family(self.env.coredata.compilers.host)
+ libdir = None
if arch == 'x86':
- if 'MSMPI_LIB32' not in os.environ:
- return None
- libdir = os.environ['MSMPI_LIB32']
+ libdir = os.environ.get('MSMPI_LIB32')
post = 'x86'
elif arch == 'x86_64':
- if 'MSMPI_LIB64' not in os.environ:
- return None
- libdir = os.environ['MSMPI_LIB64']
+ libdir = os.environ.get('MSMPI_LIB64')
post = 'x64'
- else:
- return None
+ if libdir is None or incdir is None:
+ self.is_found = False
+ return
+
+ self.is_found = True
+ self.link_args = ['-l' + os.path.join(libdir, 'msmpi')]
+ self.compile_args = ['-I' + incdir, '-I' + os.path.join(incdir, post)]
if self.language == 'fortran':
- return (None,
- ['-I' + incdir, '-I' + os.path.join(incdir, post)],
- [os.path.join(libdir, 'msmpi.lib'), os.path.join(libdir, 'msmpifec.lib')])
- else:
- return (None,
- ['-I' + incdir, '-I' + os.path.join(incdir, post)],
- [os.path.join(libdir, 'msmpi.lib')])
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]
+ self.link_args.append('-l' + os.path.join(libdir, 'msmpifec'))
diff -Nru meson-0.53.2/mesonbuild/dependencies/pkgconfig.py meson-0.61.2/mesonbuild/dependencies/pkgconfig.py
--- meson-0.53.2/mesonbuild/dependencies/pkgconfig.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/pkgconfig.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,497 @@
+# 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 ExternalDependency, DependencyException, sort_libpaths, DependencyTypeName
+from ..mesonlib import MachineChoice, OptionKey, OrderedSet, PerMachine, Popen_safe
+from ..programs import find_external_program, ExternalProgram
+from .. import mlog
+from pathlib import PurePath
+import re
+import os
+import shlex
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
+class PkgConfigDependency(ExternalDependency):
+ # The class's copy of the pkg-config path. Avoids having to search for it
+ # multiple times in the same Meson invocation.
+ class_pkgbin: PerMachine[T.Union[None, bool, ExternalProgram]] = PerMachine(None, None)
+ # We cache all pkg-config subprocess invocations to avoid redundant calls
+ pkgbin_cache: T.Dict[
+ T.Tuple[ExternalProgram, T.Tuple[str, ...], T.FrozenSet[T.Tuple[str, str]]],
+ T.Tuple[int, str, str]
+ ] = {}
+
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None) -> None:
+ super().__init__(DependencyTypeName('pkgconfig'), environment, kwargs, language=language)
+ self.name = name
+ self.is_libtool = False
+ # Store a copy of the pkg-config path on the object itself so it is
+ # stored in the pickled coredata and recovered.
+ self.pkgbin: T.Union[None, bool, ExternalProgram] = None
+
+ # Only search for pkg-config for each machine the first time and store
+ # the result in the class definition
+ if PkgConfigDependency.class_pkgbin[self.for_machine] is False:
+ mlog.debug(f'Pkg-config binary for {self.for_machine} is cached as not found.')
+ elif PkgConfigDependency.class_pkgbin[self.for_machine] is not None:
+ mlog.debug(f'Pkg-config binary for {self.for_machine} is cached.')
+ else:
+ assert PkgConfigDependency.class_pkgbin[self.for_machine] is None
+ mlog.debug(f'Pkg-config binary for {self.for_machine} is not cached.')
+ for potential_pkgbin in find_external_program(
+ self.env, self.for_machine, 'pkgconfig', 'Pkg-config',
+ environment.default_pkgconfig, allow_default_for_cross=False):
+ version_if_ok = self.check_pkgconfig(potential_pkgbin)
+ if not version_if_ok:
+ continue
+ if not self.silent:
+ mlog.log('Found pkg-config:', mlog.bold(potential_pkgbin.get_path()),
+ f'({version_if_ok})')
+ PkgConfigDependency.class_pkgbin[self.for_machine] = potential_pkgbin
+ break
+ else:
+ if not self.silent:
+ mlog.log('Found Pkg-config:', mlog.red('NO'))
+ # Set to False instead of None to signify that we've already
+ # searched for it and not found it
+ PkgConfigDependency.class_pkgbin[self.for_machine] = False
+
+ self.pkgbin = PkgConfigDependency.class_pkgbin[self.for_machine]
+ if self.pkgbin is False:
+ self.pkgbin = None
+ msg = f'Pkg-config binary for machine {self.for_machine} not found. Giving up.'
+ if self.required:
+ raise DependencyException(msg)
+ else:
+ mlog.debug(msg)
+ return
+
+ assert isinstance(self.pkgbin, ExternalProgram)
+ mlog.debug('Determining dependency {!r} with pkg-config executable '
+ '{!r}'.format(name, self.pkgbin.get_path()))
+ ret, self.version, _ = self._call_pkgbin(['--modversion', name])
+ if ret != 0:
+ return
+
+ self.is_found = True
+
+ try:
+ # Fetch cargs to be used while using this dependency
+ self._set_cargs()
+ # Fetch the libraries and library paths needed for using this
+ self._set_libs()
+ except DependencyException as e:
+ mlog.debug(f"pkg-config error with '{name}': {e}")
+ if self.required:
+ raise
+ else:
+ self.compile_args = []
+ self.link_args = []
+ self.is_found = False
+ self.reason = e
+
+ def __repr__(self) -> str:
+ s = '<{0} {1}: {2} {3}>'
+ return s.format(self.__class__.__name__, self.name, self.is_found,
+ self.version_reqs)
+
+ def _call_pkgbin_real(self, args: T.List[str], env: T.Dict[str, str]) -> T.Tuple[int, str, str]:
+ assert isinstance(self.pkgbin, ExternalProgram)
+ cmd = self.pkgbin.get_command() + args
+ p, out, err = Popen_safe(cmd, env=env)
+ rc, out, err = p.returncode, out.strip(), err.strip()
+ call = ' '.join(cmd)
+ mlog.debug(f"Called `{call}` -> {rc}\n{out}")
+ return rc, out, err
+
+ @staticmethod
+ def setup_env(env: T.MutableMapping[str, str], environment: 'Environment', for_machine: MachineChoice,
+ extra_path: T.Optional[str] = None) -> None:
+ extra_paths: T.List[str] = environment.coredata.options[OptionKey('pkg_config_path', machine=for_machine)].value[:]
+ if extra_path and extra_path not in extra_paths:
+ extra_paths.append(extra_path)
+ sysroot = environment.properties[for_machine].get_sys_root()
+ if sysroot:
+ env['PKG_CONFIG_SYSROOT_DIR'] = sysroot
+ new_pkg_config_path = ':'.join([p for p in extra_paths])
+ env['PKG_CONFIG_PATH'] = new_pkg_config_path
+
+ pkg_config_libdir_prop = environment.properties[for_machine].get_pkg_config_libdir()
+ if pkg_config_libdir_prop:
+ new_pkg_config_libdir = ':'.join([p for p in pkg_config_libdir_prop])
+ env['PKG_CONFIG_LIBDIR'] = new_pkg_config_libdir
+ # Dump all PKG_CONFIG environment variables
+ for key, value in env.items():
+ if key.startswith('PKG_'):
+ mlog.debug(f'env[{key}]: {value}')
+
+ def _call_pkgbin(self, args: T.List[str], env: T.Optional[T.Dict[str, str]] = None) -> T.Tuple[int, str, str]:
+ # Always copy the environment since we're going to modify it
+ # with pkg-config variables
+ if env is None:
+ env = os.environ.copy()
+ else:
+ env = env.copy()
+
+ assert isinstance(self.pkgbin, ExternalProgram)
+ PkgConfigDependency.setup_env(env, self.env, self.for_machine)
+
+ fenv = frozenset(env.items())
+ targs = tuple(args)
+ cache = PkgConfigDependency.pkgbin_cache
+ if (self.pkgbin, targs, fenv) not in cache:
+ cache[(self.pkgbin, targs, fenv)] = self._call_pkgbin_real(args, env)
+ return cache[(self.pkgbin, targs, fenv)]
+
+ def _convert_mingw_paths(self, args: T.List[str]) -> T.List[str]:
+ '''
+ Both MSVC and native Python on Windows cannot handle MinGW-esque /c/foo
+ paths so convert them to C:/foo. We cannot resolve other paths starting
+ with / like /home/foo so leave them as-is so that the user gets an
+ error/warning from the compiler/linker.
+ '''
+ if not self.env.machines.build.is_windows():
+ return args
+ converted = []
+ for arg in args:
+ pargs: T.Tuple[str, ...] = tuple()
+ # Library search path
+ if arg.startswith('-L/'):
+ pargs = PurePath(arg[2:]).parts
+ tmpl = '-L{}:/{}'
+ elif arg.startswith('-I/'):
+ pargs = PurePath(arg[2:]).parts
+ tmpl = '-I{}:/{}'
+ # Full path to library or .la file
+ elif arg.startswith('/'):
+ pargs = PurePath(arg).parts
+ tmpl = '{}:/{}'
+ elif arg.startswith(('-L', '-I')) or (len(arg) > 2 and arg[1] == ':'):
+ # clean out improper '\\ ' as comes from some Windows pkg-config files
+ arg = arg.replace('\\ ', ' ')
+ if len(pargs) > 1 and len(pargs[1]) == 1:
+ arg = tmpl.format(pargs[1], '/'.join(pargs[2:]))
+ converted.append(arg)
+ return converted
+
+ def _split_args(self, cmd: str) -> T.List[str]:
+ # pkg-config paths follow Unix conventions, even on Windows; split the
+ # output using shlex.split rather than mesonlib.split_args
+ return shlex.split(cmd)
+
+ def _set_cargs(self) -> None:
+ env = None
+ if self.language == 'fortran':
+ # gfortran doesn't appear to look in system paths for INCLUDE files,
+ # so don't allow pkg-config to suppress -I flags for system paths
+ env = os.environ.copy()
+ env['PKG_CONFIG_ALLOW_SYSTEM_CFLAGS'] = '1'
+ ret, out, err = self._call_pkgbin(['--cflags', self.name], env=env)
+ if ret != 0:
+ raise DependencyException(f'Could not generate cargs for {self.name}:\n{err}\n')
+ self.compile_args = self._convert_mingw_paths(self._split_args(out))
+
+ def _search_libs(self, out: str, out_raw: str) -> T.Tuple[T.List[str], T.List[str]]:
+ '''
+ @out: PKG_CONFIG_ALLOW_SYSTEM_LIBS=1 pkg-config --libs
+ @out_raw: pkg-config --libs
+
+ We always look for the file ourselves instead of depending on the
+ compiler to find it with -lfoo or foo.lib (if possible) because:
+ 1. We want to be able to select static or shared
+ 2. We need the full path of the library to calculate RPATH values
+ 3. De-dup of libraries is easier when we have absolute paths
+
+ Libraries that are provided by the toolchain or are not found by
+ find_library() will be added with -L -l pairs.
+ '''
+ # Library paths should be safe to de-dup
+ #
+ # First, figure out what library paths to use. Originally, we were
+ # doing this as part of the loop, but due to differences in the order
+ # of -L values between pkg-config and pkgconf, we need to do that as
+ # a separate step. See:
+ # https://github.com/mesonbuild/meson/issues/3951
+ # https://github.com/mesonbuild/meson/issues/4023
+ #
+ # Separate system and prefix paths, and ensure that prefix paths are
+ # always searched first.
+ prefix_libpaths: OrderedSet[str] = OrderedSet()
+ # We also store this raw_link_args on the object later
+ raw_link_args = self._convert_mingw_paths(self._split_args(out_raw))
+ for arg in raw_link_args:
+ if arg.startswith('-L') and not arg.startswith(('-L-l', '-L-L')):
+ path = arg[2:]
+ if not os.path.isabs(path):
+ # Resolve the path as a compiler in the build directory would
+ path = os.path.join(self.env.get_build_dir(), path)
+ prefix_libpaths.add(path)
+ # Library paths are not always ordered in a meaningful way
+ #
+ # Instead of relying on pkg-config or pkgconf to provide -L flags in a
+ # specific order, we reorder library paths ourselves, according to th
+ # order specified in PKG_CONFIG_PATH. See:
+ # https://github.com/mesonbuild/meson/issues/4271
+ #
+ # Only prefix_libpaths are reordered here because there should not be
+ # too many system_libpaths to cause library version issues.
+ pkg_config_path: T.List[str] = self.env.coredata.options[OptionKey('pkg_config_path', machine=self.for_machine)].value
+ pkg_config_path = self._convert_mingw_paths(pkg_config_path)
+ prefix_libpaths = OrderedSet(sort_libpaths(list(prefix_libpaths), pkg_config_path))
+ system_libpaths: OrderedSet[str] = OrderedSet()
+ full_args = self._convert_mingw_paths(self._split_args(out))
+ for arg in full_args:
+ if arg.startswith(('-L-l', '-L-L')):
+ # These are D language arguments, not library paths
+ continue
+ if arg.startswith('-L') and arg[2:] not in prefix_libpaths:
+ system_libpaths.add(arg[2:])
+ # Use this re-ordered path list for library resolution
+ libpaths = list(prefix_libpaths) + list(system_libpaths)
+ # Track -lfoo libraries to avoid duplicate work
+ libs_found: OrderedSet[str] = OrderedSet()
+ # Track not-found libraries to know whether to add library paths
+ libs_notfound = []
+ # Generate link arguments for this library
+ link_args = []
+ for lib in full_args:
+ if lib.startswith(('-L-l', '-L-L')):
+ # These are D language arguments, add them as-is
+ pass
+ elif lib.startswith('-L'):
+ # We already handled library paths above
+ continue
+ elif lib.startswith('-l:'):
+ # see: https://stackoverflow.com/questions/48532868/gcc-library-option-with-a-colon-llibevent-a
+ # also : See the documentation of -lnamespec | --library=namespec in the linker manual
+ # https://sourceware.org/binutils/docs-2.18/ld/Options.html
+
+ # Don't resolve the same -l:libfoo.a argument again
+ if lib in libs_found:
+ continue
+ libfilename = lib[3:]
+ foundname = None
+ for libdir in libpaths:
+ target = os.path.join(libdir, libfilename)
+ if os.path.exists(target):
+ foundname = target
+ break
+ if foundname is None:
+ if lib in libs_notfound:
+ continue
+ else:
+ mlog.warning('Library {!r} not found for dependency {!r}, may '
+ 'not be successfully linked'.format(libfilename, self.name))
+ libs_notfound.append(lib)
+ else:
+ lib = foundname
+ elif lib.startswith('-l'):
+ # Don't resolve the same -lfoo argument again
+ if lib in libs_found:
+ continue
+ if self.clib_compiler:
+ args = self.clib_compiler.find_library(lib[2:], self.env,
+ libpaths, self.libtype)
+ # If the project only uses a non-clib language such as D, Rust,
+ # C#, Python, etc, all we can do is limp along by adding the
+ # arguments as-is and then adding the libpaths at the end.
+ else:
+ args = None
+ if args is not None:
+ libs_found.add(lib)
+ # Replace -l arg with full path to library if available
+ # else, library is either to be ignored, or is provided by
+ # the compiler, can't be resolved, and should be used as-is
+ if args:
+ if not args[0].startswith('-l'):
+ lib = args[0]
+ else:
+ continue
+ else:
+ # Library wasn't found, maybe we're looking in the wrong
+ # places or the library will be provided with LDFLAGS or
+ # LIBRARY_PATH from the environment (on macOS), and many
+ # other edge cases that we can't account for.
+ #
+ # Add all -L paths and use it as -lfoo
+ if lib in libs_notfound:
+ continue
+ if self.static:
+ mlog.warning('Static library {!r} not found for dependency {!r}, may '
+ 'not be statically linked'.format(lib[2:], self.name))
+ libs_notfound.append(lib)
+ elif lib.endswith(".la"):
+ shared_libname = self.extract_libtool_shlib(lib)
+ shared_lib = os.path.join(os.path.dirname(lib), shared_libname)
+ if not os.path.exists(shared_lib):
+ shared_lib = os.path.join(os.path.dirname(lib), ".libs", shared_libname)
+
+ if not os.path.exists(shared_lib):
+ raise DependencyException(f'Got a libtools specific "{lib}" dependencies'
+ 'but we could not compute the actual shared'
+ 'library path')
+ self.is_libtool = True
+ lib = shared_lib
+ if lib in link_args:
+ continue
+ link_args.append(lib)
+ # Add all -Lbar args if we have -lfoo args in link_args
+ if libs_notfound:
+ # Order of -L flags doesn't matter with ld, but it might with other
+ # linkers such as MSVC, so prepend them.
+ link_args = ['-L' + lp for lp in prefix_libpaths] + link_args
+ return link_args, raw_link_args
+
+ def _set_libs(self) -> None:
+ env = None
+ libcmd = ['--libs']
+
+ if self.static:
+ libcmd.append('--static')
+
+ libcmd.append(self.name)
+
+ # Force pkg-config to output -L fields even if they are system
+ # paths so we can do manual searching with cc.find_library() later.
+ env = os.environ.copy()
+ env['PKG_CONFIG_ALLOW_SYSTEM_LIBS'] = '1'
+ ret, out, err = self._call_pkgbin(libcmd, env=env)
+ if ret != 0:
+ raise DependencyException(f'Could not generate libs for {self.name}:\n{err}\n')
+ # Also get the 'raw' output without -Lfoo system paths for adding -L
+ # args with -lfoo when a library can't be found, and also in
+ # gnome.generate_gir + gnome.gtkdoc which need -L -l arguments.
+ ret, out_raw, err_raw = self._call_pkgbin(libcmd)
+ if ret != 0:
+ raise DependencyException(f'Could not generate libs for {self.name}:\n\n{out_raw}')
+ self.link_args, self.raw_link_args = self._search_libs(out, out_raw)
+
+ def get_pkgconfig_variable(self, variable_name: str, kwargs: T.Dict[str, T.Union[str, T.List[str]]]) -> str:
+ options = ['--variable=' + variable_name, self.name]
+
+ if 'define_variable' in kwargs:
+ definition = kwargs.get('define_variable', [])
+ if not isinstance(definition, list):
+ raise DependencyException('define_variable takes a list')
+
+ if len(definition) != 2 or not all(isinstance(i, str) for i in definition):
+ raise DependencyException('define_variable must be made up of 2 strings for VARIABLENAME and VARIABLEVALUE')
+
+ options = ['--define-variable=' + '='.join(definition)] + options
+
+ ret, out, err = self._call_pkgbin(options)
+ variable = ''
+ if ret != 0:
+ if self.required:
+ raise DependencyException(f'dependency {self.name} not found:\n{err}\n')
+ else:
+ variable = out.strip()
+
+ # pkg-config doesn't distinguish between empty and non-existent variables
+ # use the variable list to check for variable existence
+ if not variable:
+ ret, out, _ = self._call_pkgbin(['--print-variables', self.name])
+ if not re.search(r'^' + variable_name + r'$', out, re.MULTILINE):
+ if 'default' in kwargs:
+ assert isinstance(kwargs['default'], str)
+ variable = kwargs['default']
+ else:
+ mlog.warning(f"pkgconfig variable '{variable_name}' not defined for dependency {self.name}.")
+
+ mlog.debug(f'Got pkgconfig variable {variable_name} : {variable}')
+ return variable
+
+ def check_pkgconfig(self, pkgbin: ExternalProgram) -> T.Optional[str]:
+ if not pkgbin.found():
+ mlog.log(f'Did not find pkg-config by name {pkgbin.name!r}')
+ return None
+ command_as_string = ' '.join(pkgbin.get_command())
+ try:
+ helptext = Popen_safe(pkgbin.get_command() + ['--help'])[1]
+ if 'Pure-Perl' in helptext:
+ mlog.log(f'found pkg-config {command_as_string!r} but it is Strawberry Perl and thus broken. Ignoring...')
+ return None
+ p, out = Popen_safe(pkgbin.get_command() + ['--version'])[0:2]
+ if p.returncode != 0:
+ mlog.warning(f'Found pkg-config {command_as_string!r} but it failed when run')
+ return None
+ except FileNotFoundError:
+ mlog.warning(f'We thought we found pkg-config {command_as_string!r} but now it\'s not there. How odd!')
+ return None
+ except PermissionError:
+ msg = f'Found pkg-config {command_as_string!r} but didn\'t have permissions to run it.'
+ if not self.env.machines.build.is_windows():
+ msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
+ mlog.warning(msg)
+ return None
+ return out.strip()
+
+ def extract_field(self, la_file: str, fieldname: str) -> T.Optional[str]:
+ with open(la_file, encoding='utf-8') as f:
+ for line in f:
+ arr = line.strip().split('=')
+ if arr[0] == fieldname:
+ return arr[1][1:-1]
+ return None
+
+ def extract_dlname_field(self, la_file: str) -> T.Optional[str]:
+ return self.extract_field(la_file, 'dlname')
+
+ def extract_libdir_field(self, la_file: str) -> T.Optional[str]:
+ return self.extract_field(la_file, 'libdir')
+
+ def extract_libtool_shlib(self, la_file: str) -> T.Optional[str]:
+ '''
+ Returns the path to the shared library
+ corresponding to this .la file
+ '''
+ dlname = self.extract_dlname_field(la_file)
+ if dlname is None:
+ return None
+
+ # Darwin uses absolute paths where possible; since the libtool files never
+ # contain absolute paths, use the libdir field
+ if self.env.machines[self.for_machine].is_darwin():
+ dlbasename = os.path.basename(dlname)
+ libdir = self.extract_libdir_field(la_file)
+ if libdir is None:
+ return dlbasename
+ return os.path.join(libdir, dlbasename)
+ # From the comments in extract_libtool(), older libtools had
+ # a path rather than the raw dlname
+ return os.path.basename(dlname)
+
+ def log_tried(self) -> str:
+ return self.type_name
+
+ 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: T.Optional[T.List[str]] = None) -> T.Union[str, T.List[str]]:
+ if pkgconfig:
+ kwargs: T.Dict[str, T.Union[str, T.List[str]]] = {}
+ if default_value is not None:
+ kwargs['default'] = default_value
+ if pkgconfig_define is not None:
+ kwargs['define_variable'] = pkgconfig_define
+ try:
+ return self.get_pkgconfig_variable(pkgconfig, kwargs)
+ except DependencyException:
+ pass
+ if default_value is not None:
+ return default_value
+ raise DependencyException(f'Could not get pkg-config variable and no default provided for {self!r}')
diff -Nru meson-0.53.2/mesonbuild/dependencies/platform.py meson-0.61.2/mesonbuild/dependencies/platform.py
--- meson-0.53.2/mesonbuild/dependencies/platform.py 2019-05-02 18:59:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/platform.py 2021-08-18 11:22:15.000000000 +0000
@@ -15,12 +15,16 @@
# This file contains the detection logic for external dependencies that are
# platform-specific (generally speaking).
-from .base import ExternalDependency, DependencyException
+from .base import DependencyTypeName, ExternalDependency, DependencyException
from ..mesonlib import MesonException
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
class AppleFrameworks(ExternalDependency):
- def __init__(self, env, kwargs):
- super().__init__('appleframeworks', env, None, kwargs)
+ def __init__(self, env: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__(DependencyTypeName('appleframeworks'), env, kwargs)
modules = kwargs.get('modules', [])
if isinstance(modules, str):
modules = [modules]
@@ -47,8 +51,8 @@
else:
self.is_found = False
- def log_info(self):
+ def log_info(self) -> str:
return ', '.join(self.frameworks)
- def log_tried(self):
+ def log_tried(self) -> str:
return 'framework'
diff -Nru meson-0.53.2/mesonbuild/dependencies/qt.py meson-0.61.2/mesonbuild/dependencies/qt.py
--- meson-0.53.2/mesonbuild/dependencies/qt.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/qt.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,438 @@
+# Copyright 2013-2017 The Meson development team
+# Copyright © 2021 Intel Corporation
+# SPDX-license-identifier: Apache-2.0
+
+# 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.
+
+"""Dependency finders for the Qt framework."""
+
+import abc
+import re
+import os
+import typing as T
+
+from .base import DependencyException, DependencyMethods
+from .configtool import ConfigToolDependency
+from .framework import ExtraFrameworkDependency
+from .pkgconfig import PkgConfigDependency
+from .factory import DependencyFactory
+from .. import mlog
+from .. import mesonlib
+
+if T.TYPE_CHECKING:
+ from ..compilers import Compiler
+ from ..envconfig import MachineInfo
+ from ..environment import Environment
+
+
+def _qt_get_private_includes(mod_inc_dir: str, module: str, mod_version: str) -> T.List[str]:
+ # usually Qt5 puts private headers in /QT_INSTALL_HEADERS/module/VERSION/module/private
+ # except for at least QtWebkit and Enginio where the module version doesn't match Qt version
+ # as an example with Qt 5.10.1 on linux you would get:
+ # /usr/include/qt5/QtCore/5.10.1/QtCore/private/
+ # /usr/include/qt5/QtWidgets/5.10.1/QtWidgets/private/
+ # /usr/include/qt5/QtWebKit/5.212.0/QtWebKit/private/
+
+ # on Qt4 when available private folder is directly in module folder
+ # like /usr/include/QtCore/private/
+ if int(mod_version.split('.')[0]) < 5:
+ return []
+
+ private_dir = os.path.join(mod_inc_dir, mod_version)
+ # fallback, let's try to find a directory with the latest version
+ if not os.path.exists(private_dir):
+ dirs = [filename for filename in os.listdir(mod_inc_dir)
+ if os.path.isdir(os.path.join(mod_inc_dir, filename))]
+
+ for dirname in sorted(dirs, reverse=True):
+ if len(dirname.split('.')) == 3:
+ private_dir = dirname
+ break
+ return [private_dir, os.path.join(private_dir, 'Qt' + module)]
+
+
+def get_qmake_host_bins(qvars: T.Dict[str, str]) -> str:
+ # Prefer QT_HOST_BINS (qt5, correct for cross and native compiling)
+ # but fall back to QT_INSTALL_BINS (qt4)
+ if 'QT_HOST_BINS' in qvars:
+ return qvars['QT_HOST_BINS']
+ return qvars['QT_INSTALL_BINS']
+
+
+def _get_modules_lib_suffix(version: str, info: 'MachineInfo', is_debug: bool) -> str:
+ """Get the module suffix based on platform and debug type."""
+ suffix = ''
+ if info.is_windows():
+ if is_debug:
+ suffix += 'd'
+ if version.startswith('4'):
+ suffix += '4'
+ if info.is_darwin():
+ if is_debug:
+ suffix += '_debug'
+ if mesonlib.version_compare(version, '>= 5.14.0'):
+ if info.is_android():
+ if info.cpu_family == 'x86':
+ suffix += '_x86'
+ elif info.cpu_family == 'x86_64':
+ suffix += '_x86_64'
+ elif info.cpu_family == 'arm':
+ suffix += '_armeabi-v7a'
+ elif info.cpu_family == 'aarch64':
+ suffix += '_arm64-v8a'
+ else:
+ mlog.warning(f'Android target arch "{info.cpu_family}"" for Qt5 is unknown, '
+ 'module detection may not work')
+ return suffix
+
+
+class QtExtraFrameworkDependency(ExtraFrameworkDependency):
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None):
+ super().__init__(name, env, kwargs, language=language)
+ self.mod_name = name[2:]
+
+ def get_compile_args(self, with_private_headers: bool = False, qt_version: str = "0") -> T.List[str]:
+ if self.found():
+ mod_inc_dir = os.path.join(self.framework_path, 'Headers')
+ args = ['-I' + mod_inc_dir]
+ if with_private_headers:
+ args += ['-I' + dirname for dirname in _qt_get_private_includes(mod_inc_dir, self.mod_name, qt_version)]
+ return args
+ return []
+
+
+class _QtBase:
+
+ """Mixin class for shared components between PkgConfig and Qmake."""
+
+ link_args: T.List[str]
+ clib_compiler: 'Compiler'
+ env: 'Environment'
+
+ def __init__(self, name: str, kwargs: T.Dict[str, T.Any]):
+ self.qtname = name.capitalize()
+ self.qtver = name[-1]
+ if self.qtver == "4":
+ self.qtpkgname = 'Qt'
+ else:
+ self.qtpkgname = self.qtname
+
+ self.private_headers = T.cast(bool, kwargs.get('private_headers', False))
+
+ self.requested_modules = mesonlib.stringlistify(mesonlib.extract_as_list(kwargs, 'modules'))
+ if not self.requested_modules:
+ raise DependencyException('No ' + self.qtname + ' modules specified.')
+
+ self.qtmain = T.cast(bool, kwargs.get('main', False))
+ if not isinstance(self.qtmain, bool):
+ raise DependencyException('"main" argument must be a boolean')
+
+ def _link_with_qtmain(self, is_debug: bool, libdir: T.Union[str, T.List[str]]) -> bool:
+ libdir = mesonlib.listify(libdir) # TODO: shouldn't be necessary
+ base_name = 'qtmaind' if is_debug else 'qtmain'
+ qtmain = self.clib_compiler.find_library(base_name, self.env, libdir)
+ if qtmain:
+ self.link_args.append(qtmain[0])
+ return True
+ return False
+
+ def get_exe_args(self, compiler: 'Compiler') -> T.List[str]:
+ # Originally this was -fPIE but nowadays the default
+ # for upstream and distros seems to be -reduce-relocations
+ # which requires -fPIC. This may cause a performance
+ # penalty when using self-built Qt or on platforms
+ # where -fPIC is not required. If this is an issue
+ # for you, patches are welcome.
+ return compiler.get_pic_args()
+
+ def log_details(self) -> str:
+ return f'modules: {", ".join(sorted(self.requested_modules))}'
+
+
+class QtPkgConfigDependency(_QtBase, PkgConfigDependency, metaclass=abc.ABCMeta):
+
+ """Specialization of the PkgConfigDependency for Qt."""
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ _QtBase.__init__(self, name, kwargs)
+
+ # Always use QtCore as the "main" dependency, since it has the extra
+ # pkg-config variables that a user would expect to get. If "Core" is
+ # not a requested module, delete the compile and link arguments to
+ # avoid linking with something they didn't ask for
+ PkgConfigDependency.__init__(self, self.qtpkgname + 'Core', env, kwargs)
+ if 'Core' not in self.requested_modules:
+ self.compile_args = []
+ self.link_args = []
+
+ for m in self.requested_modules:
+ mod = PkgConfigDependency(self.qtpkgname + m, self.env, kwargs, language=self.language)
+ if not mod.found():
+ self.is_found = False
+ return
+ if self.private_headers:
+ qt_inc_dir = mod.get_pkgconfig_variable('includedir', {})
+ mod_private_dir = os.path.join(qt_inc_dir, 'Qt' + m)
+ if not os.path.isdir(mod_private_dir):
+ # At least some versions of homebrew don't seem to set this
+ # up correctly. /usr/local/opt/qt/include/Qt + m_name is a
+ # symlink to /usr/local/opt/qt/include, but the pkg-config
+ # file points to /usr/local/Cellar/qt/x.y.z/Headers/, and
+ # the Qt + m_name there is not a symlink, it's a file
+ mod_private_dir = qt_inc_dir
+ mod_private_inc = _qt_get_private_includes(mod_private_dir, m, mod.version)
+ for directory in mod_private_inc:
+ mod.compile_args.append('-I' + directory)
+ self._add_sub_dependency([lambda: mod])
+
+ if self.env.machines[self.for_machine].is_windows() and self.qtmain:
+ # Check if we link with debug binaries
+ debug_lib_name = self.qtpkgname + 'Core' + _get_modules_lib_suffix(self.version, self.env.machines[self.for_machine], True)
+ is_debug = False
+ for arg in self.get_link_args():
+ if arg == f'-l{debug_lib_name}' or arg.endswith(f'{debug_lib_name}.lib') or arg.endswith(f'{debug_lib_name}.a'):
+ is_debug = True
+ break
+ libdir = self.get_pkgconfig_variable('libdir', {})
+ if not self._link_with_qtmain(is_debug, libdir):
+ self.is_found = False
+ return
+
+ self.bindir = self.get_pkgconfig_host_bins(self)
+ if not self.bindir:
+ # If exec_prefix is not defined, the pkg-config file is broken
+ prefix = self.get_pkgconfig_variable('exec_prefix', {})
+ if prefix:
+ self.bindir = os.path.join(prefix, 'bin')
+
+ @staticmethod
+ @abc.abstractmethod
+ def get_pkgconfig_host_bins(core: PkgConfigDependency) -> T.Optional[str]:
+ pass
+
+ @abc.abstractmethod
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ pass
+
+ def log_info(self) -> str:
+ return 'pkg-config'
+
+
+class QmakeQtDependency(_QtBase, ConfigToolDependency, metaclass=abc.ABCMeta):
+
+ """Find Qt using Qmake as a config-tool."""
+
+ tool_name = 'qmake'
+ version_arg = '-v'
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
+ _QtBase.__init__(self, name, kwargs)
+ self.tools = [f'qmake-{self.qtname}', 'qmake']
+
+ # Add additional constraints that the Qt version is met, but preserve
+ # any version requrements the user has set as well. For example, if Qt5
+ # is requested, add "">= 5, < 6", but if the user has ">= 5.6", don't
+ # lose that.
+ kwargs = kwargs.copy()
+ _vers = mesonlib.listify(kwargs.get('version', []))
+ _vers.extend([f'>= {self.qtver}', f'< {int(self.qtver) + 1}'])
+ kwargs['version'] = _vers
+
+ ConfigToolDependency.__init__(self, name, env, kwargs)
+ if not self.found():
+ return
+
+ # Query library path, header path, and binary path
+ stdo = self.get_config_value(['-query'], 'args')
+ qvars: T.Dict[str, str] = {}
+ for line in stdo:
+ line = line.strip()
+ if line == '':
+ continue
+ k, v = line.split(':', 1)
+ qvars[k] = v
+ # Qt on macOS uses a framework, but Qt for iOS/tvOS does not
+ xspec = qvars.get('QMAKE_XSPEC', '')
+ if self.env.machines.host.is_darwin() and not any(s in xspec for s in ['ios', 'tvos']):
+ mlog.debug("Building for macOS, looking for framework")
+ self._framework_detect(qvars, self.requested_modules, kwargs)
+ # Sometimes Qt is built not as a framework (for instance, when using conan pkg manager)
+ # skip and fall back to normal procedure then
+ if self.is_found:
+ return
+ else:
+ mlog.debug("Building for macOS, couldn't find framework, falling back to library search")
+ incdir = qvars['QT_INSTALL_HEADERS']
+ self.compile_args.append('-I' + incdir)
+ libdir = qvars['QT_INSTALL_LIBS']
+ # Used by qt.compilers_detect()
+ self.bindir = get_qmake_host_bins(qvars)
+
+ # Use the buildtype by default, but look at the b_vscrt option if the
+ # compiler supports it.
+ is_debug = self.env.coredata.get_option(mesonlib.OptionKey('buildtype')) == 'debug'
+ if mesonlib.OptionKey('b_vscrt') in self.env.coredata.options:
+ if self.env.coredata.options[mesonlib.OptionKey('b_vscrt')].value in {'mdd', 'mtd'}:
+ is_debug = True
+ modules_lib_suffix = _get_modules_lib_suffix(self.version, self.env.machines[self.for_machine], is_debug)
+
+ for module in self.requested_modules:
+ mincdir = os.path.join(incdir, 'Qt' + module)
+ self.compile_args.append('-I' + mincdir)
+
+ if module == 'QuickTest':
+ define_base = 'QMLTEST'
+ elif module == 'Test':
+ define_base = 'TESTLIB'
+ else:
+ define_base = module.upper()
+ self.compile_args.append(f'-DQT_{define_base}_LIB')
+
+ if self.private_headers:
+ priv_inc = self.get_private_includes(mincdir, module)
+ for directory in priv_inc:
+ self.compile_args.append('-I' + directory)
+ libfiles = self.clib_compiler.find_library(
+ self.qtpkgname + module + modules_lib_suffix, self.env,
+ mesonlib.listify(libdir)) # TODO: shouldn't be necissary
+ if libfiles:
+ libfile = libfiles[0]
+ else:
+ mlog.log("Could not find:", module,
+ self.qtpkgname + module + modules_lib_suffix,
+ 'in', libdir)
+ self.is_found = False
+ break
+ self.link_args.append(libfile)
+
+ if self.env.machines[self.for_machine].is_windows() and self.qtmain:
+ if not self._link_with_qtmain(is_debug, libdir):
+ self.is_found = False
+
+ def _sanitize_version(self, version: str) -> str:
+ m = re.search(rf'({self.qtver}(\.\d+)+)', version)
+ if m:
+ return m.group(0).rstrip('.')
+ return version
+
+ @abc.abstractmethod
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ pass
+
+ def _framework_detect(self, qvars: T.Dict[str, str], modules: T.List[str], kwargs: T.Dict[str, T.Any]) -> None:
+ libdir = qvars['QT_INSTALL_LIBS']
+
+ # ExtraFrameworkDependency doesn't support any methods
+ fw_kwargs = kwargs.copy()
+ fw_kwargs.pop('method', None)
+ fw_kwargs['paths'] = [libdir]
+
+ for m in modules:
+ fname = 'Qt' + m
+ mlog.debug('Looking for qt framework ' + fname)
+ fwdep = QtExtraFrameworkDependency(fname, self.env, fw_kwargs, language=self.language)
+ if fwdep.found():
+ self.compile_args.append('-F' + libdir)
+ self.compile_args += fwdep.get_compile_args(with_private_headers=self.private_headers,
+ qt_version=self.version)
+ self.link_args += fwdep.get_link_args()
+ else:
+ self.is_found = False
+ break
+ else:
+ self.is_found = True
+ # Used by self.compilers_detect()
+ self.bindir = get_qmake_host_bins(qvars)
+
+ def log_info(self) -> str:
+ return 'qmake'
+
+
+class Qt4ConfigToolDependency(QmakeQtDependency):
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return []
+
+
+class Qt5ConfigToolDependency(QmakeQtDependency):
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return _qt_get_private_includes(mod_inc_dir, module, self.version)
+
+
+class Qt6ConfigToolDependency(QmakeQtDependency):
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return _qt_get_private_includes(mod_inc_dir, module, self.version)
+
+
+class Qt4PkgConfigDependency(QtPkgConfigDependency):
+
+ @staticmethod
+ def get_pkgconfig_host_bins(core: PkgConfigDependency) -> T.Optional[str]:
+ # Only return one bins dir, because the tools are generally all in one
+ # directory for Qt4, in Qt5, they must all be in one directory. Return
+ # the first one found among the bin variables, in case one tool is not
+ # configured to be built.
+ applications = ['moc', 'uic', 'rcc', 'lupdate', 'lrelease']
+ for application in applications:
+ try:
+ return os.path.dirname(core.get_pkgconfig_variable(f'{application}_location', {}))
+ except mesonlib.MesonException:
+ pass
+ return None
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return []
+
+
+class Qt5PkgConfigDependency(QtPkgConfigDependency):
+
+ @staticmethod
+ def get_pkgconfig_host_bins(core: PkgConfigDependency) -> str:
+ return core.get_pkgconfig_variable('host_bins', {})
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return _qt_get_private_includes(mod_inc_dir, module, self.version)
+
+
+class Qt6PkgConfigDependency(QtPkgConfigDependency):
+
+ @staticmethod
+ def get_pkgconfig_host_bins(core: PkgConfigDependency) -> str:
+ return core.get_pkgconfig_variable('host_bins', {})
+
+ def get_private_includes(self, mod_inc_dir: str, module: str) -> T.List[str]:
+ return _qt_get_private_includes(mod_inc_dir, module, self.version)
+
+
+qt4_factory = DependencyFactory(
+ 'qt4',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ pkgconfig_class=Qt4PkgConfigDependency,
+ configtool_class=Qt4ConfigToolDependency,
+)
+
+qt5_factory = DependencyFactory(
+ 'qt5',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ pkgconfig_class=Qt5PkgConfigDependency,
+ configtool_class=Qt5ConfigToolDependency,
+)
+
+qt6_factory = DependencyFactory(
+ 'qt6',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL],
+ pkgconfig_class=Qt6PkgConfigDependency,
+ configtool_class=Qt6ConfigToolDependency,
+)
diff -Nru meson-0.53.2/mesonbuild/dependencies/scalapack.py meson-0.61.2/mesonbuild/dependencies/scalapack.py
--- meson-0.53.2/mesonbuild/dependencies/scalapack.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/scalapack.py 2021-08-18 11:22:15.000000000 +0000
@@ -1,4 +1,4 @@
-# Copyright 2013-2019 The Meson development team
+# Copyright 2013-2020 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.
@@ -13,108 +13,141 @@
# limitations under the License.
from pathlib import Path
+import functools
import os
+import typing as T
-from .. import mesonlib
-from .base import CMakeDependency, DependencyMethods, ExternalDependency, PkgConfigDependency
+from .base import DependencyMethods
+from .base import DependencyException
+from .cmake import CMakeDependency
+from .pkgconfig import PkgConfigDependency
+from .factory import factory_methods
+if T.TYPE_CHECKING:
+ from ..environment import Environment, MachineChoice
+ from .factory import DependencyGenerator
-class ScalapackDependency(ExternalDependency):
- def __init__(self, environment, kwargs: dict):
- super().__init__('scalapack', environment, None, kwargs)
- kwargs['required'] = False
- kwargs['silent'] = True
- self.is_found = False
- self.static = kwargs.get('static', False)
- methods = mesonlib.listify(self.methods)
-
- if set([DependencyMethods.AUTO, DependencyMethods.PKGCONFIG]).intersection(methods):
- pkgconfig_files = []
- mklroot = None
- is_gcc = self.clib_compiler.get_id() == 'gcc'
- # Intel MKL works with non-Intel compilers too -- but not gcc on windows
- if 'MKLROOT' in os.environ and not (mesonlib.is_windows() and is_gcc):
+
+@factory_methods({DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE})
+def scalapack_factory(env: 'Environment', for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any],
+ methods: T.List[DependencyMethods]) -> T.List['DependencyGenerator']:
+ candidates: T.List['DependencyGenerator'] = []
+
+ if DependencyMethods.PKGCONFIG in methods:
+ mkl = 'mkl-static-lp64-iomp' if kwargs.get('static', False) else 'mkl-dynamic-lp64-iomp'
+ candidates.append(functools.partial(
+ MKLPkgConfigDependency, mkl, env, kwargs))
+
+ for pkg in ['scalapack-openmpi', 'scalapack']:
+ candidates.append(functools.partial(
+ PkgConfigDependency, pkg, env, kwargs))
+
+ if DependencyMethods.CMAKE in methods:
+ candidates.append(functools.partial(
+ CMakeDependency, 'Scalapack', env, kwargs))
+
+ return candidates
+
+
+class MKLPkgConfigDependency(PkgConfigDependency):
+
+ """PkgConfigDependency for Intel MKL.
+
+ MKL's pkg-config is pretty much borked in every way. We need to apply a
+ bunch of fixups to make it work correctly.
+ """
+
+ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ language: T.Optional[str] = None):
+ _m = os.environ.get('MKLROOT')
+ self.__mklroot = Path(_m).resolve() if _m else None
+
+ # We need to call down into the normal super() method even if we don't
+ # find mklroot, otherwise we won't have all of the instance variables
+ # initialized that meson expects.
+ super().__init__(name, env, kwargs, language=language)
+
+ # Doesn't work with gcc on windows, but does on Linux
+ if (not self.__mklroot or (env.machines[self.for_machine].is_windows()
+ and self.clib_compiler.id == 'gcc')):
+ self.is_found = False
+
+ # This can happen either because we're using GCC, we couldn't find the
+ # mklroot, or the pkg-config couldn't find it.
+ if not self.is_found:
+ return
+
+ assert self.version != '', 'This should not happen if we didn\'t return above'
+
+ if self.version == 'unknown':
+ # At least by 2020 the version is in the pkg-config, just not with
+ # the correct name
+ v = self.get_variable(pkgconfig='Version', default_value='')
+
+ if not v and self.__mklroot:
try:
- mklroot = Path(os.environ['MKLROOT']).resolve()
- except Exception:
+ v = (
+ self.__mklroot.as_posix()
+ .split('compilers_and_libraries_')[1]
+ .split('/', 1)[0]
+ )
+ except IndexError:
pass
- if mklroot is not None:
- # MKL pkg-config is a start, but you have to add / change stuff
- # https://software.intel.com/en-us/articles/intel-math-kernel-library-intel-mkl-and-pkg-config-tool
- pkgconfig_files = (
- ['mkl-static-lp64-iomp'] if self.static else ['mkl-dynamic-lp64-iomp']
- )
- if mesonlib.is_windows():
- suffix = '.lib'
- elif self.static:
- suffix = '.a'
- else:
- suffix = ''
- libdir = mklroot / 'lib/intel64'
- # Intel compiler might not have Parallel Suite
- pkgconfig_files += ['scalapack-openmpi', 'scalapack']
-
- for pkg in pkgconfig_files:
- pkgdep = PkgConfigDependency(
- pkg, environment, kwargs, language=self.language
- )
- if pkgdep.found():
- self.compile_args = pkgdep.get_compile_args()
- if mklroot:
- link_args = pkgdep.get_link_args()
- if is_gcc:
- for i, a in enumerate(link_args):
- if 'mkl_intel_lp64' in a:
- link_args[i] = a.replace('intel', 'gf')
- break
- # MKL pkg-config omits scalapack
- # be sure "-L" and "-Wl" are first if present
- i = 0
- for j, a in enumerate(link_args):
- if a.startswith(('-L', '-Wl')):
- i = j + 1
- elif j > 3:
- break
- if mesonlib.is_windows() or self.static:
- link_args.insert(
- i, str(libdir / ('mkl_scalapack_lp64' + suffix))
- )
- link_args.insert(
- i + 1, str(libdir / ('mkl_blacs_intelmpi_lp64' + suffix))
- )
- else:
- link_args.insert(i, '-lmkl_scalapack_lp64')
- link_args.insert(i + 1, '-lmkl_blacs_intelmpi_lp64')
- else:
- link_args = pkgdep.get_link_args()
- self.link_args = link_args
-
- self.version = pkgdep.get_version()
- if self.version == 'unknown' and mklroot:
- try:
- v = (
- mklroot.as_posix()
- .split('compilers_and_libraries_')[1]
- .split('/', 1)[0]
- )
- if v:
- self.version = v
- except IndexError:
- pass
-
- self.is_found = True
- self.pcdep = pkgdep
- return
-
- if set([DependencyMethods.AUTO, DependencyMethods.CMAKE]).intersection(methods):
- cmakedep = CMakeDependency('Scalapack', environment, kwargs, language=self.language)
- if cmakedep.found():
- self.compile_args = cmakedep.get_compile_args()
- self.link_args = cmakedep.get_link_args()
- self.version = cmakedep.get_version()
- self.is_found = True
- return
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.AUTO, DependencyMethods.PKGCONFIG, DependencyMethods.CMAKE]
+
+ if v:
+ assert isinstance(v, str)
+ self.version = v
+
+ def _set_libs(self) -> None:
+ super()._set_libs()
+
+ if self.env.machines[self.for_machine].is_windows():
+ suffix = '.lib'
+ elif self.static:
+ suffix = '.a'
+ else:
+ suffix = ''
+ libdir = self.__mklroot / 'lib/intel64'
+
+ if self.clib_compiler.id == 'gcc':
+ for i, a in enumerate(self.link_args):
+ # only replace in filename, not in directory names
+ dirname, basename = os.path.split(a)
+ if 'mkl_intel_lp64' in basename:
+ basename = basename.replace('intel', 'gf')
+ self.link_args[i] = '/' + os.path.join(dirname, basename)
+ # MKL pkg-config omits scalapack
+ # be sure "-L" and "-Wl" are first if present
+ i = 0
+ for j, a in enumerate(self.link_args):
+ if a.startswith(('-L', '-Wl')):
+ i = j + 1
+ elif j > 3:
+ break
+ if self.env.machines[self.for_machine].is_windows() or self.static:
+ self.link_args.insert(
+ i, str(libdir / ('mkl_scalapack_lp64' + suffix))
+ )
+ self.link_args.insert(
+ i + 1, str(libdir / ('mkl_blacs_intelmpi_lp64' + suffix))
+ )
+ else:
+ self.link_args.insert(i, '-lmkl_scalapack_lp64')
+ self.link_args.insert(i + 1, '-lmkl_blacs_intelmpi_lp64')
+
+ def _set_cargs(self) -> None:
+ env = None
+ if self.language == 'fortran':
+ # gfortran doesn't appear to look in system paths for INCLUDE files,
+ # so don't allow pkg-config to suppress -I flags for system paths
+ env = os.environ.copy()
+ env['PKG_CONFIG_ALLOW_SYSTEM_CFLAGS'] = '1'
+ ret, out, err = self._call_pkgbin([
+ '--cflags', self.name,
+ '--define-variable=prefix=' + self.__mklroot.as_posix()],
+ env=env)
+ if ret != 0:
+ raise DependencyException('Could not generate cargs for %s:\n%s\n' %
+ (self.name, err))
+ self.compile_args = self._convert_mingw_paths(self._split_args(out))
diff -Nru meson-0.53.2/mesonbuild/dependencies/ui.py meson-0.61.2/mesonbuild/dependencies/ui.py
--- meson-0.53.2/mesonbuild/dependencies/ui.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/dependencies/ui.py 2021-11-02 19:58:07.000000000 +0000
@@ -14,28 +14,28 @@
# This file contains the detection logic for external dependencies that
# are UI-related.
-import functools
import os
-import re
import subprocess
-from collections import OrderedDict
+import typing as T
from .. import mlog
from .. import mesonlib
from ..mesonlib import (
- MesonException, Popen_safe, extract_as_list, version_compare_many
+ Popen_safe, extract_as_list, version_compare_many
)
from ..environment import detect_cpu_family
-from .base import DependencyException, DependencyMethods
-from .base import ExternalDependency, ExternalProgram, NonExistingExternalProgram
-from .base import ExtraFrameworkDependency, PkgConfigDependency
-from .base import ConfigToolDependency
+from .base import DependencyException, DependencyMethods, DependencyTypeName, SystemDependency
+from .configtool import ConfigToolDependency
+from .factory import DependencyFactory
+if T.TYPE_CHECKING:
+ from ..environment import Environment
-class GLDependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('gl', environment, None, kwargs)
+
+class GLDependencySystem(SystemDependency):
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__(name, environment, kwargs)
if self.env.machines[self.for_machine].is_darwin():
self.is_found = True
@@ -50,27 +50,7 @@
# FIXME: Detect version using self.clib_compiler
return
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'gl', environment, kwargs))
-
- if DependencyMethods.SYSTEM in methods:
- candidates.append(functools.partial(GLDependency, environment, kwargs))
-
- return candidates
-
- @staticmethod
- def get_methods():
- if mesonlib.is_osx() or mesonlib.is_windows():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM]
- else:
- return [DependencyMethods.PKGCONFIG]
-
- def log_tried(self):
+ def log_tried(self) -> str:
return 'system'
class GnuStepDependency(ConfigToolDependency):
@@ -78,8 +58,8 @@
tools = ['gnustep-config']
tool_name = 'gnustep-config'
- def __init__(self, environment, kwargs):
- super().__init__('gnustep', environment, 'objc', kwargs)
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]) -> None:
+ super().__init__('gnustep', environment, kwargs, language='objc')
if not self.is_found:
return
self.modules = kwargs.get('modules', [])
@@ -89,13 +69,13 @@
['--gui-libs' if 'gui' in self.modules else '--base-libs'],
'link_args'))
- def find_config(self, versions=None):
+ def find_config(self, versions: T.Optional[T.List[str]] = None, returncode: int = 0) -> T.Tuple[T.Optional[T.List[str]], T.Optional[str]]:
tool = [self.tools[0]]
try:
p, out = Popen_safe(tool + ['--help'])[:2]
except (FileNotFoundError, PermissionError):
return (None, None)
- if p.returncode != 0:
+ if p.returncode != returncode:
return (None, None)
self.config = tool
found_version = self.detect_version()
@@ -104,14 +84,16 @@
return (tool, found_version)
- def weird_filter(self, elems):
+ @staticmethod
+ def weird_filter(elems: T.List[str]) -> T.List[str]:
"""When building packages, the output of the enclosing Make is
sometimes mixed among the subprocess output. I have no idea why. As a
hack filter out everything that is not a flag.
"""
return [e for e in elems if e.startswith('-')]
- def filter_args(self, args):
+ @staticmethod
+ def filter_args(args: T.List[str]) -> T.List[str]:
"""gnustep-config returns a bunch of garbage args such as -O2 and so
on. Drop everything that is not needed.
"""
@@ -125,7 +107,7 @@
result.append(f)
return result
- def detect_version(self):
+ def detect_version(self) -> str:
gmake = self.get_config_value(['--variable=GNUMAKE'], 'variable')[0]
makefile_dir = self.get_config_value(['--variable=GNUSTEP_MAKEFILES'], 'variable')[0]
# This Makefile has the GNUStep version set
@@ -148,421 +130,17 @@
return version
-def _qt_get_private_includes(mod_inc_dir, module, mod_version):
- # usually Qt5 puts private headers in /QT_INSTALL_HEADERS/module/VERSION/module/private
- # except for at least QtWebkit and Enginio where the module version doesn't match Qt version
- # as an example with Qt 5.10.1 on linux you would get:
- # /usr/include/qt5/QtCore/5.10.1/QtCore/private/
- # /usr/include/qt5/QtWidgets/5.10.1/QtWidgets/private/
- # /usr/include/qt5/QtWebKit/5.212.0/QtWebKit/private/
-
- # on Qt4 when available private folder is directly in module folder
- # like /usr/include/QtCore/private/
- if int(mod_version.split('.')[0]) < 5:
- return tuple()
-
- private_dir = os.path.join(mod_inc_dir, mod_version)
- # fallback, let's try to find a directory with the latest version
- if not os.path.exists(private_dir):
- dirs = [filename for filename in os.listdir(mod_inc_dir)
- if os.path.isdir(os.path.join(mod_inc_dir, filename))]
- dirs.sort(reverse=True)
-
- for dirname in dirs:
- if len(dirname.split('.')) == 3:
- private_dir = dirname
- break
- return (private_dir,
- os.path.join(private_dir, 'Qt' + module))
-
-class QtExtraFrameworkDependency(ExtraFrameworkDependency):
- def __init__(self, name, required, paths, env, lang, kwargs):
- super().__init__(name, required, paths, env, lang, kwargs)
- self.mod_name = name[2:]
-
- def get_compile_args(self, with_private_headers=False, qt_version="0"):
- if self.found():
- mod_inc_dir = os.path.join(self.framework_path, 'Headers')
- args = ['-I' + mod_inc_dir]
- if with_private_headers:
- args += ['-I' + dirname for dirname in _qt_get_private_includes(mod_inc_dir, self.mod_name, qt_version)]
- return args
- return []
-
-class QtBaseDependency(ExternalDependency):
- def __init__(self, name, env, kwargs):
- super().__init__(name, env, 'cpp', kwargs)
- self.qtname = name.capitalize()
- self.qtver = name[-1]
- if self.qtver == "4":
- self.qtpkgname = 'Qt'
- else:
- self.qtpkgname = self.qtname
- self.root = '/usr'
- self.bindir = None
- self.private_headers = kwargs.get('private_headers', False)
- mods = extract_as_list(kwargs, 'modules')
- self.requested_modules = mods
- if not mods:
- raise DependencyException('No ' + self.qtname + ' modules specified.')
- self.from_text = 'pkg-config'
-
- self.qtmain = kwargs.get('main', False)
- if not isinstance(self.qtmain, bool):
- raise DependencyException('"main" argument must be a boolean')
-
- # Keep track of the detection methods used, for logging purposes.
- methods = []
- # Prefer pkg-config, then fallback to `qmake -query`
- if DependencyMethods.PKGCONFIG in self.methods:
- mlog.debug('Trying to find qt with pkg-config')
- self._pkgconfig_detect(mods, kwargs)
- methods.append('pkgconfig')
- if not self.is_found and DependencyMethods.QMAKE in self.methods:
- mlog.debug('Trying to find qt with qmake')
- self.from_text = self._qmake_detect(mods, kwargs)
- methods.append('qmake-' + self.name)
- methods.append('qmake')
- if not self.is_found:
- # Reset compile args and link args
- self.compile_args = []
- self.link_args = []
- self.from_text = mlog.format_list(methods)
- self.version = None
-
- def compilers_detect(self, interp_obj):
- "Detect Qt (4 or 5) moc, uic, rcc in the specified bindir or in PATH"
- # It is important that this list does not change order as the order of
- # the returned ExternalPrograms will change as well
- bins = ['moc', 'uic', 'rcc', 'lrelease']
- found = {b: NonExistingExternalProgram(name='{}-{}'.format(b, self.name))
- for b in bins}
-
- def gen_bins():
- for b in bins:
- if self.bindir:
- yield os.path.join(self.bindir, b), b, False
- yield '{}-{}'.format(b, self.name), b, False
- yield b, b, self.required if b != 'lrelease' else False
-
- for b, name, required in gen_bins():
- if found[name].found():
- continue
-
- # prefer the -qt of the tool to the plain one, as we
- # don't know what the unsuffixed one points to without calling it.
- p = interp_obj.find_program_impl([b], silent=True, required=required).held_object
- if not p.found():
- continue
-
- if name == 'lrelease':
- arg = ['-version']
- elif mesonlib.version_compare(self.version, '>= 5'):
- arg = ['--version']
- else:
- arg = ['-v']
-
- # Ensure that the version of qt and each tool are the same
- _, out, err = mesonlib.Popen_safe(p.get_command() + arg)
- if b.startswith('lrelease') or not self.version.startswith('4'):
- care = out
- else:
- care = err
- if mesonlib.version_compare(self.version, '== {}'.format(care.split(' ')[-1])):
- found[name] = p
-
- return tuple([found[b] for b in bins])
-
- def _pkgconfig_detect(self, mods, kwargs):
- # We set the value of required to False so that we can try the
- # qmake-based fallback if pkg-config fails.
- kwargs['required'] = False
- modules = OrderedDict()
- for module in mods:
- modules[module] = PkgConfigDependency(self.qtpkgname + module, self.env,
- kwargs, language=self.language)
- for m_name, m in modules.items():
- if not m.found():
- self.is_found = False
- return
- self.compile_args += m.get_compile_args()
- if self.private_headers:
- qt_inc_dir = m.get_pkgconfig_variable('includedir', dict())
- mod_private_dir = os.path.join(qt_inc_dir, 'Qt' + m_name)
- if not os.path.isdir(mod_private_dir):
- # At least some versions of homebrew don't seem to set this
- # up correctly. /usr/local/opt/qt/include/Qt + m_name is a
- # symlink to /usr/local/opt/qt/include, but the pkg-config
- # file points to /usr/local/Cellar/qt/x.y.z/Headers/, and
- # the Qt + m_name there is not a symlink, it's a file
- mod_private_dir = qt_inc_dir
- mod_private_inc = _qt_get_private_includes(mod_private_dir, m_name, m.version)
- for directory in mod_private_inc:
- self.compile_args.append('-I' + directory)
- self.link_args += m.get_link_args()
+class SDL2DependencyConfigTool(ConfigToolDependency):
- if 'Core' in modules:
- core = modules['Core']
- else:
- corekwargs = {'required': 'false', 'silent': 'true'}
- core = PkgConfigDependency(self.qtpkgname + 'Core', self.env, corekwargs,
- language=self.language)
- modules['Core'] = core
-
- if self.env.machines[self.for_machine].is_windows() and self.qtmain:
- # Check if we link with debug binaries
- debug_lib_name = self.qtpkgname + 'Core' + self._get_modules_lib_suffix(True)
- is_debug = False
- for arg in core.get_link_args():
- if arg == '-l%s' % debug_lib_name or arg.endswith('%s.lib' % debug_lib_name) or arg.endswith('%s.a' % debug_lib_name):
- is_debug = True
- break
- libdir = core.get_pkgconfig_variable('libdir', {})
- if not self._link_with_qtmain(is_debug, libdir):
- self.is_found = False
- return
+ tools = ['sdl2-config']
+ tool_name = 'sdl2-config'
- self.is_found = True
- self.version = m.version
- self.pcdep = list(modules.values())
- # Try to detect moc, uic, rcc
- # Used by self.compilers_detect()
- self.bindir = self.get_pkgconfig_host_bins(core)
- if not self.bindir:
- # If exec_prefix is not defined, the pkg-config file is broken
- prefix = core.get_pkgconfig_variable('exec_prefix', {})
- if prefix:
- self.bindir = os.path.join(prefix, 'bin')
-
- def _qmake_detect(self, mods, kwargs):
- for qmake in ('qmake-' + self.name, 'qmake'):
- self.qmake = ExternalProgram.from_bin_list(
- self.env.binaries.host, qmake)
- if not self.qmake.found():
- # Even when cross-compiling, if a cross-info qmake is not
- # specified, we fallback to using the qmake in PATH because
- # that's what we used to do
- self.qmake = ExternalProgram.from_bin_list(
- self.env.binaries.build, qmake)
- if not self.qmake.found():
- self.qmake = ExternalProgram(qmake, silent=True)
- if not self.qmake.found():
- continue
- # Check that the qmake is for qt5
- pc, stdo = Popen_safe(self.qmake.get_command() + ['-v'])[0:2]
- if pc.returncode != 0:
- continue
- if not 'Qt version ' + self.qtver in stdo:
- mlog.log('QMake is not for ' + self.qtname)
- continue
- # Found qmake for Qt5!
- break
- else:
- # Didn't find qmake :(
- self.is_found = False
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__(name, environment, kwargs)
+ if not self.is_found:
return
- self.version = re.search(self.qtver + r'(\.\d+)+', stdo).group(0)
- # Query library path, header path, and binary path
- mlog.log("Found qmake:", mlog.bold(self.qmake.get_path()), '(%s)' % self.version)
- stdo = Popen_safe(self.qmake.get_command() + ['-query'])[1]
- qvars = {}
- for line in stdo.split('\n'):
- line = line.strip()
- if line == '':
- continue
- (k, v) = tuple(line.split(':', 1))
- qvars[k] = v
- # Qt on macOS uses a framework, but Qt for iOS/tvOS does not
- xspec = qvars.get('QMAKE_XSPEC', '')
- if self.env.machines.host.is_darwin() and not any(s in xspec for s in ['ios', 'tvos']):
- mlog.debug("Building for macOS, looking for framework")
- self._framework_detect(qvars, mods, kwargs)
- return qmake
- incdir = qvars['QT_INSTALL_HEADERS']
- self.compile_args.append('-I' + incdir)
- libdir = qvars['QT_INSTALL_LIBS']
- # Used by self.compilers_detect()
- self.bindir = self.get_qmake_host_bins(qvars)
- self.is_found = True
-
- is_debug = self.env.coredata.get_builtin_option('buildtype') == 'debug'
- modules_lib_suffix = self._get_modules_lib_suffix(is_debug)
-
- for module in mods:
- mincdir = os.path.join(incdir, 'Qt' + module)
- self.compile_args.append('-I' + mincdir)
-
- if module == 'QuickTest':
- define_base = 'QMLTEST'
- elif module == 'Test':
- define_base = 'TESTLIB'
- else:
- define_base = module.upper()
- self.compile_args.append('-DQT_%s_LIB' % define_base)
-
- if self.private_headers:
- priv_inc = self.get_private_includes(mincdir, module)
- for directory in priv_inc:
- self.compile_args.append('-I' + directory)
- libfile = self.clib_compiler.find_library(self.qtpkgname + module + modules_lib_suffix,
- self.env,
- libdir)
- if libfile:
- libfile = libfile[0]
- else:
- self.is_found = False
- break
- self.link_args.append(libfile)
-
- if self.env.machines[self.for_machine].is_windows() and self.qtmain:
- if not self._link_with_qtmain(is_debug, libdir):
- self.is_found = False
-
- return qmake
-
- def _get_modules_lib_suffix(self, is_debug):
- suffix = ''
- if self.env.machines[self.for_machine].is_windows():
- if is_debug:
- suffix += 'd'
- if self.qtver == '4':
- suffix += '4'
- return suffix
-
- def _link_with_qtmain(self, is_debug, libdir):
- base_name = 'qtmaind' if is_debug else 'qtmain'
- qtmain = self.clib_compiler.find_library(base_name, self.env, libdir)
- if qtmain:
- self.link_args.append(qtmain[0])
- return True
- return False
-
- def _framework_detect(self, qvars, modules, kwargs):
- libdir = qvars['QT_INSTALL_LIBS']
-
- # 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)
- fwdep = QtExtraFrameworkDependency(fname, False, [libdir], self.env,
- self.language, fw_kwargs)
- self.compile_args.append('-F' + libdir)
- if fwdep.found():
- self.compile_args += fwdep.get_compile_args(with_private_headers=self.private_headers,
- qt_version=self.version)
- self.link_args += fwdep.get_link_args()
- else:
- break
- else:
- self.is_found = True
- # Used by self.compilers_detect()
- self.bindir = self.get_qmake_host_bins(qvars)
-
- def get_qmake_host_bins(self, qvars):
- # Prefer QT_HOST_BINS (qt5, correct for cross and native compiling)
- # but fall back to QT_INSTALL_BINS (qt4)
- if 'QT_HOST_BINS' in qvars:
- return qvars['QT_HOST_BINS']
- else:
- return qvars['QT_INSTALL_BINS']
-
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.QMAKE]
-
- def get_exe_args(self, compiler):
- # Originally this was -fPIE but nowadays the default
- # for upstream and distros seems to be -reduce-relocations
- # which requires -fPIC. This may cause a performance
- # penalty when using self-built Qt or on platforms
- # where -fPIC is not required. If this is an issue
- # for you, patches are welcome.
- return compiler.get_pic_args()
-
- def get_private_includes(self, mod_inc_dir, module):
- return tuple()
-
- def log_details(self):
- module_str = ', '.join(self.requested_modules)
- return 'modules: ' + module_str
-
- def log_info(self):
- return '{}'.format(self.from_text)
-
- def log_tried(self):
- return self.from_text
-
-
-class Qt4Dependency(QtBaseDependency):
- def __init__(self, env, kwargs):
- QtBaseDependency.__init__(self, 'qt4', env, kwargs)
-
- def get_pkgconfig_host_bins(self, core):
- # Only return one bins dir, because the tools are generally all in one
- # directory for Qt4, in Qt5, they must all be in one directory. Return
- # the first one found among the bin variables, in case one tool is not
- # configured to be built.
- applications = ['moc', 'uic', 'rcc', 'lupdate', 'lrelease']
- for application in applications:
- try:
- return os.path.dirname(core.get_pkgconfig_variable('%s_location' % application, {}))
- except MesonException:
- pass
-
-
-class Qt5Dependency(QtBaseDependency):
- def __init__(self, env, kwargs):
- QtBaseDependency.__init__(self, 'qt5', env, kwargs)
-
- def get_pkgconfig_host_bins(self, core):
- return core.get_pkgconfig_variable('host_bins', {})
-
- def get_private_includes(self, mod_inc_dir, module):
- return _qt_get_private_includes(mod_inc_dir, module, self.version)
-
-
-# There are three different ways of depending on SDL2:
-# sdl2-config, pkg-config and OSX framework
-class SDL2Dependency(ExternalDependency):
- def __init__(self, environment, kwargs):
- super().__init__('sdl2', environment, None, kwargs)
-
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'sdl2', environment, kwargs))
-
- if DependencyMethods.CONFIG_TOOL in methods:
- candidates.append(functools.partial(ConfigToolDependency.factory,
- 'sdl2', environment, None,
- kwargs, ['sdl2-config'],
- 'sdl2-config', SDL2Dependency.tool_finish_init))
-
- if DependencyMethods.EXTRAFRAMEWORK in methods:
- if mesonlib.is_osx():
- candidates.append(functools.partial(ExtraFrameworkDependency,
- 'sdl2', False, None, environment,
- kwargs.get('language', None), kwargs))
- # fwdep.version = '2' # FIXME
- return candidates
-
- @staticmethod
- def tool_finish_init(ctdep):
- ctdep.compile_args = ctdep.get_config_value(['--cflags'], 'compile_args')
- ctdep.link_args = ctdep.get_config_value(['--libs'], 'link_args')
-
- @staticmethod
- def get_methods():
- if mesonlib.is_osx():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK]
- else:
- return [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL]
+ self.compile_args = self.get_config_value(['--cflags'], 'compile_args')
+ self.link_args = self.get_config_value(['--libs'], 'link_args')
class WxDependency(ConfigToolDependency):
@@ -570,17 +148,30 @@
tools = ['wx-config-3.0', 'wx-config', 'wx-config-gtk3']
tool_name = 'wx-config'
- def __init__(self, environment, kwargs):
- super().__init__('WxWidgets', environment, None, kwargs)
+ def __init__(self, environment: 'Environment', kwargs: T.Dict[str, T.Any]):
+ super().__init__('WxWidgets', environment, kwargs, language='cpp')
if not self.is_found:
return
self.requested_modules = self.get_requested(kwargs)
+
+ extra_args = []
+ if self.static:
+ extra_args.append('--static=yes')
+
+ # Check to make sure static is going to work
+ err = Popen_safe(self.config + extra_args)[2]
+ if 'No config found to match' in err:
+ mlog.debug('WxWidgets is missing static libraries.')
+ self.is_found = False
+ return
+
# wx-config seems to have a cflags as well but since it requires C++,
# this should be good, at least for now.
- self.compile_args = self.get_config_value(['--cxxflags'] + self.requested_modules, 'compile_args')
- self.link_args = self.get_config_value(['--libs'] + self.requested_modules, 'link_args')
+ self.compile_args = self.get_config_value(['--cxxflags'] + extra_args + self.requested_modules, 'compile_args')
+ self.link_args = self.get_config_value(['--libs'] + extra_args + self.requested_modules, 'link_args')
- def get_requested(self, kwargs):
+ @staticmethod
+ def get_requested(kwargs: T.Dict[str, T.Any]) -> T.List[str]:
if 'modules' not in kwargs:
return []
candidates = extract_as_list(kwargs, 'modules')
@@ -590,10 +181,10 @@
return candidates
-class VulkanDependency(ExternalDependency):
+class VulkanDependencySystem(SystemDependency):
- def __init__(self, environment, kwargs):
- super().__init__('vulkan', environment, None, kwargs)
+ def __init__(self, name: str, environment: 'Environment', kwargs: T.Dict[str, T.Any], language: T.Optional[str] = None) -> None:
+ super().__init__(name, environment, kwargs, language=language)
try:
self.vulkan_sdk = os.environ['VULKAN_SDK']
@@ -619,7 +210,7 @@
inc_path = os.path.join(self.vulkan_sdk, inc_dir)
header = os.path.join(inc_path, 'vulkan', 'vulkan.h')
lib_path = os.path.join(self.vulkan_sdk, lib_dir)
- find_lib = self.clib_compiler.find_library(lib_name, environment, lib_path)
+ find_lib = self.clib_compiler.find_library(lib_name, environment, [lib_path])
if not find_lib:
raise DependencyException('VULKAN_SDK point to invalid directory (no lib)')
@@ -627,7 +218,8 @@
if not os.path.isfile(header):
raise DependencyException('VULKAN_SDK point to invalid directory (no include)')
- self.type_name = 'vulkan_sdk'
+ # XXX: this is very odd, and may deserve being removed
+ self.type_name = DependencyTypeName('vulkan_sdk')
self.is_found = True
self.compile_args.append('-I' + inc_path)
self.link_args.append('-L' + lib_path)
@@ -640,28 +232,28 @@
# simply try to guess it, usually works on linux
libs = self.clib_compiler.find_library('vulkan', environment, [])
if libs is not None and self.clib_compiler.has_header('vulkan/vulkan.h', '', environment, disable_cache=True)[0]:
- self.type_name = 'system'
self.is_found = True
for lib in libs:
self.link_args.append(lib)
return
- @classmethod
- def _factory(cls, environment, kwargs):
- methods = cls._process_method_kw(kwargs)
- candidates = []
-
- if DependencyMethods.PKGCONFIG in methods:
- candidates.append(functools.partial(PkgConfigDependency, 'vulkan', environment, kwargs))
-
- if DependencyMethods.SYSTEM in methods:
- candidates.append(functools.partial(VulkanDependency, environment, kwargs))
+ def log_tried(self) -> str:
+ return 'system'
- return candidates
+gl_factory = DependencyFactory(
+ 'gl',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
+ system_class=GLDependencySystem,
+)
- @staticmethod
- def get_methods():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM]
+sdl2_factory = DependencyFactory(
+ 'sdl2',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.CONFIG_TOOL, DependencyMethods.EXTRAFRAMEWORK],
+ configtool_class=SDL2DependencyConfigTool,
+)
- def log_tried(self):
- return 'system'
+vulkan_factory = DependencyFactory(
+ 'vulkan',
+ [DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM],
+ system_class=VulkanDependencySystem,
+)
diff -Nru meson-0.53.2/mesonbuild/depfile.py meson-0.61.2/mesonbuild/depfile.py
--- meson-0.53.2/mesonbuild/depfile.py 2019-10-06 17:01:35.000000000 +0000
+++ meson-0.61.2/mesonbuild/depfile.py 2022-01-17 10:50:45.000000000 +0000
@@ -82,4 +82,4 @@
deps.update(target.deps)
for dep in target.deps:
deps.update(self.get_all_dependencies(dep, visited))
- return deps
+ return sorted(deps)
diff -Nru meson-0.53.2/mesonbuild/envconfig.py meson-0.61.2/mesonbuild/envconfig.py
--- meson-0.53.2/mesonbuild/envconfig.py 2020-01-23 22:34:28.000000000 +0000
+++ meson-0.61.2/mesonbuild/envconfig.py 2022-01-17 10:50:45.000000000 +0000
@@ -12,14 +12,14 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import configparser, os, subprocess
+import subprocess
import typing as T
+from enum import Enum
from . import mesonlib
-from .mesonlib import EnvironmentException, split_args
+from .mesonlib import EnvironmentException, HoldableObject
from . import mlog
-
-_T = T.TypeVar('_T')
+from pathlib import Path
# These classes contains all the data pulled from configuration files (native
@@ -40,13 +40,20 @@
'alpha',
'arc',
'arm',
+ 'avr',
+ 'c2000',
+ 'csky',
+ 'dspic',
'e2k',
+ 'ft32',
'ia64',
+ 'loongarch64',
'm68k',
'microblaze',
'mips',
'mips64',
'parisc',
+ 'pic24',
'ppc',
'ppc64',
'riscv32',
@@ -55,20 +62,22 @@
'rx',
's390',
's390x',
+ 'sh4',
'sparc',
'sparc64',
'wasm32',
'wasm64',
'x86',
- 'x86_64'
+ 'x86_64',
)
-# It would feel more natural to call this "64_BIT_CPU_FAMILES", but
+# It would feel more natural to call this "64_BIT_CPU_FAMILIES", but
# python identifiers cannot start with numbers
-CPU_FAMILES_64_BIT = [
+CPU_FAMILIES_64_BIT = [
'aarch64',
'alpha',
'ia64',
+ 'loongarch64',
'mips64',
'ppc64',
'riscv64',
@@ -78,55 +87,61 @@
'x86_64',
]
-class MesonConfigFile:
- @classmethod
- def from_config_parser(cls, parser: configparser.ConfigParser) -> T.Dict[str, T.Dict[str, T.Dict[str, str]]]:
- out = {}
- # This is a bit hackish at the moment.
- for s in parser.sections():
- section = {}
- for entry in parser[s]:
- value = parser[s][entry]
- # Windows paths...
- value = value.replace('\\', '\\\\')
- if ' ' in entry or '\t' in entry or "'" in entry or '"' in entry:
- raise EnvironmentException('Malformed variable name %s in cross file..' % entry)
- try:
- res = eval(value, {'__builtins__': None}, {'true': True, 'false': False})
- except Exception:
- raise EnvironmentException('Malformed value in cross file variable %s.' % entry)
-
- for i in (res if isinstance(res, list) else [res]):
- if not isinstance(i, (str, int, bool)):
- raise EnvironmentException('Malformed value in cross file variable %s.' % entry)
-
- section[entry] = res
-
- out[s] = section
- return out
-
-class HasEnvVarFallback:
- """
- A tiny class to indicate that this class contains data that can be
- initialized from either a config file or environment file. The `fallback`
- field says whether env vars should be used. Downstream logic (e.g. subclass
- methods) can check it to decide what to do, since env vars are currently
- lazily decoded.
-
- Frankly, this is a pretty silly class at the moment. The hope is the way
- that we deal with environment variables will become more structured, and
- this can be starting point.
- """
- def __init__(self, fallback: bool = True):
- self.fallback = fallback
+# Map from language identifiers to environment variables.
+ENV_VAR_PROG_MAP: T.Mapping[str, str] = {
+ # Compilers
+ 'c': 'CC',
+ 'cpp': 'CXX',
+ 'cs': 'CSC',
+ 'd': 'DC',
+ 'fortran': 'FC',
+ 'objc': 'OBJC',
+ 'objcpp': 'OBJCXX',
+ 'rust': 'RUSTC',
+ 'vala': 'VALAC',
+
+ # Linkers
+ 'c_ld': 'CC_LD',
+ 'cpp_ld': 'CXX_LD',
+ 'd_ld': 'DC_LD',
+ 'fortran_ld': 'FC_LD',
+ 'objc_ld': 'OBJC_LD',
+ 'objcpp_ld': 'OBJCXX_LD',
+ 'rust_ld': 'RUSTC_LD',
+
+ # Binutils
+ 'strip': 'STRIP',
+ 'ar': 'AR',
+ 'windres': 'WINDRES',
+
+ # Other tools
+ 'cmake': 'CMAKE',
+ 'qmake': 'QMAKE',
+ 'pkgconfig': 'PKG_CONFIG',
+ 'make': 'MAKE',
+ 'vapigen': 'VAPIGEN',
+}
+
+# Deprecated environment variables mapped from the new variable to the old one
+# Deprecated in 0.54.0
+DEPRECATED_ENV_PROG_MAP: T.Mapping[str, str] = {
+ 'd_ld': 'D_LD',
+ 'fortran_ld': 'F_LD',
+ 'rust_ld': 'RUST_LD',
+ 'objcpp_ld': 'OBJCPP_LD',
+}
+
+class CMakeSkipCompilerTest(Enum):
+ ALWAYS = 'always'
+ NEVER = 'never'
+ DEP_ONLY = 'dep_only'
-class Properties(HasEnvVarFallback):
+class Properties:
def __init__(
self,
- properties: T.Optional[T.Dict[str, T.Union[str, T.List[str]]]] = None,
- fallback: bool = True):
- super().__init__(fallback)
- self.properties = properties or {} # type: T.Dict[str, T.Union[str, T.List[str]]]
+ properties: T.Optional[T.Dict[str, T.Optional[T.Union[str, bool, int, T.List[str]]]]] = None,
+ ):
+ self.properties = properties or {} # type: T.Dict[str, T.Optional[T.Union[str, bool, int, T.List[str]]]]
def has_stdlib(self, language: str) -> bool:
return language + '_stdlib' in self.properties
@@ -135,41 +150,100 @@
# true, but without heterogenious dict annotations it's not practical to
# narrow them
def get_stdlib(self, language: str) -> T.Union[str, T.List[str]]:
- return self.properties[language + '_stdlib']
+ stdlib = self.properties[language + '_stdlib']
+ if isinstance(stdlib, str):
+ return stdlib
+ assert isinstance(stdlib, list)
+ for i in stdlib:
+ assert isinstance(i, str)
+ return stdlib
+
+ def get_root(self) -> T.Optional[str]:
+ root = self.properties.get('root', None)
+ assert root is None or isinstance(root, str)
+ return root
+
+ def get_sys_root(self) -> T.Optional[str]:
+ sys_root = self.properties.get('sys_root', None)
+ assert sys_root is None or isinstance(sys_root, str)
+ return sys_root
+
+ def get_pkg_config_libdir(self) -> T.Optional[T.List[str]]:
+ p = self.properties.get('pkg_config_libdir', None)
+ if p is None:
+ return p
+ res = mesonlib.listify(p)
+ for i in res:
+ assert isinstance(i, str)
+ return res
+
+ def get_cmake_defaults(self) -> bool:
+ if 'cmake_defaults' not in self.properties:
+ return True
+ res = self.properties['cmake_defaults']
+ assert isinstance(res, bool)
+ return res
- def get_root(self) -> T.Optional[T.Union[str, T.List[str]]]:
- return self.properties.get('root', None)
+ def get_cmake_toolchain_file(self) -> T.Optional[Path]:
+ if 'cmake_toolchain_file' not in self.properties:
+ return None
+ raw = self.properties['cmake_toolchain_file']
+ assert isinstance(raw, str)
+ cmake_toolchain_file = Path(raw)
+ if not cmake_toolchain_file.is_absolute():
+ raise EnvironmentException(f'cmake_toolchain_file ({raw}) is not absolute')
+ return cmake_toolchain_file
+
+ def get_cmake_skip_compiler_test(self) -> CMakeSkipCompilerTest:
+ if 'cmake_skip_compiler_test' not in self.properties:
+ return CMakeSkipCompilerTest.DEP_ONLY
+ raw = self.properties['cmake_skip_compiler_test']
+ assert isinstance(raw, str)
+ try:
+ return CMakeSkipCompilerTest(raw)
+ except ValueError:
+ raise EnvironmentException(
+ '"{}" is not a valid value for cmake_skip_compiler_test. Supported values are {}'
+ .format(raw, [e.value for e in CMakeSkipCompilerTest]))
- def get_sys_root(self) -> T.Optional[T.Union[str, T.List[str]]]:
- return self.properties.get('sys_root', None)
+ def get_cmake_use_exe_wrapper(self) -> bool:
+ if 'cmake_use_exe_wrapper' not in self.properties:
+ return True
+ res = self.properties['cmake_use_exe_wrapper']
+ assert isinstance(res, bool)
+ return res
+
+ def get_java_home(self) -> T.Optional[Path]:
+ value = T.cast(T.Optional[str], self.properties.get('java_home'))
+ return Path(value) if value else None
- def __eq__(self, other: T.Any) -> 'T.Union[bool, NotImplemented]':
+ def __eq__(self, other: object) -> bool:
if isinstance(other, type(self)):
return self.properties == other.properties
return NotImplemented
# TODO consider removing so Properties is less freeform
- def __getitem__(self, key: str) -> T.Any:
+ def __getitem__(self, key: str) -> T.Optional[T.Union[str, bool, int, T.List[str]]]:
return self.properties[key]
# TODO consider removing so Properties is less freeform
- def __contains__(self, item: T.Any) -> bool:
+ def __contains__(self, item: T.Union[str, bool, int, T.List[str]]) -> bool:
return item in self.properties
# TODO consider removing, for same reasons as above
- def get(self, key: str, default: T.Any = None) -> T.Any:
+ def get(self, key: str, default: T.Optional[T.Union[str, bool, int, T.List[str]]] = None) -> T.Optional[T.Union[str, bool, int, T.List[str]]]:
return self.properties.get(key, default)
-class MachineInfo:
+class MachineInfo(HoldableObject):
def __init__(self, system: str, cpu_family: str, cpu: str, endian: str):
self.system = system
self.cpu_family = cpu_family
self.cpu = cpu
self.endian = endian
- self.is_64_bit = cpu_family in CPU_FAMILES_64_BIT # type: bool
+ self.is_64_bit = cpu_family in CPU_FAMILIES_64_BIT # type: bool
- def __eq__(self, other: T.Any) -> 'T.Union[bool, NotImplemented]':
- if self.__class__ is not other.__class__:
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, MachineInfo):
return NotImplemented
return \
self.system == other.system and \
@@ -177,29 +251,29 @@
self.cpu == other.cpu and \
self.endian == other.endian
- def __ne__(self, other: T.Any) -> 'T.Union[bool, NotImplemented]':
- if self.__class__ is not other.__class__:
+ def __ne__(self, other: object) -> bool:
+ if not isinstance(other, MachineInfo):
return NotImplemented
return not self.__eq__(other)
def __repr__(self) -> str:
- return ''.format(self.system, self.cpu_family, self.cpu)
+ return f''
@classmethod
def from_literal(cls, literal: T.Dict[str, str]) -> 'MachineInfo':
minimum_literal = {'cpu', 'cpu_family', 'endian', 'system'}
if set(literal) < minimum_literal:
raise EnvironmentException(
- 'Machine info is currently {}\n'.format(literal) +
+ f'Machine info is currently {literal}\n' +
'but is missing {}.'.format(minimum_literal - set(literal)))
cpu_family = literal['cpu_family']
if cpu_family not in known_cpu_families:
- mlog.warning('Unknown CPU family %s, please report this at https://github.com/mesonbuild/meson/issues/new' % cpu_family)
+ mlog.warning(f'Unknown CPU family {cpu_family}, please report this at https://github.com/mesonbuild/meson/issues/new')
endian = literal['endian']
if endian not in ('little', 'big'):
- mlog.warning('Unknown endian %s' % endian)
+ mlog.warning(f'Unknown endian {endian}')
return cls(literal['system'], cpu_family, literal['cpu'], endian)
@@ -207,13 +281,13 @@
"""
Machine is windows?
"""
- return self.system == 'windows' or 'mingw' in self.system
+ return self.system == 'windows'
def is_cygwin(self) -> bool:
"""
Machine is cygwin?
"""
- return self.system.startswith('cygwin')
+ return self.system == 'cygwin'
def is_linux(self) -> bool:
"""
@@ -263,6 +337,16 @@
"""Machine is illumos or Solaris?"""
return self.system == 'sunos'
+ def is_hurd(self) -> bool:
+ """
+ Machine is GNU/Hurd?
+ """
+ return self.system == 'gnu'
+
+ def is_irix(self) -> bool:
+ """Machine is IRIX?"""
+ return self.system.startswith('irix')
+
# Various prefixes and suffixes for import libraries, shared libraries,
# static libraries, and executables.
# Versioning is added to these names in the backends as-needed.
@@ -281,52 +365,19 @@
def libdir_layout_is_win(self) -> bool:
return self.is_windows() or self.is_cygwin()
-class BinaryTable(HasEnvVarFallback):
+class BinaryTable:
+
def __init__(
self,
binaries: T.Optional[T.Dict[str, T.Union[str, T.List[str]]]] = None,
- fallback: bool = True):
- super().__init__(fallback)
- self.binaries = binaries or {} # type: T.Dict[str, T.Union[str, T.List[str]]]
- for name, command in self.binaries.items():
- if not isinstance(command, (list, str)):
- # TODO generalize message
- raise mesonlib.MesonException(
- 'Invalid type {!r} for binary {!r} in cross file'
- ''.format(command, name))
-
- # Map from language identifiers to environment variables.
- evarMap = {
- # Compilers
- 'c': 'CC',
- 'cpp': 'CXX',
- 'cs': 'CSC',
- 'd': 'DC',
- 'fortran': 'FC',
- 'objc': 'OBJC',
- 'objcpp': 'OBJCXX',
- 'rust': 'RUSTC',
- 'vala': 'VALAC',
-
- # Linkers
- 'c_ld': 'CC_LD',
- 'cpp_ld': 'CXX_LD',
- 'd_ld': 'D_LD',
- 'fortran_ld': 'F_LD',
- 'objc_ld': 'OBJC_LD',
- 'objcpp_ld': 'OBJCPP_LD',
- 'rust_ld': 'RUST_LD',
-
- # Binutils
- 'strip': 'STRIP',
- 'ar': 'AR',
- 'windres': 'WINDRES',
-
- # Other tools
- 'cmake': 'CMAKE',
- 'qmake': 'QMAKE',
- 'pkgconfig': 'PKG_CONFIG',
- } # type: T.Dict[str, str]
+ ):
+ self.binaries: T.Dict[str, T.List[str]] = {}
+ if binaries:
+ for name, command in binaries.items():
+ if not isinstance(command, (list, str)):
+ raise mesonlib.MesonException(
+ f'Invalid type {command!r} for entry {name!r} in cross file')
+ self.binaries[name] = mesonlib.listify(command)
@staticmethod
def detect_ccache() -> T.List[str]:
@@ -336,12 +387,21 @@
return []
return ['ccache']
- @classmethod
- def _warn_about_lang_pointing_to_cross(cls, compiler_exe: str, evar: str) -> None:
- evar_str = os.environ.get(evar, 'WHO_WOULD_CALL_THEIR_COMPILER_WITH_THIS_NAME')
- if evar_str == compiler_exe:
- mlog.warning('''Env var %s seems to point to the cross compiler.
-This is probably wrong, it should always point to the native compiler.''' % evar)
+ @staticmethod
+ def detect_sccache() -> T.List[str]:
+ try:
+ subprocess.check_call(['sccache', '--version'], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+ except (OSError, subprocess.CalledProcessError):
+ return []
+ return ['sccache']
+
+ @staticmethod
+ def detect_compiler_cache() -> T.List[str]:
+ # Sccache is "newer" so it is assumed that people would prefer it by default.
+ cache = BinaryTable.detect_sccache()
+ if cache:
+ return cache
+ return BinaryTable.detect_ccache()
@classmethod
def parse_entry(cls, entry: T.Union[str, T.List[str]]) -> T.Tuple[T.List[str], T.List[str]]:
@@ -350,74 +410,37 @@
if compiler[0] == 'ccache':
compiler = compiler[1:]
ccache = cls.detect_ccache()
+ elif compiler[0] == 'sccache':
+ compiler = compiler[1:]
+ ccache = cls.detect_sccache()
else:
ccache = []
# Return value has to be a list of compiler 'choices'
return compiler, ccache
def lookup_entry(self, name: str) -> T.Optional[T.List[str]]:
- """Lookup binaryk
+ """Lookup binary in cross/native file and fallback to environment.
Returns command with args as list if found, Returns `None` if nothing is
found.
-
- First tries looking in explicit map, then tries environment variable.
"""
- # Try explicit map, don't fall back on env var
command = self.binaries.get(name)
- if command is not None:
- command = mesonlib.stringlistify(command)
- # Relies on there being no "" env var
- evar = self.evarMap.get(name, "")
- self._warn_about_lang_pointing_to_cross(command[0], evar)
- elif self.fallback:
- # Relies on there being no "" env var
- evar = self.evarMap.get(name, "")
- command = os.environ.get(evar)
- if command is not None:
- command = split_args(command)
-
- # Do not return empty or blank string entries
- if command is not None and (len(command) == 0 or len(command[0].strip()) == 0):
+ if not command:
+ return None
+ elif not command[0].strip():
return None
return command
-class Directories:
-
- """Data class that holds information about directories for native and cross
- builds.
- """
-
- def __init__(self, bindir: T.Optional[str] = None, datadir: T.Optional[str] = None,
- includedir: T.Optional[str] = None, infodir: T.Optional[str] = None,
- libdir: T.Optional[str] = None, libexecdir: T.Optional[str] = None,
- localedir: T.Optional[str] = None, localstatedir: T.Optional[str] = None,
- mandir: T.Optional[str] = None, prefix: T.Optional[str] = None,
- sbindir: T.Optional[str] = None, sharedstatedir: T.Optional[str] = None,
- sysconfdir: T.Optional[str] = None):
- self.bindir = bindir
- self.datadir = datadir
- self.includedir = includedir
- self.infodir = infodir
- self.libdir = libdir
- self.libexecdir = libexecdir
- self.localedir = localedir
- self.localstatedir = localstatedir
- self.mandir = mandir
- self.prefix = prefix
- self.sbindir = sbindir
- self.sharedstatedir = sharedstatedir
- self.sysconfdir = sysconfdir
-
- def __contains__(self, key: str) -> bool:
- return hasattr(self, key)
-
- def __getitem__(self, key: str) -> T.Optional[str]:
- # Mypy can't figure out what to do with getattr here, so we'll case for it
- return T.cast(T.Optional[str], getattr(self, key))
-
- def __setitem__(self, key: str, value: T.Optional[str]) -> None:
- setattr(self, key, value)
+class CMakeVariables:
+ def __init__(self, variables: T.Optional[T.Dict[str, T.Any]] = None) -> None:
+ variables = variables or {}
+ self.variables = {} # type: T.Dict[str, T.List[str]]
+
+ for key, value in variables.items():
+ value = mesonlib.listify(value)
+ for i in value:
+ assert isinstance(i, str)
+ self.variables[key] = value
- def __iter__(self) -> T.Iterator[T.Tuple[str, str]]:
- return iter(self.__dict__.items())
+ def get_variables(self) -> T.Dict[str, T.List[str]]:
+ return self.variables
diff -Nru meson-0.53.2/mesonbuild/environment.py meson-0.61.2/mesonbuild/environment.py
--- meson-0.53.2/mesonbuild/environment.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/environment.py 2021-11-02 19:58:13.000000000 +0000
@@ -1,4 +1,4 @@
-# Copyright 2012-2016 The Meson development team
+# Copyright 2012-2020 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.
@@ -12,23 +12,25 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os, platform, re, sys, shutil, subprocess
-import tempfile
-import shlex
+import itertools
+import os, platform, re, sys, shutil
import typing as T
+import collections
from . import coredata
-from .linkers import ArLinker, ArmarLinker, VisualStudioLinker, DLinker, CcrxLinker, IntelVisualStudioLinker
from . import mesonlib
from .mesonlib import (
- MesonException, EnvironmentException, MachineChoice, Popen_safe,
- PerMachineDefaultable, PerThreeMachineDefaultable, split_args, quote_arg
+ MesonException, EnvironmentException, MachineChoice, Popen_safe, PerMachine,
+ PerMachineDefaultable, PerThreeMachineDefaultable, split_args, quote_arg, OptionKey,
+ search_version, MesonBugException
)
from . import mlog
+from .programs import (
+ ExternalProgram, EmptyExternalProgram
+)
from .envconfig import (
- BinaryTable, Directories, MachineInfo, MesonConfigFile,
- Properties, known_cpu_families,
+ BinaryTable, MachineInfo, Properties, known_cpu_families, CMakeVariables,
)
from . import compilers
from .compilers import (
@@ -40,81 +42,49 @@
is_object,
is_source,
)
-from .linkers import (
- AppleDynamicLinker,
- ArmClangDynamicLinker,
- ArmDynamicLinker,
- CcrxDynamicLinker,
- ClangClDynamicLinker,
- DynamicLinker,
- GnuBFDDynamicLinker,
- GnuGoldDynamicLinker,
- LLVMDynamicLinker,
- MSVCDynamicLinker,
- OptlinkDynamicLinker,
- PGIDynamicLinker,
- PGIStaticLinker,
- SolarisDynamicLinker,
- XilinkDynamicLinker,
- CudaLinker,
- VisualStudioLikeLinkerMixin,
-)
+
from functools import lru_cache
-from .compilers import (
- ArmCCompiler,
- ArmCPPCompiler,
- ArmclangCCompiler,
- ArmclangCPPCompiler,
- AppleClangCCompiler,
- AppleClangCPPCompiler,
- ClangCCompiler,
- ClangCPPCompiler,
- ClangObjCCompiler,
- ClangObjCPPCompiler,
- ClangClCCompiler,
- ClangClCPPCompiler,
- FlangFortranCompiler,
- G95FortranCompiler,
- GnuCCompiler,
- GnuCPPCompiler,
- GnuFortranCompiler,
- GnuObjCCompiler,
- GnuObjCPPCompiler,
- ElbrusCCompiler,
- ElbrusCPPCompiler,
- ElbrusFortranCompiler,
- EmscriptenCCompiler,
- EmscriptenCPPCompiler,
- IntelCCompiler,
- IntelClCCompiler,
- IntelCPPCompiler,
- IntelClCPPCompiler,
- IntelFortranCompiler,
- IntelClFortranCompiler,
- JavaCompiler,
- MonoCompiler,
- CudaCompiler,
- VisualStudioCsCompiler,
- NAGFortranCompiler,
- Open64FortranCompiler,
- PathScaleFortranCompiler,
- PGICCompiler,
- PGICPPCompiler,
- PGIFortranCompiler,
- RustCompiler,
- CcrxCCompiler,
- CcrxCPPCompiler,
- SunFortranCompiler,
- ValaCompiler,
- VisualStudioCCompiler,
- VisualStudioCPPCompiler,
-)
+from mesonbuild import envconfig
+
+if T.TYPE_CHECKING:
+ from configparser import ConfigParser
+
+ from .wrap.wrap import Resolver
build_filename = 'meson.build'
CompilersDict = T.Dict[str, Compiler]
-def detect_gcovr(min_version='3.3', new_rootdir_version='4.2', log=False):
+if T.TYPE_CHECKING:
+ import argparse
+
+
+def _get_env_var(for_machine: MachineChoice, is_cross: bool, var_name: str) -> T.Optional[str]:
+ """
+ Returns the exact env var and the value.
+ """
+ candidates = PerMachine(
+ # The prefixed build version takes priority, but if we are native
+ # compiling we fall back on the unprefixed host version. This
+ # allows native builds to never need to worry about the 'BUILD_*'
+ # ones.
+ ([var_name + '_FOR_BUILD'] if is_cross else [var_name]),
+ # Always just the unprefixed host versions
+ [var_name]
+ )[for_machine]
+ for var in candidates:
+ value = os.environ.get(var)
+ if value is not None:
+ break
+ else:
+ formatted = ', '.join([f'{var!r}' for var in candidates])
+ mlog.debug(f'None of {formatted} are defined in the environment, not changing global flags.')
+ return None
+ mlog.debug(f'Using {var!r} from environment with value: {value!r}')
+ return value
+
+
+def detect_gcovr(min_version='3.3', log=False):
gcovr_exe = 'gcovr'
try:
p, found = Popen_safe([gcovr_exe, '--version'])[0:2]
@@ -125,11 +95,20 @@
if p.returncode == 0 and mesonlib.version_compare(found, '>=' + min_version):
if log:
mlog.log('Found gcovr-{} at {}'.format(found, quote_arg(shutil.which(gcovr_exe))))
- return gcovr_exe, mesonlib.version_compare(found, '>=' + new_rootdir_version)
+ return gcovr_exe, found
return None, None
-def find_coverage_tools():
- gcovr_exe, gcovr_new_rootdir = detect_gcovr()
+def detect_llvm_cov():
+ tools = get_llvm_tool_names('llvm-cov')
+ for tool in tools:
+ if mesonlib.exe_exists([tool, '--version']):
+ return tool
+ return None
+
+def find_coverage_tools() -> T.Tuple[T.Optional[str], T.Optional[str], T.Optional[str], T.Optional[str], T.Optional[str]]:
+ gcovr_exe, gcovr_version = detect_gcovr()
+
+ llvm_cov_exe = detect_llvm_cov()
lcov_exe = 'lcov'
genhtml_exe = 'genhtml'
@@ -139,17 +118,20 @@
if not mesonlib.exe_exists([genhtml_exe, '--version']):
genhtml_exe = None
- return gcovr_exe, gcovr_new_rootdir, lcov_exe, genhtml_exe
+ return gcovr_exe, gcovr_version, lcov_exe, genhtml_exe, llvm_cov_exe
-def detect_ninja(version: str = '1.5', log: bool = False) -> str:
+def detect_ninja(version: str = '1.8.2', log: bool = False) -> T.List[str]:
r = detect_ninja_command_and_version(version, log)
return r[0] if r else None
-def detect_ninja_command_and_version(version: str = '1.5', log: bool = False) -> (str, str):
+def detect_ninja_command_and_version(version: str = '1.8.2', log: bool = False) -> T.Tuple[T.List[str], str]:
env_ninja = os.environ.get('NINJA', None)
for n in [env_ninja] if env_ninja else ['ninja', 'ninja-build', 'samu']:
+ prog = ExternalProgram(n, silent=True)
+ if not prog.found():
+ continue
try:
- p, found = Popen_safe([n, '--version'])[0:2]
+ p, found = Popen_safe(prog.command + ['--version'])[0:2]
except (FileNotFoundError, PermissionError):
# Doesn't exist in PATH or isn't executable
continue
@@ -157,7 +139,6 @@
# Perhaps we should add a way for the caller to know the failure mode
# (not found or too old)
if p.returncode == 0 and mesonlib.version_compare(found, '>=' + version):
- n = shutil.which(n)
if log:
name = os.path.basename(n)
if name.endswith('-' + found):
@@ -166,8 +147,9 @@
name = 'ninja'
if name == 'samu':
name = 'samurai'
- mlog.log('Found {}-{} at {}'.format(name, found, quote_arg(n)))
- return (n, found)
+ mlog.log('Found {}-{} at {}'.format(name, found,
+ ' '.join([quote_arg(x) for x in prog.command])))
+ return (prog.command, found)
def get_llvm_tool_names(tool: str) -> T.List[str]:
# Ordered list of possible suffixes of LLVM executables to try. Start with
@@ -177,6 +159,9 @@
# unless it becomes a stable release.
suffixes = [
'', # base (no suffix)
+ '-12', '12',
+ '-11', '11',
+ '-10', '10',
'-9', '90',
'-8', '80',
'-7', '70',
@@ -188,7 +173,7 @@
'-3.7', '37',
'-3.6', '36',
'-3.5', '35',
- '-10', # Debian development snapshot
+ '-13', # Debian development snapshot
'-devel', # FreeBSD development snapshot
]
names = []
@@ -318,7 +303,7 @@
"""
if mesonlib.is_windows():
trial = detect_windows_arch(compilers)
- elif mesonlib.is_freebsd() or mesonlib.is_netbsd() or mesonlib.is_openbsd():
+ elif mesonlib.is_freebsd() or mesonlib.is_netbsd() or mesonlib.is_openbsd() or mesonlib.is_qnx() or mesonlib.is_aix():
trial = platform.processor().lower()
else:
trial = platform.machine().lower()
@@ -326,18 +311,28 @@
trial = 'x86'
elif trial == 'bepc':
trial = 'x86'
+ elif trial == 'arm64':
+ trial = 'aarch64'
+ elif trial.startswith('aarch64'):
+ # This can be `aarch64_be`
+ trial = 'aarch64'
elif trial.startswith('arm') or trial.startswith('earm'):
trial = 'arm'
elif trial.startswith(('powerpc64', 'ppc64')):
trial = 'ppc64'
- elif trial.startswith(('powerpc', 'ppc')):
- trial = 'ppc'
- elif trial == 'macppc':
+ elif trial.startswith(('powerpc', 'ppc')) or trial in {'macppc', 'power macintosh'}:
trial = 'ppc'
elif trial in ('amd64', 'x64', 'i86pc'):
trial = 'x86_64'
elif trial in {'sun4u', 'sun4v'}:
trial = 'sparc64'
+ elif trial.startswith('mips'):
+ if '64' not in trial:
+ trial = 'mips'
+ else:
+ trial = 'mips64'
+ elif trial in {'ip30', 'ip35'}:
+ trial = 'mips64'
# On Linux (and maybe others) there can be any mixture of 32/64 bit code in
# the kernel, Python, system, 32-bit chroot on 64-bit host, etc. The only
@@ -354,50 +349,65 @@
# ATM there is no 64 bit userland for PA-RISC. Thus always
# report it as 32 bit for simplicity.
trial = 'parisc'
+ elif trial == 'ppc':
+ # AIX always returns powerpc, check here for 64-bit
+ if any_compiler_has_define(compilers, '__64BIT__'):
+ trial = 'ppc64'
if trial not in known_cpu_families:
- mlog.warning('Unknown CPU family {!r}, please report this at '
+ mlog.warning(f'Unknown CPU family {trial!r}, please report this at '
'https://github.com/mesonbuild/meson/issues/new with the '
- 'output of `uname -a` and `cat /proc/cpuinfo`'.format(trial))
+ 'output of `uname -a` and `cat /proc/cpuinfo`')
return trial
-def detect_cpu(compilers: CompilersDict):
+def detect_cpu(compilers: CompilersDict) -> str:
if mesonlib.is_windows():
trial = detect_windows_arch(compilers)
- elif mesonlib.is_freebsd() or mesonlib.is_netbsd() or mesonlib.is_openbsd():
+ elif mesonlib.is_freebsd() or mesonlib.is_netbsd() or mesonlib.is_openbsd() or mesonlib.is_aix():
trial = platform.processor().lower()
else:
trial = platform.machine().lower()
+
if trial in ('amd64', 'x64', 'i86pc'):
trial = 'x86_64'
if trial == 'x86_64':
# Same check as above for cpu_family
if any_compiler_has_define(compilers, '__i386__'):
trial = 'i686' # All 64 bit cpus have at least this level of x86 support.
- elif trial == 'aarch64':
+ elif trial.startswith('aarch64'):
# Same check as above for cpu_family
if any_compiler_has_define(compilers, '__arm__'):
trial = 'arm'
+ else:
+ # for aarch64_be
+ trial = 'aarch64'
elif trial.startswith('earm'):
trial = 'arm'
elif trial == 'e2k':
# Make more precise CPU detection for Elbrus platform.
trial = platform.processor().lower()
+ elif trial.startswith('mips'):
+ if '64' not in trial:
+ trial = 'mips'
+ else:
+ trial = 'mips64'
+ elif trial == 'ppc':
+ # AIX always returns powerpc, check here for 64-bit
+ if any_compiler_has_define(compilers, '__64BIT__'):
+ trial = 'ppc64'
+
# Add more quirks here as bugs are reported. Keep in sync with
# detect_cpu_family() above.
return trial
-def detect_system():
- system = platform.system().lower()
- if system.startswith('cygwin'):
+def detect_system() -> str:
+ if sys.platform == 'cygwin':
return 'cygwin'
- return system
+ return platform.system().lower()
-def detect_msys2_arch():
- if 'MSYSTEM_CARCH' in os.environ:
- return os.environ['MSYSTEM_CARCH']
- return None
+def detect_msys2_arch() -> T.Optional[str]:
+ return os.environ.get('MSYSTEM_CARCH', None)
def detect_machine_info(compilers: T.Optional[CompilersDict] = None) -> MachineInfo:
"""Detect the machine we're running on
@@ -428,50 +438,15 @@
true_build_cpu_family = detect_cpu_family({})
return \
(machine_info.cpu_family == true_build_cpu_family) or \
- ((true_build_cpu_family == 'x86_64') and (machine_info.cpu_family == 'x86'))
-
-def search_version(text):
- # Usually of the type 4.1.4 but compiler output may contain
- # stuff like this:
- # (Sourcery CodeBench Lite 2014.05-29) 4.8.3 20140320 (prerelease)
- # Limiting major version number to two digits seems to work
- # thus far. When we get to GCC 100, this will break, but
- # if we are still relevant when that happens, it can be
- # considered an achievement in itself.
- #
- # This regex is reaching magic levels. If it ever needs
- # to be updated, do not complexify but convert to something
- # saner instead.
- # We'll demystify it a bit with a verbose definition.
- version_regex = re.compile(r"""
- (? None:
self.source_dir = source_dir
self.build_dir = build_dir
# Do not try to create build directories when build_dir is none.
@@ -484,10 +459,15 @@
os.makedirs(self.log_dir, exist_ok=True)
os.makedirs(self.info_dir, exist_ok=True)
try:
- self.coredata = coredata.load(self.get_build_dir())
+ self.coredata = coredata.load(self.get_build_dir()) # type: coredata.CoreData
self.first_invocation = False
except FileNotFoundError:
self.create_new_coredata(options)
+ except coredata.MesonVersionMismatchException as e:
+ # This is routine, but tell the user the update happened
+ mlog.log('Regenerating configuration from scratch:', str(e))
+ coredata.read_cmd_line_file(self.build_dir, options)
+ self.create_new_coredata(options)
except MesonException as e:
# If we stored previous command line options, we can recover from
# a broken/outdated coredata.
@@ -508,19 +488,17 @@
# Stores machine infos, the only *three* machine one because we have a
# target machine info on for the user (Meson never cares about the
# target machine.)
- machines = PerThreeMachineDefaultable()
+ machines: PerThreeMachineDefaultable[MachineInfo] = PerThreeMachineDefaultable()
# Similar to coredata.compilers, but lower level in that there is no
# meta data, only names/paths.
- binaries = PerMachineDefaultable()
+ binaries = PerMachineDefaultable() # type: PerMachineDefaultable[BinaryTable]
# Misc other properties about each machine.
- properties = PerMachineDefaultable()
+ properties = PerMachineDefaultable() # type: PerMachineDefaultable[Properties]
- # Store paths for native and cross build files. There is no target
- # machine information here because nothing is installed for the target
- # architecture, just the build and host architectures
- paths = PerMachineDefaultable()
+ # CMake toolchain variables
+ cmakevars = PerMachineDefaultable() # type: PerMachineDefaultable[CMakeVariables]
## Setup build machine defaults
@@ -532,1138 +510,292 @@
binaries.build = BinaryTable()
properties.build = Properties()
+ # Options with the key parsed into an OptionKey type.
+ #
+ # Note that order matters because of 'buildtype', if it is after
+ # 'optimization' and 'debug' keys, it override them.
+ self.options: T.MutableMapping[OptionKey, T.Union[str, T.List[str]]] = collections.OrderedDict()
+
## Read in native file(s) to override build machine configuration
if self.coredata.config_files is not None:
- config = MesonConfigFile.from_config_parser(
- coredata.load_configs(self.coredata.config_files))
+ config = coredata.parse_machine_files(self.coredata.config_files)
binaries.build = BinaryTable(config.get('binaries', {}))
- paths.build = Directories(**config.get('paths', {}))
+ properties.build = Properties(config.get('properties', {}))
+ cmakevars.build = CMakeVariables(config.get('cmake', {}))
+ self._load_machine_file_options(
+ config, properties.build,
+ MachineChoice.BUILD if self.coredata.cross_files else MachineChoice.HOST)
## Read in cross file(s) to override host machine configuration
if self.coredata.cross_files:
- config = MesonConfigFile.from_config_parser(
- coredata.load_configs(self.coredata.cross_files))
- properties.host = Properties(config.get('properties', {}), False)
- binaries.host = BinaryTable(config.get('binaries', {}), False)
+ config = coredata.parse_machine_files(self.coredata.cross_files)
+ properties.host = Properties(config.get('properties', {}))
+ binaries.host = BinaryTable(config.get('binaries', {}))
+ cmakevars.host = CMakeVariables(config.get('cmake', {}))
if 'host_machine' in config:
machines.host = MachineInfo.from_literal(config['host_machine'])
if 'target_machine' in config:
machines.target = MachineInfo.from_literal(config['target_machine'])
- paths.host = Directories(**config.get('paths', {}))
+ # Keep only per machine options from the native file. The cross
+ # file takes precedence over all other options.
+ for key, value in list(self.options.items()):
+ if self.coredata.is_per_machine_option(key):
+ self.options[key.as_build()] = value
+ self._load_machine_file_options(config, properties.host, MachineChoice.HOST)
## "freeze" now initialized configuration, and "save" to the class.
self.machines = machines.default_missing()
self.binaries = binaries.default_missing()
self.properties = properties.default_missing()
- self.paths = paths.default_missing()
+ self.cmakevars = cmakevars.default_missing()
+
+ # Command line options override those from cross/native files
+ self.options.update(options.cmd_line_options)
+
+ # Take default value from env if not set in cross/native files or command line.
+ self._set_default_options_from_env()
+ self._set_default_binaries_from_env()
+ self._set_default_properties_from_env()
+
+ # Warn if the user is using two different ways of setting build-type
+ # options that override each other
+ bt = OptionKey('buildtype')
+ db = OptionKey('debug')
+ op = OptionKey('optimization')
+ if bt in self.options and (db in self.options or op in self.options):
+ mlog.warning('Recommend using either -Dbuildtype or -Doptimization + -Ddebug. '
+ 'Using both is redundant since they override each other. '
+ 'See: https://mesonbuild.com/Builtin-options.html#build-type-options')
- exe_wrapper = self.binaries.host.lookup_entry('exe_wrapper')
+ exe_wrapper = self.lookup_binary_entry(MachineChoice.HOST, 'exe_wrapper')
if exe_wrapper is not None:
- from .dependencies import ExternalProgram
- self.exe_wrapper = ExternalProgram.from_bin_list(
- self.binaries.host,
- 'exe_wrapper')
+ self.exe_wrapper = ExternalProgram.from_bin_list(self, MachineChoice.HOST, 'exe_wrapper')
else:
self.exe_wrapper = None
- self.cmd_line_options = options.cmd_line_options.copy()
-
- # List of potential compilers.
- if mesonlib.is_windows():
- # Intel C and C++ compiler is icl on Windows, but icc and icpc elsewhere.
- # Search for icl before cl, since Intel "helpfully" provides a
- # cl.exe that returns *exactly the same thing* that microsofts
- # cl.exe does, and if icl is present, it's almost certainly what
- # you want.
- self.default_c = ['icl', 'cl', 'cc', 'gcc', 'clang', 'clang-cl', 'pgcc']
- # There is currently no pgc++ for Windows, only for Mac and Linux.
- self.default_cpp = ['icl', 'cl', 'c++', 'g++', 'clang++', 'clang-cl']
- self.default_fortran = ['ifort', 'gfortran', 'flang', 'pgfortran', 'g95']
- # Clang and clang++ are valid, but currently unsupported.
- self.default_objc = ['cc', 'gcc']
- self.default_objcpp = ['c++', 'g++']
- self.default_cs = ['csc', 'mcs']
- else:
- if platform.machine().lower() == 'e2k':
- # There are no objc or objc++ compilers for Elbrus,
- # and there's no clang which can build binaries for host.
- self.default_c = ['cc', 'gcc', 'lcc']
- self.default_cpp = ['c++', 'g++', 'l++']
- self.default_objc = []
- self.default_objcpp = []
- else:
- self.default_c = ['cc', 'gcc', 'clang', 'pgcc', 'icc']
- self.default_cpp = ['c++', 'g++', 'clang++', 'pgc++', 'icpc']
- self.default_objc = ['cc', 'gcc', 'clang']
- self.default_objcpp = ['c++', 'g++', 'clang++']
- self.default_fortran = ['gfortran', 'flang', 'pgfortran', 'ifort', 'g95']
- self.default_cs = ['mcs', 'csc']
- self.default_d = ['ldc2', 'ldc', 'gdc', 'dmd']
- self.default_java = ['javac']
- self.default_cuda = ['nvcc']
- self.default_rust = ['rustc']
- self.default_swift = ['swiftc']
- self.default_vala = ['valac']
- self.default_static_linker = ['ar', 'gar']
- self.default_strip = ['strip']
- self.vs_static_linker = ['lib']
- self.clang_cl_static_linker = ['llvm-lib']
- self.cuda_static_linker = ['nvlink']
- self.gcc_static_linker = ['gcc-ar']
- self.clang_static_linker = ['llvm-ar']
self.default_cmake = ['cmake']
self.default_pkgconfig = ['pkg-config']
+ self.wrap_resolver: T.Optional['Resolver'] = None
- def create_new_coredata(self, options):
+ def _load_machine_file_options(self, config: 'ConfigParser', properties: Properties, machine: MachineChoice) -> None:
+ """Read the contents of a Machine file and put it in the options store."""
+
+ # Look for any options in the deprecated paths section, warn about
+ # those, then assign them. They will be overwritten by the ones in the
+ # "built-in options" section if they're in both sections.
+ paths = config.get('paths')
+ if paths:
+ mlog.deprecation('The [paths] section is deprecated, use the [built-in options] section instead.')
+ for k, v in paths.items():
+ self.options[OptionKey.from_string(k).evolve(machine=machine)] = v
+
+ # Next look for compiler options in the "properties" section, this is
+ # also deprecated, and these will also be overwritten by the "built-in
+ # options" section. We need to remove these from this section, as well.
+ deprecated_properties: T.Set[str] = set()
+ for lang in compilers.all_languages:
+ deprecated_properties.add(lang + '_args')
+ deprecated_properties.add(lang + '_link_args')
+ for k, v in properties.properties.copy().items():
+ if k in deprecated_properties:
+ mlog.deprecation(f'{k} in the [properties] section of the machine file is deprecated, use the [built-in options] section.')
+ self.options[OptionKey.from_string(k).evolve(machine=machine)] = v
+ del properties.properties[k]
+
+ for section, values in config.items():
+ if ':' in section:
+ subproject, section = section.split(':')
+ else:
+ subproject = ''
+ if section == 'built-in options':
+ for k, v in values.items():
+ key = OptionKey.from_string(k)
+ # If we're in the cross file, and there is a `build.foo` warn about that. Later we'll remove it.
+ if machine is MachineChoice.HOST and key.machine is not machine:
+ mlog.deprecation('Setting build machine options in cross files, please use a native file instead, this will be removed in meson 0.60', once=True)
+ if key.subproject:
+ raise MesonException('Do not set subproject options in [built-in options] section, use [subproject:built-in options] instead.')
+ self.options[key.evolve(subproject=subproject, machine=machine)] = v
+ elif section == 'project options' and machine is MachineChoice.HOST:
+ # Project options are only for the host machine, we don't want
+ # to read these from the native file
+ for k, v in values.items():
+ # Project options are always for the host machine
+ key = OptionKey.from_string(k)
+ if key.subproject:
+ raise MesonException('Do not set subproject options in [built-in options] section, use [subproject:built-in options] instead.')
+ self.options[key.evolve(subproject=subproject)] = v
+
+ def _set_default_options_from_env(self) -> None:
+ opts: T.List[T.Tuple[str, str]] = (
+ [(v, f'{k}_args') for k, v in compilers.compilers.CFLAGS_MAPPING.items()] +
+ [
+ ('PKG_CONFIG_PATH', 'pkg_config_path'),
+ ('CMAKE_PREFIX_PATH', 'cmake_prefix_path'),
+ ('LDFLAGS', 'ldflags'),
+ ('CPPFLAGS', 'cppflags'),
+ ]
+ )
+
+ env_opts: T.DefaultDict[OptionKey, T.List[str]] = collections.defaultdict(list)
+
+ for (evar, keyname), for_machine in itertools.product(opts, MachineChoice):
+ p_env = _get_env_var(for_machine, self.is_cross_build(), evar)
+ if p_env is not None:
+ # these may contain duplicates, which must be removed, else
+ # a duplicates-in-array-option warning arises.
+ if keyname == 'cmake_prefix_path':
+ if self.machines[for_machine].is_windows():
+ # Cannot split on ':' on Windows because its in the drive letter
+ _p_env = p_env.split(os.pathsep)
+ else:
+ # https://github.com/mesonbuild/meson/issues/7294
+ _p_env = re.split(r':|;', p_env)
+ p_list = list(mesonlib.OrderedSet(_p_env))
+ elif keyname == 'pkg_config_path':
+ p_list = list(mesonlib.OrderedSet(p_env.split(':')))
+ else:
+ p_list = split_args(p_env)
+ p_list = [e for e in p_list if e] # filter out any empty elements
+
+ # Take env vars only on first invocation, if the env changes when
+ # reconfiguring it gets ignored.
+ # FIXME: We should remember if we took the value from env to warn
+ # if it changes on future invocations.
+ if self.first_invocation:
+ if keyname == 'ldflags':
+ key = OptionKey('link_args', machine=for_machine, lang='c') # needs a language to initialize properly
+ for lang in compilers.compilers.LANGUAGES_USING_LDFLAGS:
+ key = key.evolve(lang=lang)
+ env_opts[key].extend(p_list)
+ elif keyname == 'cppflags':
+ key = OptionKey('env_args', machine=for_machine, lang='c')
+ for lang in compilers.compilers.LANGUAGES_USING_CPPFLAGS:
+ key = key.evolve(lang=lang)
+ env_opts[key].extend(p_list)
+ else:
+ key = OptionKey.from_string(keyname).evolve(machine=for_machine)
+ if evar in compilers.compilers.CFLAGS_MAPPING.values():
+ # If this is an environment variable, we have to
+ # store it separately until the compiler is
+ # instantiated, as we don't know whether the
+ # compiler will want to use these arguments at link
+ # time and compile time (instead of just at compile
+ # time) until we're instantiating that `Compiler`
+ # object. This is required so that passing
+ # `-Dc_args=` on the command line and `$CFLAGS`
+ # have subtely different behavior. `$CFLAGS` will be
+ # added to the linker command line if the compiler
+ # acts as a linker driver, `-Dc_args` will not.
+ #
+ # We still use the original key as the base here, as
+ # we want to inhert the machine and the compiler
+ # language
+ key = key.evolve('env_args')
+ env_opts[key].extend(p_list)
+
+ # Only store options that are not already in self.options,
+ # otherwise we'd override the machine files
+ for k, v in env_opts.items():
+ if k not in self.options:
+ self.options[k] = v
+
+ def _set_default_binaries_from_env(self) -> None:
+ """Set default binaries from the environment.
+
+ For example, pkg-config can be set via PKG_CONFIG, or in the machine
+ file. We want to set the default to the env variable.
+ """
+ opts = itertools.chain(envconfig.DEPRECATED_ENV_PROG_MAP.items(),
+ envconfig.ENV_VAR_PROG_MAP.items())
+
+ for (name, evar), for_machine in itertools.product(opts, MachineChoice):
+ p_env = _get_env_var(for_machine, self.is_cross_build(), evar)
+ if p_env is not None:
+ self.binaries[for_machine].binaries.setdefault(name, mesonlib.split_args(p_env))
+
+ def _set_default_properties_from_env(self) -> None:
+ """Properties which can also be set from the environment."""
+ # name, evar, split
+ opts: T.List[T.Tuple[str, T.List[str], bool]] = [
+ ('boost_includedir', ['BOOST_INCLUDEDIR'], False),
+ ('boost_librarydir', ['BOOST_LIBRARYDIR'], False),
+ ('boost_root', ['BOOST_ROOT', 'BOOSTROOT'], True),
+ ('java_home', ['JAVA_HOME'], False),
+ ]
+
+ for (name, evars, split), for_machine in itertools.product(opts, MachineChoice):
+ for evar in evars:
+ p_env = _get_env_var(for_machine, self.is_cross_build(), evar)
+ if p_env is not None:
+ if split:
+ self.properties[for_machine].properties.setdefault(name, p_env.split(os.pathsep))
+ else:
+ self.properties[for_machine].properties.setdefault(name, p_env)
+ break
+
+ def create_new_coredata(self, options: 'argparse.Namespace') -> None:
# WARNING: Don't use any values from coredata in __init__. It gets
# re-initialized with project options by the interpreter during
# build file parsing.
- self.coredata = coredata.CoreData(options, self.scratch_dir)
- # Used by the regenchecker script, which runs meson
- self.coredata.meson_command = mesonlib.meson_command
+ # meson_command is used by the regenchecker script, which runs meson
+ self.coredata = coredata.CoreData(options, self.scratch_dir, mesonlib.get_meson_command())
self.first_invocation = True
- def is_cross_build(self) -> bool:
- return self.coredata.is_cross_build()
+ def is_cross_build(self, when_building_for: MachineChoice = MachineChoice.HOST) -> bool:
+ return self.coredata.is_cross_build(when_building_for)
- def dump_coredata(self):
+ def dump_coredata(self) -> str:
return coredata.save(self.coredata, self.get_build_dir())
- def get_script_dir(self):
- import mesonbuild.scripts
- return os.path.dirname(mesonbuild.scripts.__file__)
-
- def get_log_dir(self):
+ def get_log_dir(self) -> str:
return self.log_dir
- def get_coredata(self):
+ def get_coredata(self) -> coredata.CoreData:
return self.coredata
- def get_build_command(self, unbuffered=False):
- cmd = mesonlib.meson_command[:]
+ @staticmethod
+ def get_build_command(unbuffered: bool = False) -> T.List[str]:
+ cmd = mesonlib.get_meson_command()
+ if cmd is None:
+ raise MesonBugException('No command?')
+ cmd = cmd.copy()
if unbuffered and 'python' in os.path.basename(cmd[0]):
cmd.insert(1, '-u')
return cmd
- def is_header(self, fname):
+ def is_header(self, fname: 'mesonlib.FileOrString') -> bool:
return is_header(fname)
- def is_source(self, fname):
+ def is_source(self, fname: 'mesonlib.FileOrString') -> bool:
return is_source(fname)
- def is_assembly(self, fname):
+ def is_assembly(self, fname: 'mesonlib.FileOrString') -> bool:
return is_assembly(fname)
- def is_llvm_ir(self, fname):
+ def is_llvm_ir(self, fname: 'mesonlib.FileOrString') -> bool:
return is_llvm_ir(fname)
- def is_object(self, fname):
+ def is_object(self, fname: 'mesonlib.FileOrString') -> bool:
return is_object(fname)
@lru_cache(maxsize=None)
def is_library(self, fname):
return is_library(fname)
- @staticmethod
- def get_gnu_compiler_defines(compiler):
- """
- Detect GNU compiler platform type (Apple, MinGW, Unix)
- """
- # Arguments to output compiler pre-processor defines to stdout
- # gcc, g++, and gfortran all support these arguments
- args = compiler + ['-E', '-dM', '-']
- p, output, error = Popen_safe(args, write='', stdin=subprocess.PIPE)
- if p.returncode != 0:
- raise EnvironmentException('Unable to detect GNU compiler type:\n' + output + error)
- # Parse several lines of the type:
- # `#define ___SOME_DEF some_value`
- # and extract `___SOME_DEF`
- defines = {}
- for line in output.split('\n'):
- if not line:
- continue
- d, *rest = line.split(' ', 2)
- if d != '#define':
- continue
- if len(rest) == 1:
- defines[rest] = True
- if len(rest) == 2:
- defines[rest[0]] = rest[1]
- return defines
-
- @staticmethod
- def get_gnu_version_from_defines(defines):
- dot = '.'
- major = defines.get('__GNUC__', '0')
- minor = defines.get('__GNUC_MINOR__', '0')
- patch = defines.get('__GNUC_PATCHLEVEL__', '0')
- return dot.join((major, minor, patch))
-
- @staticmethod
- def get_lcc_version_from_defines(defines):
- dot = '.'
- generation_and_major = defines.get('__LCC__', '100')
- generation = generation_and_major[:1]
- major = generation_and_major[1:]
- minor = defines.get('__LCC_MINOR__', '0')
- return dot.join((generation, major, minor))
-
- def _get_compilers(self, lang, for_machine):
- '''
- The list of compilers is detected in the exact same way for
- C, C++, ObjC, ObjC++, Fortran, CS so consolidate it here.
- '''
- value = self.binaries[for_machine].lookup_entry(lang)
- if value is not None:
- compilers, ccache = BinaryTable.parse_entry(value)
- # Return value has to be a list of compiler 'choices'
- compilers = [compilers]
- else:
- if not self.machines.matches_build_machine(for_machine):
- raise EnvironmentException('{!r} compiler binary not defined in cross or native file'.format(lang))
- compilers = getattr(self, 'default_' + lang)
- ccache = BinaryTable.detect_ccache()
-
- if self.machines.matches_build_machine(for_machine):
- exe_wrap = None
- else:
- exe_wrap = self.get_exe_wrapper()
-
- return compilers, ccache, exe_wrap
-
- def _handle_exceptions(self, exceptions, binaries, bintype='compiler'):
- errmsg = 'Unknown {}(s): {}'.format(bintype, binaries)
- if exceptions:
- errmsg += '\nThe follow exceptions were encountered:'
- for (c, e) in exceptions.items():
- errmsg += '\nRunning "{0}" gave "{1}"'.format(c, e)
- raise EnvironmentException(errmsg)
-
- def _guess_win_linker(self, compiler: T.List[str], comp_class: Compiler,
- for_machine: MachineChoice, *,
- use_linker_prefix: bool = True) -> 'DynamicLinker':
- self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
-
- # Explicitly pass logo here so that we can get the version of link.exe
- if not use_linker_prefix or comp_class.LINKER_PREFIX is None:
- check_args = ['/logo', '--version']
- elif isinstance(comp_class.LINKER_PREFIX, str):
- check_args = [comp_class.LINKER_PREFIX + '/logo', comp_class.LINKER_PREFIX + '--version']
- elif isinstance(comp_class.LINKER_PREFIX, list):
- check_args = comp_class.LINKER_PREFIX + ['/logo'] + comp_class.LINKER_PREFIX + ['--version']
-
- check_args += self.coredata.compiler_options[for_machine][comp_class.language + '_args'].value
+ def lookup_binary_entry(self, for_machine: MachineChoice, name: str) -> T.Optional[T.List[str]]:
+ return self.binaries[for_machine].lookup_entry(name)
- override = [] # type: T.List[str]
- value = self.binaries[for_machine].lookup_entry(comp_class.language + '_ld')
- if value is not None:
- override = comp_class.use_linker_args(value[0])
- check_args += override
-
- p, o, _ = Popen_safe(compiler + check_args)
- if o.startswith('LLD'):
- if '(compatible with GNU linkers)' in o:
- return LLVMDynamicLinker(
- compiler, for_machine, comp_class.LINKER_PREFIX,
- override, version=search_version(o))
-
- if value is not None:
- compiler = value
-
- p, o, e = Popen_safe(compiler + check_args)
- if o.startswith('LLD'):
- return ClangClDynamicLinker(
- for_machine, [],
- prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
- exelist=compiler, version=search_version(o))
- elif 'OPTLINK' in o:
- # Opltink's stdout *may* beging with a \r character.
- return OptlinkDynamicLinker(for_machine, version=search_version(o))
- elif o.startswith('Microsoft') or e.startswith('Microsoft'):
- out = o or e
- match = re.search(r'.*(X86|X64|ARM|ARM64).*', out)
- if match:
- target = str(match.group(1))
- else:
- target = 'x86'
-
- return MSVCDynamicLinker(
- for_machine, [], machine=target, exelist=compiler,
- prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
- version=search_version(out))
- elif 'GNU coreutils' in o:
- raise EnvironmentException(
- "Found GNU link.exe instead of MSVC link.exe. This link.exe "
- "is not a linker. You may need to reorder entries to your "
- "%PATH% variable to resolve this.")
- raise EnvironmentException('Unable to determine dynamic linker')
-
- def _guess_nix_linker(self, compiler: T.List[str], comp_class: T.Type[Compiler],
- for_machine: MachineChoice, *,
- extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
- """Helper for guessing what linker to use on Unix-Like OSes.
-
- :compiler: Invocation to use to get linker
- :comp_class: The Compiler Type (uninstantiated)
- :for_machine: which machine this linker targets
- :extra_args: Any additional arguments required (such as a source file)
- """
- self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
- extra_args = T.cast(T.List[str], extra_args or [])
- extra_args += self.coredata.compiler_options[for_machine][comp_class.language + '_args'].value
-
- if isinstance(comp_class.LINKER_PREFIX, str):
- check_args = [comp_class.LINKER_PREFIX + '--version'] + extra_args
- else:
- check_args = comp_class.LINKER_PREFIX + ['--version'] + extra_args
-
- override = [] # type: T.List[str]
- value = self.binaries[for_machine].lookup_entry(comp_class.language + '_ld')
- if value is not None:
- override = comp_class.use_linker_args(value[0])
- check_args += override
-
- _, o, e = Popen_safe(compiler + check_args)
- v = search_version(o)
- if o.startswith('LLD'):
- linker = LLVMDynamicLinker(
- compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v) # type: DynamicLinker
- elif e.startswith('lld-link: '):
- # Toolchain wrapper got in the way; this happens with e.g. https://github.com/mstorsjo/llvm-mingw
- # Let's try to extract the linker invocation command to grab the version.
-
- _, o, e = Popen_safe(compiler + check_args + ['-v'])
-
- try:
- linker_cmd = re.match(r'.*\n(.*?)\nlld-link: ', e, re.DOTALL).group(1)
- linker_cmd = shlex.split(linker_cmd)[0]
- except (AttributeError, IndexError, ValueError):
- pass
- else:
- _, o, e = Popen_safe([linker_cmd, '--version'])
- v = search_version(o)
-
- linker = LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
- # first is for apple clang, second is for real gcc, the third is icc
- elif e.endswith('(use -v to see invocation)\n') or 'macosx_version' in e or 'ld: unknown option:' in e:
- if isinstance(comp_class.LINKER_PREFIX, str):
- _, _, e = Popen_safe(compiler + [comp_class.LINKER_PREFIX + '-v'] + extra_args)
- else:
- _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-v'] + extra_args)
- for line in e.split('\n'):
- if 'PROJECT:ld' in line:
- v = line.split('-')[1]
- break
- else:
- v = 'unknown version'
- linker = AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
- elif 'GNU' in o:
- if 'gold' in o:
- cls = GnuGoldDynamicLinker
- else:
- cls = GnuBFDDynamicLinker
- linker = cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
- elif 'Solaris' in e or 'Solaris' in o:
- linker = SolarisDynamicLinker(
- compiler, for_machine, comp_class.LINKER_PREFIX, override,
- version=search_version(e))
- else:
- raise EnvironmentException('Unable to determine dynamic linker')
- return linker
-
- def _detect_c_or_cpp_compiler(self, lang: str, for_machine: MachineChoice) -> Compiler:
- popen_exceptions = {}
- compilers, ccache, exe_wrap = self._get_compilers(lang, for_machine)
- is_cross = not self.machines.matches_build_machine(for_machine)
- info = self.machines[for_machine]
-
- for compiler in compilers:
- if isinstance(compiler, str):
- compiler = [compiler]
- compiler_name = os.path.basename(compiler[0])
-
- if not set(['cl', 'cl.exe', 'clang-cl', 'clang-cl.exe']).isdisjoint(compiler):
- # Watcom C provides it's own cl.exe clone that mimics an older
- # version of Microsoft's compiler. Since Watcom's cl.exe is
- # just a wrapper, we skip using it if we detect its presence
- # so as not to confuse Meson when configuring for MSVC.
- #
- # Additionally the help text of Watcom's cl.exe is paged, and
- # the binary will not exit without human intervention. In
- # practice, Meson will block waiting for Watcom's cl.exe to
- # exit, which requires user input and thus will never exit.
- if 'WATCOM' in os.environ:
- def sanitize(p):
- return os.path.normcase(os.path.abspath(p))
-
- watcom_cls = [sanitize(os.path.join(os.environ['WATCOM'], 'BINNT', 'cl')),
- sanitize(os.path.join(os.environ['WATCOM'], 'BINNT', 'cl.exe'))]
- found_cl = sanitize(shutil.which('cl'))
- if found_cl in watcom_cls:
- continue
- arg = '/?'
- elif 'armcc' in compiler_name:
- arg = '--vsn'
- elif 'ccrx' in compiler_name:
- arg = '-v'
- elif 'icl' in compiler_name:
- # if you pass anything to icl you get stuck in a pager
- arg = ''
- else:
- arg = '--version'
-
- try:
- p, out, err = Popen_safe(compiler + [arg])
- except OSError as e:
- popen_exceptions[' '.join(compiler + [arg])] = e
- continue
-
- if 'ccrx' in compiler_name:
- out = err
-
- full_version = out.split('\n', 1)[0]
- version = search_version(out)
-
- guess_gcc_or_lcc = False
- if 'Free Software Foundation' in out or 'xt-' in out:
- guess_gcc_or_lcc = 'gcc'
- if 'e2k' in out and 'lcc' in out:
- guess_gcc_or_lcc = 'lcc'
-
- if guess_gcc_or_lcc:
- defines = self.get_gnu_compiler_defines(compiler)
- if not defines:
- popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
- continue
-
- if guess_gcc_or_lcc == 'lcc':
- version = self.get_lcc_version_from_defines(defines)
- cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler
- else:
- version = self.get_gnu_version_from_defines(defines)
- cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler
-
- linker = self._guess_nix_linker(compiler, cls, for_machine)
-
- return cls(
- ccache + compiler, version, for_machine, is_cross,
- info, exe_wrap, defines, full_version=full_version,
- linker=linker)
-
- if 'Emscripten' in out:
- cls = EmscriptenCCompiler if lang == 'c' else EmscriptenCPPCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- return cls(
- ccache + compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version)
-
- if 'armclang' in out:
- # The compiler version is not present in the first line of output,
- # instead it is present in second line, startswith 'Component:'.
- # So, searching for the 'Component' in out although we know it is
- # present in second line, as we are not sure about the
- # output format in future versions
- arm_ver_str = re.search('.*Component.*', out)
- if arm_ver_str is None:
- popen_exceptions[' '.join(compiler)] = 'version string not found'
- continue
- arm_ver_str = arm_ver_str.group(0)
- # Override previous values
- version = search_version(arm_ver_str)
- full_version = arm_ver_str
- cls = ArmclangCCompiler if lang == 'c' else ArmclangCPPCompiler
- linker = ArmClangDynamicLinker(for_machine, version=version)
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- return cls(
- ccache + compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
- if 'CL.EXE COMPATIBILITY' in out:
- # if this is clang-cl masquerading as cl, detect it as cl, not
- # clang
- arg = '--version'
- try:
- p, out, err = Popen_safe(compiler + [arg])
- except OSError as e:
- popen_exceptions[' '.join(compiler + [arg])] = e
- version = search_version(out)
- match = re.search('^Target: (.*?)-', out, re.MULTILINE)
- if match:
- target = match.group(1)
- else:
- target = 'unknown target'
- cls = ClangClCCompiler if lang == 'c' else ClangClCPPCompiler
- linker = self._guess_win_linker(['lld-link'], cls, for_machine)
- return cls(
- compiler, version, for_machine, is_cross, info, exe_wrap,
- target, linker=linker)
- if 'clang' in out:
- linker = None
-
- # Even if the for_machine is darwin, we could be using vanilla
- # clang.
- if 'Apple' in out:
- cls = AppleClangCCompiler if lang == 'c' else AppleClangCPPCompiler
- else:
- cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler
-
- if 'windows' in out or self.machines[for_machine].is_windows():
- # If we're in a MINGW context this actually will use a gnu
- # style ld, but for clang on "real" windows we'll use
- # either link.exe or lld-link.exe
- try:
- linker = self._guess_win_linker(compiler, cls, for_machine)
- except MesonException:
- pass
- if linker is None:
- linker = self._guess_nix_linker(compiler, cls, for_machine)
-
- return cls(
- ccache + compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- if 'Intel(R) C++ Intel(R)' in err:
- version = search_version(err)
- target = 'x86' if 'IA-32' in err else 'x86_64'
- cls = IntelClCCompiler if lang == 'c' else IntelClCPPCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = XilinkDynamicLinker(for_machine, [], version=version)
- return cls(
- compiler, version, for_machine, is_cross, info=info,
- exe_wrap=exe_wrap, target=target, linker=linker)
- if 'Microsoft' in out or 'Microsoft' in err:
- # Latest versions of Visual Studio print version
- # number to stderr but earlier ones print version
- # on stdout. Why? Lord only knows.
- # Check both outputs to figure out version.
- for lookat in [err, out]:
- version = search_version(lookat)
- if version != 'unknown version':
- break
- else:
- m = 'Failed to detect MSVC compiler version: stderr was\n{!r}'
- raise EnvironmentException(m.format(err))
- cl_signature = lookat.split('\n')[0]
- match = re.search('.*(x86|x64|ARM|ARM64)$', cl_signature)
- if match:
- target = match.group(1)
- else:
- m = 'Failed to detect MSVC compiler target architecture: \'cl /?\' output is\n{}'
- raise EnvironmentException(m.format(cl_signature))
- cls = VisualStudioCCompiler if lang == 'c' else VisualStudioCPPCompiler
- linker = self._guess_win_linker(['link'], cls, for_machine)
- return cls(
- compiler, version, for_machine, is_cross, info, exe_wrap,
- target, linker=linker)
- if 'PGI Compilers' in out:
- cls = PGICCompiler if lang == 'c' else PGICPPCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
- return cls(
- ccache + compiler, version, for_machine, is_cross,
- info, exe_wrap, linker=linker)
- if '(ICC)' in out:
- cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler
- l = self._guess_nix_linker(compiler, cls, for_machine)
- return cls(
- ccache + compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=l)
- if 'ARM' in out:
- cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = ArmDynamicLinker(for_machine, version=version)
- return cls(
- ccache + compiler, version, for_machine, is_cross,
- info, exe_wrap, full_version=full_version, linker=linker)
- if 'RX Family' in out:
- cls = CcrxCCompiler if lang == 'c' else CcrxCPPCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = CcrxDynamicLinker(for_machine, version=version)
- return cls(
- ccache + compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- self._handle_exceptions(popen_exceptions, compilers)
-
- def detect_c_compiler(self, for_machine):
- return self._detect_c_or_cpp_compiler('c', for_machine)
-
- def detect_cpp_compiler(self, for_machine):
- return self._detect_c_or_cpp_compiler('cpp', for_machine)
-
- def detect_cuda_compiler(self, for_machine):
- popen_exceptions = {}
- is_cross = not self.machines.matches_build_machine(for_machine)
- compilers, ccache, exe_wrap = self._get_compilers('cuda', for_machine)
- info = self.machines[for_machine]
- for compiler in compilers:
- if isinstance(compiler, str):
- compiler = [compiler]
- else:
- raise EnvironmentException()
- arg = '--version'
- try:
- p, out, err = Popen_safe(compiler + [arg])
- except OSError as e:
- popen_exceptions[' '.join(compiler + [arg])] = e
- continue
- # Example nvcc printout:
- #
- # nvcc: NVIDIA (R) Cuda compiler driver
- # Copyright (c) 2005-2018 NVIDIA Corporation
- # Built on Sat_Aug_25_21:08:01_CDT_2018
- # Cuda compilation tools, release 10.0, V10.0.130
- #
- # search_version() first finds the "10.0" after "release",
- # rather than the more precise "10.0.130" after "V".
- # The patch version number is occasionally important; For
- # instance, on Linux,
- # - CUDA Toolkit 8.0.44 requires NVIDIA Driver 367.48
- # - CUDA Toolkit 8.0.61 requires NVIDIA Driver 375.26
- # Luckily, the "V" also makes it very simple to extract
- # the full version:
- version = out.strip().split('V')[-1]
- cpp_compiler = self.detect_cpp_compiler(for_machine)
- cls = CudaCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = CudaLinker(compiler, for_machine, 'nvlink', CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version())
- return cls(ccache + compiler, version, for_machine, is_cross, exe_wrap, host_compiler=cpp_compiler, info=info, linker=linker)
- raise EnvironmentException('Could not find suitable CUDA compiler: "' + ' '.join(compilers) + '"')
-
- def detect_fortran_compiler(self, for_machine: MachineChoice):
- popen_exceptions = {}
- compilers, ccache, exe_wrap = self._get_compilers('fortran', for_machine)
- is_cross = not self.machines.matches_build_machine(for_machine)
- info = self.machines[for_machine]
- for compiler in compilers:
- if isinstance(compiler, str):
- compiler = [compiler]
- for arg in ['--version', '-V']:
- try:
- p, out, err = Popen_safe(compiler + [arg])
- except OSError as e:
- popen_exceptions[' '.join(compiler + [arg])] = e
- continue
-
- version = search_version(out)
- full_version = out.split('\n', 1)[0]
-
- guess_gcc_or_lcc = False
- if 'GNU Fortran' in out:
- guess_gcc_or_lcc = 'gcc'
- if 'e2k' in out and 'lcc' in out:
- guess_gcc_or_lcc = 'lcc'
-
- if guess_gcc_or_lcc:
- defines = self.get_gnu_compiler_defines(compiler)
- if not defines:
- popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
- continue
- if guess_gcc_or_lcc == 'lcc':
- version = self.get_lcc_version_from_defines(defines)
- cls = ElbrusFortranCompiler
- else:
- version = self.get_gnu_version_from_defines(defines)
- cls = GnuFortranCompiler
- linker = self._guess_nix_linker(
- compiler, cls, for_machine)
- return cls(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, defines, full_version=full_version,
- linker=linker)
-
- if 'G95' in out:
- linker = self._guess_nix_linker(
- compiler, cls, for_machine)
- return G95FortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- if 'Sun Fortran' in err:
- version = search_version(err)
- linker = self._guess_nix_linker(
- compiler, cls, for_machine)
- return SunFortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- if 'Intel(R) Visual Fortran' in err:
- version = search_version(err)
- target = 'x86' if 'IA-32' in err else 'x86_64'
- cls = IntelClFortranCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = XilinkDynamicLinker(for_machine, [], version=version)
- return cls(
- compiler, version, for_machine, is_cross, target,
- info, exe_wrap, linker=linker)
-
- if 'ifort (IFORT)' in out:
- linker = self._guess_nix_linker(compiler, IntelFortranCompiler, for_machine)
- return IntelFortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- if 'PathScale EKOPath(tm)' in err:
- return PathScaleFortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version)
-
- if 'PGI Compilers' in out:
- cls = PGIFortranCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- linker = PGIDynamicLinker(compiler, for_machine,
- cls.LINKER_PREFIX, [], version=version)
- return cls(
- compiler, version, for_machine, is_cross, info, exe_wrap,
- full_version=full_version, linker=linker)
-
- if 'flang' in out or 'clang' in out:
- linker = self._guess_nix_linker(
- compiler, FlangFortranCompiler, for_machine)
- return FlangFortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- if 'Open64 Compiler Suite' in err:
- linker = self._guess_nix_linker(
- compiler, Open64FortranCompiler, for_machine)
- return Open64FortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- if 'NAG Fortran' in err:
- linker = self._guess_nix_linker(
- compiler, NAGFortranCompiler, for_machine)
- return NAGFortranCompiler(
- compiler, version, for_machine, is_cross, info,
- exe_wrap, full_version=full_version, linker=linker)
-
- self._handle_exceptions(popen_exceptions, compilers)
-
- def get_scratch_dir(self):
+ def get_scratch_dir(self) -> str:
return self.scratch_dir
- def detect_objc_compiler(self, for_machine: MachineInfo) -> 'Compiler':
- return self._detect_objc_or_objcpp_compiler(for_machine, True)
-
- def detect_objcpp_compiler(self, for_machine: MachineInfo) -> 'Compiler':
- return self._detect_objc_or_objcpp_compiler(for_machine, False)
-
- def _detect_objc_or_objcpp_compiler(self, for_machine: MachineInfo, objc: bool) -> 'Compiler':
- popen_exceptions = {}
- compilers, ccache, exe_wrap = self._get_compilers('objc' if objc else 'objcpp', for_machine)
- is_cross = not self.machines.matches_build_machine(for_machine)
- info = self.machines[for_machine]
-
- for compiler in compilers:
- if isinstance(compiler, str):
- compiler = [compiler]
- arg = ['--version']
- try:
- p, out, err = Popen_safe(compiler + arg)
- except OSError as e:
- popen_exceptions[' '.join(compiler + arg)] = e
- continue
- version = search_version(out)
- if 'Free Software Foundation' in out:
- defines = self.get_gnu_compiler_defines(compiler)
- if not defines:
- popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
- continue
- version = self.get_gnu_version_from_defines(defines)
- comp = GnuObjCCompiler if objc else GnuObjCPPCompiler
- linker = self._guess_nix_linker(compiler, comp, for_machine)
- return comp(
- ccache + compiler, version, for_machine, is_cross, info,
- exe_wrap, defines, linker=linker)
- if 'clang' in out:
- linker = None
- comp = ClangObjCCompiler if objc else ClangObjCPPCompiler
- if 'windows' in out or self.machines[for_machine].is_windows():
- # If we're in a MINGW context this actually will use a gnu style ld
- try:
- linker = self._guess_win_linker(compiler, comp, for_machine)
- except MesonException:
- pass
-
- if not linker:
- linker = self._guess_nix_linker(
- compiler, comp, for_machine)
- return comp(
- ccache + compiler, version, for_machine,
- is_cross, info, exe_wrap, linker=linker)
- self._handle_exceptions(popen_exceptions, compilers)
-
- def detect_java_compiler(self, for_machine):
- exelist = self.binaries.host.lookup_entry('java')
- info = self.machines[for_machine]
- if exelist is None:
- # TODO support fallback
- exelist = [self.default_java[0]]
-
- try:
- p, out, err = Popen_safe(exelist + ['-version'])
- except OSError:
- raise EnvironmentException('Could not execute Java compiler "%s"' % ' '.join(exelist))
- if 'javac' in out or 'javac' in err:
- version = search_version(err if 'javac' in err else out)
- if not version or version == 'unknown version':
- parts = (err if 'javac' in err else out).split()
- if len(parts) > 1:
- version = parts[1]
- comp_class = JavaCompiler
- self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
- return comp_class(exelist, version, for_machine, info)
- raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
- def detect_cs_compiler(self, for_machine):
- compilers, ccache, exe_wrap = self._get_compilers('cs', for_machine)
- popen_exceptions = {}
- info = self.machines[for_machine]
- for comp in compilers:
- if not isinstance(comp, list):
- comp = [comp]
- try:
- p, out, err = Popen_safe(comp + ['--version'])
- except OSError as e:
- popen_exceptions[' '.join(comp + ['--version'])] = e
- continue
-
- version = search_version(out)
- if 'Mono' in out:
- cls = MonoCompiler
- elif "Visual C#" in out:
- cls = VisualStudioCsCompiler
- self.coredata.add_lang_args(cls.language, cls, for_machine, self)
- return cls(comp, version, for_machine, info)
-
- self._handle_exceptions(popen_exceptions, compilers)
-
- def detect_vala_compiler(self, for_machine):
- exelist = self.binaries.host.lookup_entry('vala')
- is_cross = not self.machines.matches_build_machine(for_machine)
- info = self.machines[for_machine]
- if exelist is None:
- # TODO support fallback
- exelist = [self.default_vala[0]]
-
- try:
- p, out = Popen_safe(exelist + ['--version'])[0:2]
- except OSError:
- raise EnvironmentException('Could not execute Vala compiler "%s"' % ' '.join(exelist))
- version = search_version(out)
- if 'Vala' in out:
- comp_class = ValaCompiler
- self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
- return comp_class(exelist, version, for_machine, info, is_cross)
- raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
- def detect_rust_compiler(self, for_machine):
- popen_exceptions = {}
- compilers, ccache, exe_wrap = self._get_compilers('rust', for_machine)
- is_cross = not self.machines.matches_build_machine(for_machine)
- info = self.machines[for_machine]
-
- cc = self.detect_c_compiler(for_machine)
- is_link_exe = isinstance(cc.linker, VisualStudioLikeLinkerMixin)
- override = self.binaries[for_machine].lookup_entry('rust_ld')
-
- for compiler in compilers:
- if isinstance(compiler, str):
- compiler = [compiler]
- arg = ['--version']
- try:
- p, out = Popen_safe(compiler + arg)[0:2]
- except OSError as e:
- popen_exceptions[' '.join(compiler + arg)] = e
- continue
-
- version = search_version(out)
-
- if 'rustc' in out:
- # On Linux and mac rustc will invoke gcc (clang for mac
- # presumably) and it can do this windows, for dynamic linking.
- # this means the easiest way to C compiler for dynamic linking.
- # figure out what linker to use is to just get the value of the
- # C compiler and use that as the basis of the rust linker.
- # However, there are two things we need to change, if CC is not
- # the default use that, and second add the necessary arguments
- # to rust to use -fuse-ld
-
- if override is None:
- extra_args = {}
- always_args = []
- if is_link_exe:
- compiler.extend(['-C', 'linker={}'.format(cc.linker.exelist[0])])
- extra_args['direct'] = True
- extra_args['machine'] = cc.linker.machine
- elif not ((info.is_darwin() and isinstance(cc, AppleClangCCompiler)) or
- isinstance(cc, GnuCCompiler)):
- c = cc.exelist[1] if cc.exelist[0].endswith('ccache') else cc.exelist[0]
- compiler.extend(['-C', 'linker={}'.format(c)])
-
- # This trickery with type() gets us the class of the linker
- # so we can initialize a new copy for the Rust Compiler
- if is_link_exe:
- linker = type(cc.linker)(for_machine, always_args, exelist=cc.linker.exelist,
- version=cc.linker.version, **extra_args)
- else:
- linker = type(cc.linker)(compiler, for_machine, cc.LINKER_PREFIX,
- always_args=always_args, version=cc.linker.version,
- **extra_args)
- elif 'link' in override[0]:
- linker = self._guess_win_linker(
- override, RustCompiler, for_machine, use_linker_prefix=False)
- linker.direct = True
- else:
- # We're creating a new type of "C" compiler, that has rust
- # as it's language. This is gross, but I can't figure out
- # another way to handle this, because rustc is actually
- # invoking the c compiler as it's linker.
- b = type('b', (type(cc), ), {})
- b.language = RustCompiler.language
- linker = self._guess_nix_linker(cc.exelist, b, for_machine)
-
- # Of course, we're not going to use any of that, we just
- # need it to get the proper arguments to pass to rustc
- c = cc.exelist[1] if cc.exelist[0].endswith('ccache') else cc.exelist[0]
- compiler.extend(['-C', 'linker={}'.format(c)])
- compiler.extend(['-C', 'link-args={}'.format(' '.join(cc.use_linker_args(override[0])))])
-
- self.coredata.add_lang_args(RustCompiler.language, RustCompiler, for_machine, self)
- return RustCompiler(
- compiler, version, for_machine, is_cross, info, exe_wrap,
- linker=linker)
-
- self._handle_exceptions(popen_exceptions, compilers)
-
- def detect_d_compiler(self, for_machine: MachineChoice):
- info = self.machines[for_machine]
-
- # Detect the target architecture, required for proper architecture handling on Windows.
- # MSVC compiler is required for correct platform detection.
- c_compiler = {'c': self.detect_c_compiler(for_machine)}
- is_msvc = isinstance(c_compiler['c'], VisualStudioCCompiler)
- if not is_msvc:
- c_compiler = {}
-
- arch = detect_cpu_family(c_compiler)
- if is_msvc and arch == 'x86':
- arch = 'x86_mscoff'
-
- popen_exceptions = {}
- is_cross = not self.machines.matches_build_machine(for_machine)
- results, ccache, exe_wrap = self._get_compilers('d', for_machine)
- for exelist in results:
- # Search for a D compiler.
- # We prefer LDC over GDC unless overridden with the DC
- # environment variable because LDC has a much more
- # up to date language version at time (2016).
- if not isinstance(exelist, list):
- exelist = [exelist]
- if os.path.basename(exelist[-1]).startswith(('ldmd', 'gdmd')):
- raise EnvironmentException(
- 'Meson does not support {} as it is only a DMD frontend for another compiler.'
- 'Please provide a valid value for DC or unset it so that Meson can resolve the compiler by itself.'.format(exelist[-1]))
- try:
- p, out = Popen_safe(exelist + ['--version'])[0:2]
- except OSError as e:
- popen_exceptions[' '.join(exelist + ['--version'])] = e
- continue
- version = search_version(out)
- full_version = out.split('\n', 1)[0]
-
- if 'LLVM D compiler' in out:
- # LDC seems to require a file
- if info.is_windows() or info.is_cygwin():
- # Getting LDC on windows to give useful linker output when
- # not doing real work is painfully hard. It ships with a
- # version of lld-link, so unless we think the user wants
- # link.exe, just assume that we're going to use lld-link
- # with it.
- linker = self._guess_win_linker(
- ['link' if is_msvc else 'lld-link'],
- compilers.LLVMDCompiler, for_machine, use_linker_prefix=False)
- else:
- with tempfile.NamedTemporaryFile(suffix='.d') as f:
- # LDC writes an object file to the current working directory.
- # Clean it up.
- objectfile = os.path.basename(f.name)[:-1] + 'o'
- linker = self._guess_nix_linker(
- exelist, compilers.LLVMDCompiler, for_machine,
- extra_args=[f.name])
- try:
- os.unlink(objectfile)
- except Exception:
- # Thank you Windows file system semantics and virus scanners.
- pass
- return compilers.LLVMDCompiler(
- exelist, version, for_machine, info, arch,
- full_version=full_version, linker=linker)
- elif 'gdc' in out:
- linker = self._guess_nix_linker(exelist, compilers.GnuDCompiler, for_machine)
- return compilers.GnuDCompiler(
- exelist, version, for_machine, info, arch, is_cross, exe_wrap,
- full_version=full_version, linker=linker)
- elif 'The D Language Foundation' in out or 'Digital Mars' in out:
- # DMD seems to require a file
- if info.is_windows() or info.is_cygwin():
- if is_msvc:
- linker_cmd = ['link']
- elif arch == 'x86':
- linker_cmd = ['optlink']
- else:
- linker_cmd = ['lld-link']
- linker = self._guess_win_linker(linker_cmd, compilers.DmdDCompiler, for_machine,
- use_linker_prefix=False)
- else:
- with tempfile.NamedTemporaryFile(suffix='.d') as f:
- linker = self._guess_nix_linker(
- exelist, compilers.DmdDCompiler, for_machine,
- extra_args=[f.name])
- return compilers.DmdDCompiler(
- exelist, version, for_machine, info, arch,
- full_version=full_version, linker=linker)
- raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
- self._handle_exceptions(popen_exceptions, compilers)
-
- def detect_swift_compiler(self, for_machine):
- exelist = self.binaries.host.lookup_entry('swift')
- is_cross = not self.machines.matches_build_machine(for_machine)
- info = self.machines[for_machine]
- if exelist is None:
- # TODO support fallback
- exelist = [self.default_swift[0]]
-
- try:
- p, _, err = Popen_safe(exelist + ['-v'])
- except OSError:
- raise EnvironmentException('Could not execute Swift compiler "%s"' % ' '.join(exelist))
- version = search_version(err)
- if 'Swift' in err:
- # As for 5.0.1 swiftc *requires* a file to check the linker:
- with tempfile.NamedTemporaryFile(suffix='.swift') as f:
- linker = self._guess_nix_linker(
- exelist, compilers.SwiftCompiler, for_machine,
- extra_args=[f.name])
- return compilers.SwiftCompiler(
- exelist, version, for_machine, info, is_cross, linker=linker)
-
- raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
- def compiler_from_language(self, lang: str, for_machine: MachineChoice):
- if lang == 'c':
- comp = self.detect_c_compiler(for_machine)
- elif lang == 'cpp':
- comp = self.detect_cpp_compiler(for_machine)
- elif lang == 'objc':
- comp = self.detect_objc_compiler(for_machine)
- elif lang == 'cuda':
- comp = self.detect_cuda_compiler(for_machine)
- elif lang == 'objcpp':
- comp = self.detect_objcpp_compiler(for_machine)
- elif lang == 'java':
- comp = self.detect_java_compiler(for_machine)
- elif lang == 'cs':
- comp = self.detect_cs_compiler(for_machine)
- elif lang == 'vala':
- comp = self.detect_vala_compiler(for_machine)
- elif lang == 'd':
- comp = self.detect_d_compiler(for_machine)
- elif lang == 'rust':
- comp = self.detect_rust_compiler(for_machine)
- elif lang == 'fortran':
- comp = self.detect_fortran_compiler(for_machine)
- elif lang == 'swift':
- comp = self.detect_swift_compiler(for_machine)
- else:
- comp = None
- return comp
-
- def detect_compiler_for(self, lang: str, for_machine: MachineChoice):
- comp = self.compiler_from_language(lang, for_machine)
- if comp is not None:
- assert comp.for_machine == for_machine
- self.coredata.process_new_compiler(lang, comp, self)
- return comp
-
- def detect_static_linker(self, compiler):
- linker = self.binaries[compiler.for_machine].lookup_entry('ar')
- if linker is not None:
- linkers = [linker]
- else:
- evar = 'AR'
- defaults = [[l] for l in self.default_static_linker]
- if isinstance(compiler, compilers.CudaCompiler):
- linkers = [self.cuda_static_linker] + defaults
- elif evar in os.environ:
- linkers = [split_args(os.environ[evar])]
- elif isinstance(compiler, compilers.VisualStudioLikeCompiler):
- linkers = [self.vs_static_linker, self.clang_cl_static_linker]
- elif isinstance(compiler, compilers.GnuCompiler):
- # Use gcc-ar if available; needed for LTO
- linkers = [self.gcc_static_linker] + defaults
- elif isinstance(compiler, compilers.ClangCompiler):
- # Use llvm-ar if available; needed for LTO
- linkers = [self.clang_static_linker] + defaults
- elif isinstance(compiler, compilers.DCompiler):
- # Prefer static linkers over linkers used by D compilers
- if mesonlib.is_windows():
- linkers = [self.vs_static_linker, self.clang_cl_static_linker, compiler.get_linker_exelist()]
- else:
- linkers = defaults
- elif isinstance(compiler, IntelClCCompiler):
- # Intel has it's own linker that acts like microsoft's lib
- linkers = ['xilib']
- elif isinstance(compiler, (PGICCompiler, PGIFortranCompiler)) and mesonlib.is_windows():
- linkers = [['ar']] # For PGI on Windows, "ar" is just a wrapper calling link/lib.
- else:
- linkers = defaults
- popen_exceptions = {}
- for linker in linkers:
- if not {'lib', 'lib.exe', 'llvm-lib', 'llvm-lib.exe', 'xilib', 'xilib.exe'}.isdisjoint(linker):
- arg = '/?'
- else:
- arg = '--version'
- try:
- p, out, err = Popen_safe(linker + [arg])
- except OSError as e:
- popen_exceptions[' '.join(linker + [arg])] = e
- continue
- if "xilib: executing 'lib'" in err:
- return IntelVisualStudioLinker(linker, getattr(compiler, 'machine', None))
- if '/OUT:' in out.upper() or '/OUT:' in err.upper():
- return VisualStudioLinker(linker, getattr(compiler, 'machine', None))
- if 'ar-Error-Unknown switch: --version' in err:
- return PGIStaticLinker(linker)
- if p.returncode == 0 and ('armar' in linker or 'armar.exe' in linker):
- return ArmarLinker(linker)
- if 'DMD32 D Compiler' in out or 'DMD64 D Compiler' in out:
- return DLinker(linker, compiler.arch)
- if 'LDC - the LLVM D compiler' in out:
- return DLinker(linker, compiler.arch)
- if 'GDC' in out and ' based on D ' in out:
- return DLinker(linker, compiler.arch)
- if err.startswith('Renesas') and ('rlink' in linker or 'rlink.exe' in linker):
- return CcrxLinker(linker)
- if p.returncode == 0:
- return ArLinker(linker)
- if p.returncode == 1 and err.startswith('usage'): # OSX
- return ArLinker(linker)
- if p.returncode == 1 and err.startswith('Usage'): # AIX
- return ArLinker(linker)
- if p.returncode == 1 and err.startswith('ar: bad option: --'): # Solaris
- return ArLinker(linker)
- self._handle_exceptions(popen_exceptions, linkers, 'linker')
- raise EnvironmentException('Unknown static linker "%s"' % ' '.join(linkers))
-
- def get_source_dir(self):
+ def get_source_dir(self) -> str:
return self.source_dir
- def get_build_dir(self):
+ def get_build_dir(self) -> str:
return self.build_dir
def get_import_lib_dir(self) -> str:
@@ -1687,25 +819,25 @@
return self.get_libdir()
def get_prefix(self) -> str:
- return self.coredata.get_builtin_option('prefix')
+ return self.coredata.get_option(OptionKey('prefix'))
def get_libdir(self) -> str:
- return self.coredata.get_builtin_option('libdir')
+ return self.coredata.get_option(OptionKey('libdir'))
def get_libexecdir(self) -> str:
- return self.coredata.get_builtin_option('libexecdir')
+ return self.coredata.get_option(OptionKey('libexecdir'))
def get_bindir(self) -> str:
- return self.coredata.get_builtin_option('bindir')
+ return self.coredata.get_option(OptionKey('bindir'))
def get_includedir(self) -> str:
- return self.coredata.get_builtin_option('includedir')
+ return self.coredata.get_option(OptionKey('includedir'))
def get_mandir(self) -> str:
- return self.coredata.get_builtin_option('mandir')
+ return self.coredata.get_option(OptionKey('mandir'))
def get_datadir(self) -> str:
- return self.coredata.get_builtin_option('datadir')
+ return self.coredata.get_option(OptionKey('datadir'))
def get_compiler_system_dirs(self, for_machine: MachineChoice):
for comp in self.coredata.compilers[for_machine].values():
@@ -1732,8 +864,7 @@
return value
return not machine_info_can_run(self.machines[for_machine])
- def get_exe_wrapper(self):
+ def get_exe_wrapper(self) -> ExternalProgram:
if not self.need_exe_wrapper():
- from .dependencies import EmptyExternalProgram
return EmptyExternalProgram()
return self.exe_wrapper
diff -Nru meson-0.53.2/mesonbuild/interpreter/compiler.py meson-0.61.2/mesonbuild/interpreter/compiler.py
--- meson-0.53.2/mesonbuild/interpreter/compiler.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/compiler.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,745 @@
+# SPDX-Licnese-Identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+import enum
+import functools
+import typing as T
+
+from .. import build
+from .. import coredata
+from .. import dependencies
+from .. import mesonlib
+from .. import mlog
+from ..compilers import SUFFIX_TO_LANG
+from ..compilers.compilers import CompileCheckMode
+from ..interpreterbase import (ObjectHolder, noPosargs, noKwargs,
+ FeatureNew, disablerIfNotFound,
+ InterpreterException)
+from ..interpreterbase.decorators import ContainerTypeInfo, typed_kwargs, KwargInfo, typed_pos_args
+from .interpreterobjects import (extract_required_kwarg, extract_search_dirs)
+from .type_checking import REQUIRED_KW, in_set_validator, NoneType
+
+if T.TYPE_CHECKING:
+ from ..interpreter import Interpreter
+ from ..compilers import Compiler, RunResult
+ from ..interpreterbase import TYPE_var, TYPE_kwargs
+ from .kwargs import ExtractRequired, ExtractSearchDirs
+
+ from typing_extensions import TypedDict, Literal
+
+ class GetSupportedArgumentKw(TypedDict):
+
+ checked: Literal['warn', 'require', 'off']
+
+ class AlignmentKw(TypedDict):
+
+ prefix: str
+ args: T.List[str]
+ dependencies: T.List[dependencies.Dependency]
+
+ class CompileKW(TypedDict):
+
+ name: str
+ no_builtin_args: bool
+ include_directories: T.List[build.IncludeDirs]
+ args: T.List[str]
+ dependencies: T.List[dependencies.Dependency]
+
+ class CommonKW(TypedDict):
+
+ prefix: str
+ no_builtin_args: bool
+ include_directories: T.List[build.IncludeDirs]
+ args: T.List[str]
+ dependencies: T.List[dependencies.Dependency]
+
+ class CompupteIntKW(CommonKW):
+
+ guess: T.Optional[int]
+ high: T.Optional[int]
+ low: T.Optional[int]
+
+ class HeaderKW(CommonKW, ExtractRequired):
+ pass
+
+ class FindLibraryKW(ExtractRequired, ExtractSearchDirs):
+
+ disabler: bool
+ has_headers: T.List[str]
+ static: bool
+
+ # This list must be all of the `HeaderKW` values with `header_`
+ # prepended to the key
+ header_args: T.List[str]
+ header_dependencies: T.List[dependencies.Dependency]
+ header_include_directories: T.List[build.IncludeDirs]
+ header_no_builtin_args: bool
+ header_prefix: str
+ header_required: T.Union[bool, coredata.UserFeatureOption]
+
+
+class _TestMode(enum.Enum):
+
+ """Whether we're doing a compiler or linker check."""
+
+ COMPILER = 0
+ LINKER = 1
+
+
+class TryRunResultHolder(ObjectHolder['RunResult']):
+ def __init__(self, res: 'RunResult', interpreter: 'Interpreter'):
+ super().__init__(res, interpreter)
+ self.methods.update({'returncode': self.returncode_method,
+ 'compiled': self.compiled_method,
+ 'stdout': self.stdout_method,
+ 'stderr': self.stderr_method,
+ })
+
+ @noPosargs
+ @noKwargs
+ def returncode_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> int:
+ return self.held_object.returncode
+
+ @noPosargs
+ @noKwargs
+ def compiled_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self.held_object.compiled
+
+ @noPosargs
+ @noKwargs
+ def stdout_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.held_object.stdout
+
+ @noPosargs
+ @noKwargs
+ def stderr_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.held_object.stderr
+
+
+_ARGS_KW: KwargInfo[T.List[str]] = KwargInfo(
+ 'args',
+ ContainerTypeInfo(list, str),
+ listify=True,
+ default=[],
+)
+_DEPENDENCIES_KW: KwargInfo[T.List['dependencies.Dependency']] = KwargInfo(
+ 'dependencies',
+ ContainerTypeInfo(list, dependencies.Dependency),
+ listify=True,
+ default=[],
+)
+_INCLUDE_DIRS_KW: KwargInfo[T.List[build.IncludeDirs]] = KwargInfo(
+ 'include_directories',
+ ContainerTypeInfo(list, build.IncludeDirs),
+ default=[],
+ listify=True,
+)
+_PREFIX_KW = KwargInfo('prefix', str, default='')
+_NO_BUILTIN_ARGS_KW = KwargInfo('no_builtin_args', bool, default=False)
+_NAME_KW = KwargInfo('name', str, default='')
+
+# Many of the compiler methods take this kwarg signature exactly, this allows
+# simplifying the `typed_kwargs` calls
+_COMMON_KWS: T.List[KwargInfo] = [_ARGS_KW, _DEPENDENCIES_KW, _INCLUDE_DIRS_KW, _PREFIX_KW, _NO_BUILTIN_ARGS_KW]
+
+# Common methods of compiles, links, runs, and similar
+_COMPILES_KWS: T.List[KwargInfo] = [_NAME_KW, _ARGS_KW, _DEPENDENCIES_KW, _INCLUDE_DIRS_KW, _NO_BUILTIN_ARGS_KW]
+
+_HEADER_KWS: T.List[KwargInfo] = [REQUIRED_KW.evolve(since='0.50.0', default=False), *_COMMON_KWS]
+
+class CompilerHolder(ObjectHolder['Compiler']):
+ def __init__(self, compiler: 'Compiler', interpreter: 'Interpreter'):
+ super().__init__(compiler, interpreter)
+ self.environment = self.env
+ self.methods.update({'compiles': self.compiles_method,
+ 'links': self.links_method,
+ 'get_id': self.get_id_method,
+ 'get_linker_id': self.get_linker_id_method,
+ 'compute_int': self.compute_int_method,
+ 'sizeof': self.sizeof_method,
+ 'get_define': self.get_define_method,
+ 'check_header': self.check_header_method,
+ 'has_header': self.has_header_method,
+ 'has_header_symbol': self.has_header_symbol_method,
+ 'run': self.run_method,
+ 'has_function': self.has_function_method,
+ 'has_member': self.has_member_method,
+ 'has_members': self.has_members_method,
+ 'has_type': self.has_type_method,
+ 'alignment': self.alignment_method,
+ 'version': self.version_method,
+ 'cmd_array': self.cmd_array_method,
+ 'find_library': self.find_library_method,
+ 'has_argument': self.has_argument_method,
+ 'has_function_attribute': self.has_func_attribute_method,
+ 'get_supported_function_attributes': self.get_supported_function_attributes_method,
+ 'has_multi_arguments': self.has_multi_arguments_method,
+ 'get_supported_arguments': self.get_supported_arguments_method,
+ 'first_supported_argument': self.first_supported_argument_method,
+ 'has_link_argument': self.has_link_argument_method,
+ 'has_multi_link_arguments': self.has_multi_link_arguments_method,
+ 'get_supported_link_arguments': self.get_supported_link_arguments_method,
+ 'first_supported_link_argument': self.first_supported_link_argument_method,
+ 'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
+ 'get_argument_syntax': self.get_argument_syntax_method,
+ })
+
+ @property
+ def compiler(self) -> 'Compiler':
+ return self.held_object
+
+ def _dep_msg(self, deps: T.List['dependencies.Dependency'], endl: str) -> str:
+ msg_single = 'with dependency {}'
+ msg_many = 'with dependencies {}'
+ if not deps:
+ return endl
+ if endl is None:
+ endl = ''
+ names = []
+ for d in deps:
+ if isinstance(d, dependencies.InternalDependency):
+ FeatureNew.single_use('compiler method "dependencies" kwarg with internal dep', '0.57.0', self.subproject,
+ location=self.current_node)
+ continue
+ if isinstance(d, dependencies.ExternalLibrary):
+ name = '-l' + d.name
+ else:
+ name = d.name
+ names.append(name)
+ if not names:
+ return None
+ tpl = msg_many if len(names) > 1 else msg_single
+ return tpl.format(', '.join(names)) + endl
+
+ @noPosargs
+ @noKwargs
+ def version_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.compiler.version
+
+ @noPosargs
+ @noKwargs
+ def cmd_array_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> T.List[str]:
+ return self.compiler.exelist
+
+ def _determine_args(self, nobuiltins: bool,
+ incdirs: T.List[build.IncludeDirs],
+ extra_args: T.List[str],
+ mode: CompileCheckMode = CompileCheckMode.LINK) -> T.List[str]:
+ args: T.List[str] = []
+ for i in incdirs:
+ for idir in i.to_string_list(self.environment.get_source_dir()):
+ args.extend(self.compiler.get_include_args(idir, False))
+ if not nobuiltins:
+ opts = self.environment.coredata.options
+ args += self.compiler.get_option_compile_args(opts)
+ if mode is CompileCheckMode.LINK:
+ args.extend(self.compiler.get_option_link_args(opts))
+ args.extend(extra_args)
+ return args
+
+ def _determine_dependencies(self, deps: T.List['dependencies.Dependency'], endl: str = ':') -> T.Tuple[T.List['dependencies.Dependency'], str]:
+ if deps:
+ final_deps = []
+ while deps:
+ next_deps = []
+ for d in mesonlib.listify(deps):
+ if not isinstance(d, dependencies.Dependency) or d.is_built():
+ raise InterpreterException('Dependencies must be external dependencies')
+ final_deps.append(d)
+ next_deps.extend(d.ext_deps)
+ deps = next_deps
+ deps = final_deps
+ else:
+ # Ensure that we always return a new instance
+ deps = deps.copy()
+ return deps, self._dep_msg(deps, endl)
+
+ @typed_pos_args('compiler.alignment', str)
+ @typed_kwargs(
+ 'compiler.alignment',
+ _PREFIX_KW,
+ _ARGS_KW,
+ _DEPENDENCIES_KW,
+ )
+ def alignment_method(self, args: T.Tuple[str], kwargs: 'AlignmentKw') -> int:
+ typename = args[0]
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ result = self.compiler.alignment(typename, kwargs['prefix'], self.environment,
+ extra_args=kwargs['args'],
+ dependencies=deps)
+ mlog.log('Checking for alignment of', mlog.bold(typename, True), msg, result)
+ return result
+
+ @typed_pos_args('compiler.run', (str, mesonlib.File))
+ @typed_kwargs('compiler.run', *_COMPILES_KWS)
+ def run_method(self, args: T.Tuple['mesonlib.FileOrString'], kwargs: 'CompileKW') -> 'RunResult':
+ code = args[0]
+ if isinstance(code, mesonlib.File):
+ self.interpreter.add_build_def_file(code)
+ code = mesonlib.File.from_absolute_file(
+ code.rel_to_builddir(self.environment.source_dir))
+ testname = kwargs['name']
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'], endl=None)
+ result = self.compiler.run(code, self.environment, extra_args=extra_args,
+ dependencies=deps)
+ if testname:
+ if not result.compiled:
+ h = mlog.red('DID NOT COMPILE')
+ elif result.returncode == 0:
+ h = mlog.green('YES')
+ else:
+ h = mlog.red(f'NO ({result.returncode})')
+ mlog.log('Checking if', mlog.bold(testname, True), msg, 'runs:', h)
+ return result
+
+ @noPosargs
+ @noKwargs
+ def get_id_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.compiler.get_id()
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('compiler.get_linker_id', '0.53.0')
+ def get_linker_id_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.compiler.get_linker_id()
+
+ @noPosargs
+ @noKwargs
+ def symbols_have_underscore_prefix_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ '''
+ Check if the compiler prefixes _ (underscore) to global C symbols
+ See: https://en.wikipedia.org/wiki/Name_mangling#C
+ '''
+ return self.compiler.symbols_have_underscore_prefix(self.environment)
+
+ @typed_pos_args('compiler.has_member', str, str)
+ @typed_kwargs('compiler.has_member', *_COMMON_KWS)
+ def has_member_method(self, args: T.Tuple[str, str], kwargs: 'CommonKW') -> bool:
+ typename, membername = args
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ had, cached = self.compiler.has_members(typename, [membername], kwargs['prefix'],
+ self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if had:
+ hadtxt = mlog.green('YES')
+ else:
+ hadtxt = mlog.red('NO')
+ mlog.log('Checking whether type', mlog.bold(typename, True),
+ 'has member', mlog.bold(membername, True), msg, hadtxt, cached_msg)
+ return had
+
+ @typed_pos_args('compiler.has_members', str, varargs=str, min_varargs=1)
+ @typed_kwargs('compiler.has_members', *_COMMON_KWS)
+ def has_members_method(self, args: T.Tuple[str, T.List[str]], kwargs: 'CommonKW') -> bool:
+ typename, membernames = args
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ had, cached = self.compiler.has_members(typename, membernames, kwargs['prefix'],
+ self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if had:
+ hadtxt = mlog.green('YES')
+ else:
+ hadtxt = mlog.red('NO')
+ members = mlog.bold(', '.join([f'"{m}"' for m in membernames]))
+ mlog.log('Checking whether type', mlog.bold(typename, True),
+ 'has members', members, msg, hadtxt, cached_msg)
+ return had
+
+ @typed_pos_args('compiler.has_function', str)
+ @typed_kwargs('compiler.has_function', *_COMMON_KWS)
+ def has_function_method(self, args: T.Tuple[str], kwargs: 'CommonKW') -> bool:
+ funcname = args[0]
+ extra_args = self._determine_args(kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ had, cached = self.compiler.has_function(funcname, kwargs['prefix'], self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if had:
+ hadtxt = mlog.green('YES')
+ else:
+ hadtxt = mlog.red('NO')
+ mlog.log('Checking for function', mlog.bold(funcname, True), msg, hadtxt, cached_msg)
+ return had
+
+ @typed_pos_args('compiler.has_type', str)
+ @typed_kwargs('compiler.has_type', *_COMMON_KWS)
+ def has_type_method(self, args: T.Tuple[str], kwargs: 'CommonKW') -> bool:
+ typename = args[0]
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ had, cached = self.compiler.has_type(typename, kwargs['prefix'], self.environment,
+ extra_args=extra_args, dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if had:
+ hadtxt = mlog.green('YES')
+ else:
+ hadtxt = mlog.red('NO')
+ mlog.log('Checking for type', mlog.bold(typename, True), msg, hadtxt, cached_msg)
+ return had
+
+ @FeatureNew('compiler.compute_int', '0.40.0')
+ @typed_pos_args('compiler.compute_int', str)
+ @typed_kwargs(
+ 'compiler.compute_int',
+ KwargInfo('low', (int, NoneType)),
+ KwargInfo('high', (int, NoneType)),
+ KwargInfo('guess', (int, NoneType)),
+ *_COMMON_KWS,
+ )
+ def compute_int_method(self, args: T.Tuple[str], kwargs: 'CompupteIntKW') -> int:
+ expression = args[0]
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ res = self.compiler.compute_int(expression, kwargs['low'], kwargs['high'],
+ kwargs['guess'], kwargs['prefix'],
+ self.environment, extra_args=extra_args,
+ dependencies=deps)
+ mlog.log('Computing int of', mlog.bold(expression, True), msg, res)
+ return res
+
+ @typed_pos_args('compiler.sizeof', str)
+ @typed_kwargs('compiler.sizeof', *_COMMON_KWS)
+ def sizeof_method(self, args: T.Tuple[str], kwargs: 'CommonKW') -> int:
+ element = args[0]
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ esize = self.compiler.sizeof(element, kwargs['prefix'], self.environment,
+ extra_args=extra_args, dependencies=deps)
+ mlog.log('Checking for size of', mlog.bold(element, True), msg, esize)
+ return esize
+
+ @FeatureNew('compiler.get_define', '0.40.0')
+ @typed_pos_args('compiler.get_define', str)
+ @typed_kwargs('compiler.get_define', *_COMMON_KWS)
+ def get_define_method(self, args: T.Tuple[str], kwargs: 'CommonKW') -> str:
+ element = args[0]
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ value, cached = self.compiler.get_define(element, kwargs['prefix'], self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ mlog.log('Fetching value of define', mlog.bold(element, True), msg, value, cached_msg)
+ return value
+
+ @typed_pos_args('compiler.compiles', (str, mesonlib.File))
+ @typed_kwargs('compiler.compiles', *_COMPILES_KWS)
+ def compiles_method(self, args: T.Tuple['mesonlib.FileOrString'], kwargs: 'CompileKW') -> bool:
+ code = args[0]
+ if isinstance(code, mesonlib.File):
+ self.interpreter.add_build_def_file(code)
+ code = mesonlib.File.from_absolute_file(
+ code.rel_to_builddir(self.environment.source_dir))
+ testname = kwargs['name']
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'], endl=None)
+ result, cached = self.compiler.compiles(code, self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ if testname:
+ if result:
+ h = mlog.green('YES')
+ else:
+ h = mlog.red('NO')
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ mlog.log('Checking if', mlog.bold(testname, True), msg, 'compiles:', h, cached_msg)
+ return result
+
+ @typed_pos_args('compiler.links', (str, mesonlib.File))
+ @typed_kwargs('compiler.links', *_COMPILES_KWS)
+ def links_method(self, args: T.Tuple['mesonlib.FileOrString'], kwargs: 'CompileKW') -> bool:
+ code = args[0]
+ compiler = None
+ if isinstance(code, mesonlib.File):
+ self.interpreter.add_build_def_file(code)
+ code = mesonlib.File.from_absolute_file(
+ code.rel_to_builddir(self.environment.source_dir))
+ suffix = code.suffix
+ if suffix not in self.compiler.file_suffixes:
+ for_machine = self.compiler.for_machine
+ clist = self.interpreter.coredata.compilers[for_machine]
+ if suffix not in SUFFIX_TO_LANG:
+ # just pass it to the compiler driver
+ mlog.warning(f'Unknown suffix for test file {code}')
+ elif SUFFIX_TO_LANG[suffix] not in clist:
+ mlog.warning(f'Passed {SUFFIX_TO_LANG[suffix]} source to links method, not specified for {for_machine.get_lower_case_name()} machine.')
+ else:
+ compiler = clist[SUFFIX_TO_LANG[suffix]]
+
+ testname = kwargs['name']
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ result, cached = self.compiler.links(code, self.environment,
+ compiler=compiler,
+ extra_args=extra_args,
+ dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if testname:
+ if result:
+ h = mlog.green('YES')
+ else:
+ h = mlog.red('NO')
+ mlog.log('Checking if', mlog.bold(testname, True), msg, 'links:', h, cached_msg)
+ return result
+
+ @FeatureNew('compiler.check_header', '0.47.0')
+ @typed_pos_args('compiler.check_header', str)
+ @typed_kwargs('compiler.check_header', *_HEADER_KWS)
+ def check_header_method(self, args: T.Tuple[str], kwargs: 'HeaderKW') -> bool:
+ hname = args[0]
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
+ if disabled:
+ mlog.log('Check usable header', mlog.bold(hname, True), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return False
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ haz, cached = self.compiler.check_header(hname, kwargs['prefix'], self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if required and not haz:
+ raise InterpreterException(f'{self.compiler.get_display_language()} header {hname!r} not usable')
+ elif haz:
+ h = mlog.green('YES')
+ else:
+ h = mlog.red('NO')
+ mlog.log('Check usable header', mlog.bold(hname, True), msg, h, cached_msg)
+ return haz
+
+ def _has_header_impl(self, hname: str, kwargs: 'HeaderKW') -> bool:
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
+ if disabled:
+ mlog.log('Has header', mlog.bold(hname, True), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return False
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ haz, cached = self.compiler.has_header(hname, kwargs['prefix'], self.environment,
+ extra_args=extra_args, dependencies=deps)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ if required and not haz:
+ raise InterpreterException(f'{self.compiler.get_display_language()} header {hname!r} not found')
+ elif haz:
+ h = mlog.green('YES')
+ else:
+ h = mlog.red('NO')
+ mlog.log('Has header', mlog.bold(hname, True), msg, h, cached_msg)
+ return haz
+
+ @typed_pos_args('compiler.has_header', str)
+ @typed_kwargs('compiler.has_header', *_HEADER_KWS)
+ def has_header_method(self, args: T.Tuple[str], kwargs: 'HeaderKW') -> bool:
+ return self._has_header_impl(args[0], kwargs)
+
+ @typed_pos_args('compiler.has_header_symbol', str, str)
+ @typed_kwargs('compiler.has_header_symbol', *_HEADER_KWS)
+ def has_header_symbol_method(self, args: T.Tuple[str, str], kwargs: 'HeaderKW') -> bool:
+ hname, symbol = args
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
+ if disabled:
+ mlog.log(f'Header <{hname}> has symbol', mlog.bold(symbol, True), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return False
+ extra_args = functools.partial(self._determine_args, kwargs['no_builtin_args'], kwargs['include_directories'], kwargs['args'])
+ deps, msg = self._determine_dependencies(kwargs['dependencies'])
+ haz, cached = self.compiler.has_header_symbol(hname, symbol, kwargs['prefix'], self.environment,
+ extra_args=extra_args,
+ dependencies=deps)
+ if required and not haz:
+ raise InterpreterException(f'{self.compiler.get_display_language()} symbol {symbol} not found in header {hname}')
+ elif haz:
+ h = mlog.green('YES')
+ else:
+ h = mlog.red('NO')
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ mlog.log(f'Header <{hname}> has symbol', mlog.bold(symbol, True), msg, h, cached_msg)
+ return haz
+
+ def notfound_library(self, libname: str) -> 'dependencies.ExternalLibrary':
+ lib = dependencies.ExternalLibrary(libname, None,
+ self.environment,
+ self.compiler.language,
+ silent=True)
+ return lib
+
+ @disablerIfNotFound
+ @typed_pos_args('compiler.find_library', str)
+ @typed_kwargs(
+ 'compiler.find_library',
+ KwargInfo('required', (bool, coredata.UserFeatureOption), default=True),
+ KwargInfo('has_headers', ContainerTypeInfo(list, str), listify=True, default=[], since='0.50.0'),
+ KwargInfo('static', (bool, NoneType), since='0.51.0'),
+ KwargInfo('disabler', bool, default=False, since='0.49.0'),
+ KwargInfo('dirs', ContainerTypeInfo(list, str), listify=True, default=[]),
+ *(k.evolve(name=f'header_{k.name}') for k in _HEADER_KWS)
+ )
+ def find_library_method(self, args: T.Tuple[str], kwargs: 'FindLibraryKW') -> 'dependencies.ExternalLibrary':
+ # TODO add dependencies support?
+ libname = args[0]
+
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
+ if disabled:
+ mlog.log('Library', mlog.bold(libname), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return self.notfound_library(libname)
+
+ # This could be done with a comprehension, but that confuses the type
+ # checker, and having it check this seems valuable
+ has_header_kwargs: 'HeaderKW' = {
+ 'required': required,
+ 'args': kwargs['header_args'],
+ 'dependencies': kwargs['header_dependencies'],
+ 'include_directories': kwargs['header_include_directories'],
+ 'prefix': kwargs['header_prefix'],
+ 'no_builtin_args': kwargs['header_no_builtin_args'],
+ }
+ for h in kwargs['has_headers']:
+ if not self._has_header_impl(h, has_header_kwargs):
+ return self.notfound_library(libname)
+
+ search_dirs = extract_search_dirs(kwargs)
+
+ if kwargs['static'] is True:
+ libtype = mesonlib.LibType.STATIC
+ elif kwargs['static'] is False:
+ libtype = mesonlib.LibType.SHARED
+ else:
+ libtype = mesonlib.LibType.PREFER_SHARED
+ linkargs = self.compiler.find_library(libname, self.environment, search_dirs, libtype)
+ if required and not linkargs:
+ if libtype == mesonlib.LibType.PREFER_SHARED:
+ libtype_s = 'shared or static'
+ else:
+ libtype_s = libtype.name.lower()
+ raise InterpreterException('{} {} library {!r} not found'
+ .format(self.compiler.get_display_language(),
+ libtype_s, libname))
+ lib = dependencies.ExternalLibrary(libname, linkargs, self.environment,
+ self.compiler.language)
+ return lib
+
+ def _has_argument_impl(self, arguments: T.Union[str, T.List[str]],
+ mode: _TestMode = _TestMode.COMPILER) -> bool:
+ """Shared implementation for methods checking compiler and linker arguments."""
+ # This simplifies the callers
+ if isinstance(arguments, str):
+ arguments = [arguments]
+ test = self.compiler.has_multi_link_arguments if mode is _TestMode.LINKER else self.compiler.has_multi_arguments
+ result, cached = test(arguments, self.environment)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ mlog.log(
+ 'Compiler for',
+ self.compiler.get_display_language(),
+ 'supports{}'.format(' link' if mode is _TestMode.LINKER else ''),
+ 'arguments {}:'.format(' '.join(arguments)),
+ mlog.green('YES') if result else mlog.red('NO'),
+ cached_msg)
+ return result
+
+ @noKwargs
+ @typed_pos_args('compiler.has_argument', str)
+ def has_argument_method(self, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool:
+ return self._has_argument_impl([args[0]])
+
+ @noKwargs
+ @typed_pos_args('compiler.has_multi_arguments', varargs=str)
+ @FeatureNew('compiler.has_multi_arguments', '0.37.0')
+ def has_multi_arguments_method(self, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> bool:
+ return self._has_argument_impl(args[0])
+
+ @FeatureNew('compiler.get_supported_arguments', '0.43.0')
+ @typed_pos_args('compiler.get_supported_arguments', varargs=str)
+ @typed_kwargs(
+ 'compiler.get_supported_arguments',
+ KwargInfo('checked', str, default='off', since='0.59.0',
+ validator=in_set_validator({'warn', 'require', 'off'})),
+ )
+ def get_supported_arguments_method(self, args: T.Tuple[T.List[str]], kwargs: 'GetSupportedArgumentKw') -> T.List[str]:
+ supported_args: T.List[str] = []
+ checked = kwargs['checked']
+
+ for arg in args[0]:
+ if not self._has_argument_impl([arg]):
+ msg = f'Compiler for {self.compiler.get_display_language()} does not support "{arg}"'
+ if checked == 'warn':
+ mlog.warning(msg)
+ elif checked == 'require':
+ raise mesonlib.MesonException(msg)
+ else:
+ supported_args.append(arg)
+ return supported_args
+
+ @noKwargs
+ @typed_pos_args('compiler.first_supported_argument', varargs=str)
+ def first_supported_argument_method(self, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> T.List[str]:
+ for arg in args[0]:
+ if self._has_argument_impl([arg]):
+ mlog.log('First supported argument:', mlog.bold(arg))
+ return [arg]
+ mlog.log('First supported argument:', mlog.red('None'))
+ return []
+
+ @FeatureNew('compiler.has_link_argument', '0.46.0')
+ @noKwargs
+ @typed_pos_args('compiler.has_link_argument', str)
+ def has_link_argument_method(self, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool:
+ return self._has_argument_impl([args[0]], mode=_TestMode.LINKER)
+
+ @FeatureNew('compiler.has_multi_link_argument', '0.46.0')
+ @noKwargs
+ @typed_pos_args('compiler.has_multi_link_argument', varargs=str)
+ def has_multi_link_arguments_method(self, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> bool:
+ return self._has_argument_impl(args[0], mode=_TestMode.LINKER)
+
+ @FeatureNew('compiler.get_supported_link_arguments', '0.46.0')
+ @noKwargs
+ @typed_pos_args('compiler.get_supported_link_arguments', varargs=str)
+ def get_supported_link_arguments_method(self, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> T.List[str]:
+ supported_args: T.List[str] = []
+ for arg in args[0]:
+ if self._has_argument_impl([arg], mode=_TestMode.LINKER):
+ supported_args.append(arg)
+ return supported_args
+
+ @FeatureNew('compiler.first_supported_link_argument_method', '0.46.0')
+ @noKwargs
+ @typed_pos_args('compiler.first_supported_link_argument', varargs=str)
+ def first_supported_link_argument_method(self, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> T.List[str]:
+ for arg in args[0]:
+ if self._has_argument_impl([arg], mode=_TestMode.LINKER):
+ mlog.log('First supported link argument:', mlog.bold(arg))
+ return [arg]
+ mlog.log('First supported link argument:', mlog.red('None'))
+ return []
+
+ def _has_function_attribute_impl(self, attr: str) -> bool:
+ """Common helper for function attribute testing."""
+ result, cached = self.compiler.has_func_attribute(attr, self.environment)
+ cached_msg = mlog.blue('(cached)') if cached else ''
+ h = mlog.green('YES') if result else mlog.red('NO')
+ mlog.log(f'Compiler for {self.compiler.get_display_language()} supports function attribute {attr}:', h, cached_msg)
+ return result
+
+ @FeatureNew('compiler.has_function_attribute', '0.48.0')
+ @noKwargs
+ @typed_pos_args('compiler.has_function_attribute', str)
+ def has_func_attribute_method(self, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool:
+ return self._has_function_attribute_impl(args[0])
+
+ @FeatureNew('compiler.get_supported_function_attributes', '0.48.0')
+ @noKwargs
+ @typed_pos_args('compiler.get_supported_function_attributes', varargs=str)
+ def get_supported_function_attributes_method(self, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> T.List[str]:
+ return [a for a in args[0] if self._has_function_attribute_impl(a)]
+
+ @FeatureNew('compiler.get_argument_syntax_method', '0.49.0')
+ @noPosargs
+ @noKwargs
+ def get_argument_syntax_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.compiler.get_argument_syntax()
diff -Nru meson-0.53.2/mesonbuild/interpreter/dependencyfallbacks.py meson-0.61.2/mesonbuild/interpreter/dependencyfallbacks.py
--- meson-0.53.2/mesonbuild/interpreter/dependencyfallbacks.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/dependencyfallbacks.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,366 @@
+from .interpreterobjects import SubprojectHolder, extract_required_kwarg
+
+from .. import mlog
+from .. import dependencies
+from .. import build
+from ..wrap import WrapMode
+from ..mesonlib import OptionKey, extract_as_list, stringlistify, version_compare_many
+from ..dependencies import Dependency, DependencyException, NotFoundDependency
+from ..interpreterbase import (MesonInterpreterObject, FeatureNew,
+ InterpreterException, InvalidArguments,
+ TYPE_nkwargs, TYPE_nvar)
+
+import typing as T
+if T.TYPE_CHECKING:
+ from .interpreter import Interpreter
+
+
+class DependencyFallbacksHolder(MesonInterpreterObject):
+ def __init__(self, interpreter: 'Interpreter', names: T.List[str], allow_fallback: T.Optional[bool] = None,
+ default_options: T.Optional[T.List[str]] = None) -> None:
+ super().__init__(subproject=interpreter.subproject)
+ self.interpreter = interpreter
+ self.subproject = interpreter.subproject
+ self.coredata = interpreter.coredata
+ self.build = interpreter.build
+ self.environment = interpreter.environment
+ self.wrap_resolver = interpreter.environment.wrap_resolver
+ self.allow_fallback = allow_fallback
+ self.subproject_name = None
+ self.subproject_varname = None
+ self.subproject_kwargs = {'default_options': default_options or []}
+ self.names: T.List[str] = []
+ for name in names:
+ if not name:
+ raise InterpreterException('dependency_fallbacks empty name \'\' is not allowed')
+ if '<' in name or '>' in name or '=' in name:
+ raise InvalidArguments('Characters <, > and = are forbidden in dependency names. To specify'
+ 'version\n requirements use the \'version\' keyword argument instead.')
+ if name in self.names:
+ raise InterpreterException('dependency_fallbacks name {name!r} is duplicated')
+ self.names.append(name)
+
+ def set_fallback(self, fbinfo: T.Optional[T.Union[T.List[str], str]]) -> None:
+ # Legacy: This converts dependency()'s fallback kwargs.
+ if fbinfo is None:
+ return
+ if self.allow_fallback is not None:
+ raise InvalidArguments('"fallback" and "allow_fallback" arguments are mutually exclusive')
+ fbinfo = stringlistify(fbinfo)
+ if len(fbinfo) == 0:
+ # dependency('foo', fallback: []) is the same as dependency('foo', allow_fallback: false)
+ self.allow_fallback = False
+ return
+ if len(fbinfo) == 1:
+ FeatureNew.single_use('Fallback without variable name', '0.53.0', self.subproject)
+ subp_name, varname = fbinfo[0], None
+ elif len(fbinfo) == 2:
+ subp_name, varname = fbinfo
+ else:
+ raise InterpreterException('Fallback info must have one or two items.')
+ self._subproject_impl(subp_name, varname)
+
+ def _subproject_impl(self, subp_name: str, varname: str) -> None:
+ if not varname:
+ # If no variable name is specified, check if the wrap file has one.
+ # If the wrap file has a variable name, better use it because the
+ # subproject most probably is not using meson.override_dependency().
+ for name in self.names:
+ varname = self.wrap_resolver.get_varname(subp_name, name)
+ if varname:
+ break
+ assert self.subproject_name is None
+ self.subproject_name = subp_name
+ self.subproject_varname = varname
+
+ def _do_dependency_cache(self, kwargs: TYPE_nkwargs, func_args: TYPE_nvar, func_kwargs: TYPE_nkwargs) -> T.Optional[Dependency]:
+ name = func_args[0]
+ cached_dep = self._get_cached_dep(name, kwargs)
+ if cached_dep:
+ self._verify_fallback_consistency(cached_dep)
+ return cached_dep
+
+ def _do_dependency(self, kwargs: TYPE_nkwargs, func_args: TYPE_nvar, func_kwargs: TYPE_nkwargs) -> T.Optional[Dependency]:
+ # Note that there is no df.dependency() method, this is called for names
+ # given as positional arguments to dependency_fallbacks(name1, ...).
+ # We use kwargs from the dependency() function, for things like version,
+ # module, etc.
+ name = func_args[0]
+ self._handle_featurenew_dependencies(name)
+ dep = dependencies.find_external_dependency(name, self.environment, kwargs)
+ if dep.found():
+ for_machine = self.interpreter.machine_from_native_kwarg(kwargs)
+ identifier = dependencies.get_dep_identifier(name, kwargs)
+ self.coredata.deps[for_machine].put(identifier, dep)
+ return dep
+ return None
+
+ def _do_existing_subproject(self, kwargs: TYPE_nkwargs, func_args: TYPE_nvar, func_kwargs: TYPE_nkwargs) -> T.Optional[Dependency]:
+ subp_name = func_args[0]
+ varname = self.subproject_varname
+ if subp_name and self._get_subproject(subp_name):
+ return self._get_subproject_dep(subp_name, varname, kwargs)
+ return None
+
+ def _do_subproject(self, kwargs: TYPE_nkwargs, func_args: TYPE_nvar, func_kwargs: TYPE_nkwargs) -> T.Optional[Dependency]:
+ if self.forcefallback:
+ mlog.log('Looking for a fallback subproject for the dependency',
+ mlog.bold(self.display_name), 'because:\nUse of fallback dependencies is forced.')
+ elif self.nofallback:
+ mlog.log('Not looking for a fallback subproject for the dependency',
+ mlog.bold(self.display_name), 'because:\nUse of fallback dependencies is disabled.')
+ return None
+ else:
+ mlog.log('Looking for a fallback subproject for the dependency',
+ mlog.bold(self.display_name))
+
+ # dependency('foo', static: true) should implicitly add
+ # default_options: ['default_library=static']
+ static = kwargs.get('static')
+ default_options = stringlistify(func_kwargs.get('default_options', []))
+ if static is not None and not any('default_library' in i for i in default_options):
+ default_library = 'static' if static else 'shared'
+ opt = f'default_library={default_library}'
+ mlog.log(f'Building fallback subproject with {opt}')
+ default_options.append(opt)
+ func_kwargs['default_options'] = default_options
+
+ # Configure the subproject
+ subp_name = self.subproject_name
+ varname = self.subproject_varname
+ self.interpreter.do_subproject(subp_name, 'meson', func_kwargs)
+ return self._get_subproject_dep(subp_name, varname, kwargs)
+
+ def _get_subproject(self, subp_name: str) -> T.Optional[SubprojectHolder]:
+ sub = self.interpreter.subprojects.get(subp_name)
+ if sub and sub.found():
+ return sub
+ return None
+
+ def _get_subproject_dep(self, subp_name: str, varname: str, kwargs: TYPE_nkwargs) -> T.Optional[Dependency]:
+ # Verify the subproject is found
+ subproject = self._get_subproject(subp_name)
+ if not subproject:
+ mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.bold(subp_name), 'found:', mlog.red('NO'),
+ mlog.blue('(subproject failed to configure)'))
+ return None
+
+ # The subproject has been configured. If for any reason the dependency
+ # cannot be found in this subproject we have to return not-found object
+ # instead of None, because we don't want to continue the lookup on the
+ # system.
+
+ # Check if the subproject overridden at least one of the names we got.
+ cached_dep = None
+ for name in self.names:
+ cached_dep = self._get_cached_dep(name, kwargs)
+ if cached_dep:
+ break
+
+ # If we have cached_dep we did all the checks and logging already in
+ # self._get_cached_dep().
+ if cached_dep:
+ self._verify_fallback_consistency(cached_dep)
+ return cached_dep
+
+ # Legacy: Use the variable name if provided instead of relying on the
+ # subproject to override one of our dependency names
+ if not varname:
+ mlog.warning(f'Subproject {subp_name!r} did not override {self.display_name!r} dependency and no variable name specified')
+ mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.bold(subproject.subdir), 'found:', mlog.red('NO'))
+ return self._notfound_dependency()
+
+ var_dep = self._get_subproject_variable(subproject, varname) or self._notfound_dependency()
+ if not var_dep.found():
+ mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.bold(subproject.subdir), 'found:', mlog.red('NO'))
+ return var_dep
+
+ wanted = stringlistify(kwargs.get('version', []))
+ found = var_dep.get_version()
+ if not self._check_version(wanted, found):
+ mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.bold(subproject.subdir), 'found:', mlog.red('NO'),
+ 'found', mlog.normal_cyan(found), 'but need:',
+ mlog.bold(', '.join([f"'{e}'" for e in wanted])))
+ return self._notfound_dependency()
+
+ mlog.log('Dependency', mlog.bold(self.display_name), 'from subproject',
+ mlog.bold(subproject.subdir), 'found:', mlog.green('YES'),
+ mlog.normal_cyan(found) if found else None)
+ return var_dep
+
+ def _get_cached_dep(self, name: str, kwargs: TYPE_nkwargs) -> T.Optional[Dependency]:
+ # Unlike other methods, this one returns not-found dependency instead
+ # of None in the case the dependency is cached as not-found, or if cached
+ # version does not match. In that case we don't want to continue with
+ # other candidates.
+ for_machine = self.interpreter.machine_from_native_kwarg(kwargs)
+ identifier = dependencies.get_dep_identifier(name, kwargs)
+ wanted_vers = stringlistify(kwargs.get('version', []))
+
+ override = self.build.dependency_overrides[for_machine].get(identifier)
+ if override:
+ info = [mlog.blue('(overridden)' if override.explicit else '(cached)')]
+ cached_dep = override.dep
+ # We don't implicitly override not-found dependencies, but user could
+ # have explicitly called meson.override_dependency() with a not-found
+ # dep.
+ if not cached_dep.found():
+ mlog.log('Dependency', mlog.bold(self.display_name),
+ 'found:', mlog.red('NO'), *info)
+ return cached_dep
+ else:
+ info = [mlog.blue('(cached)')]
+ cached_dep = self.coredata.deps[for_machine].get(identifier)
+
+ if cached_dep:
+ found_vers = cached_dep.get_version()
+ if not self._check_version(wanted_vers, found_vers):
+ if not override:
+ # We cached this dependency on disk from a previous run,
+ # but it could got updated on the system in the meantime.
+ return None
+ mlog.log('Dependency', mlog.bold(name),
+ 'found:', mlog.red('NO'),
+ 'found', mlog.normal_cyan(found_vers), 'but need:',
+ mlog.bold(', '.join([f"'{e}'" for e in wanted_vers])),
+ *info)
+ return self._notfound_dependency()
+ if found_vers:
+ info = [mlog.normal_cyan(found_vers), *info]
+ mlog.log('Dependency', mlog.bold(self.display_name),
+ 'found:', mlog.green('YES'), *info)
+ return cached_dep
+ return None
+
+ def _get_subproject_variable(self, subproject: SubprojectHolder, varname: str) -> T.Optional[Dependency]:
+ try:
+ var_dep = subproject.get_variable_method([varname], {})
+ except InvalidArguments:
+ var_dep = None
+ if not isinstance(var_dep, Dependency):
+ mlog.warning(f'Variable {varname!r} in the subproject {subproject.subdir!r} is',
+ 'not found' if var_dep is None else 'not a dependency object')
+ return None
+ return var_dep
+
+ def _verify_fallback_consistency(self, cached_dep: Dependency):
+ subp_name = self.subproject_name
+ varname = self.subproject_varname
+ subproject = self._get_subproject(subp_name)
+ if subproject and varname:
+ var_dep = self._get_subproject_variable(subproject, varname)
+ if var_dep and cached_dep.found() and var_dep != cached_dep:
+ mlog.warning(f'Inconsistency: Subproject has overridden the dependency with another variable than {varname!r}')
+
+ def _handle_featurenew_dependencies(self, name: str) -> None:
+ 'Do a feature check on dependencies used by this subproject'
+ if name == 'mpi':
+ FeatureNew.single_use('MPI Dependency', '0.42.0', self.subproject)
+ elif name == 'pcap':
+ FeatureNew.single_use('Pcap Dependency', '0.42.0', self.subproject)
+ elif name == 'vulkan':
+ FeatureNew.single_use('Vulkan Dependency', '0.42.0', self.subproject)
+ elif name == 'libwmf':
+ FeatureNew.single_use('LibWMF Dependency', '0.44.0', self.subproject)
+ elif name == 'openmp':
+ FeatureNew.single_use('OpenMP Dependency', '0.46.0', self.subproject)
+
+ def _notfound_dependency(self) -> NotFoundDependency:
+ return NotFoundDependency(self.names[0] if self.names else '', self.environment)
+
+ @staticmethod
+ def _check_version(wanted: T.Optional[str], found: str) -> bool:
+ if not wanted:
+ return True
+ if found == 'undefined' or not version_compare_many(found, wanted)[0]:
+ return False
+ return True
+
+ def _get_candidates(self) -> T.List[T.Tuple[T.Callable[[TYPE_nkwargs, TYPE_nvar, TYPE_nkwargs], T.Optional[Dependency]], TYPE_nvar, TYPE_nkwargs]]:
+ candidates = []
+ # 1. check if any of the names is cached already.
+ for name in self.names:
+ candidates.append((self._do_dependency_cache, [name], {}))
+ # 2. check if the subproject fallback has already been configured.
+ if self.subproject_name:
+ candidates.append((self._do_existing_subproject, [self.subproject_name], self.subproject_kwargs))
+ # 3. check external dependency if we are not forced to use subproject
+ if not self.forcefallback or not self.subproject_name:
+ for name in self.names:
+ candidates.append((self._do_dependency, [name], {}))
+ # 4. configure the subproject
+ if self.subproject_name:
+ candidates.append((self._do_subproject, [self.subproject_name], self.subproject_kwargs))
+ return candidates
+
+ def lookup(self, kwargs: TYPE_nkwargs, force_fallback: bool = False) -> Dependency:
+ self.display_name = self.names[0] if self.names else '(anonymous)'
+ mods = extract_as_list(kwargs, 'modules')
+ if mods:
+ self.display_name += ' (modules: {})'.format(', '.join(str(i) for i in mods))
+
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
+ if disabled:
+ mlog.log('Dependency', mlog.bold(self.display_name), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return self._notfound_dependency()
+
+ # Check if usage of the subproject fallback is forced
+ wrap_mode = self.coredata.get_option(OptionKey('wrap_mode'))
+ force_fallback_for = self.coredata.get_option(OptionKey('force_fallback_for'))
+ self.nofallback = wrap_mode == WrapMode.nofallback
+ self.forcefallback = (force_fallback or
+ wrap_mode == WrapMode.forcefallback or
+ any(name in force_fallback_for for name in self.names) or
+ self.subproject_name in force_fallback_for)
+
+ # Add an implicit subproject fallback if none has been set explicitly,
+ # unless implicit fallback is not allowed.
+ # Legacy: self.allow_fallback can be None when that kwarg is not defined
+ # in dependency('name'). In that case we don't want to use implicit
+ # fallback when required is false because user will typically fallback
+ # manually using cc.find_library() for example.
+ if not self.subproject_name and self.allow_fallback is not False:
+ for name in self.names:
+ subp_name, varname = self.wrap_resolver.find_dep_provider(name)
+ if subp_name:
+ self.forcefallback |= subp_name in force_fallback_for
+ if self.forcefallback or self.allow_fallback is True or required or self._get_subproject(subp_name):
+ self._subproject_impl(subp_name, varname)
+ break
+
+ candidates = self._get_candidates()
+
+ # writing just "dependency('')" is an error, because it can only fail
+ if not candidates and required:
+ raise InvalidArguments('Dependency is required but has no candidates.')
+
+ # Try all candidates, only the last one is really required.
+ last = len(candidates) - 1
+ for i, item in enumerate(candidates):
+ func, func_args, func_kwargs = item
+ func_kwargs['required'] = required and (i == last)
+ kwargs['required'] = required and (i == last)
+ dep = func(kwargs, func_args, func_kwargs)
+ if dep and dep.found():
+ # Override this dependency to have consistent results in subsequent
+ # dependency lookups.
+ for name in self.names:
+ for_machine = self.interpreter.machine_from_native_kwarg(kwargs)
+ identifier = dependencies.get_dep_identifier(name, kwargs)
+ if identifier not in self.build.dependency_overrides[for_machine]:
+ self.build.dependency_overrides[for_machine][identifier] = \
+ build.DependencyOverride(dep, self.interpreter.current_node, explicit=False)
+ return dep
+ elif required and (dep or i == last):
+ # This was the last candidate or the dependency has been cached
+ # as not-found, or cached dependency version does not match,
+ # otherwise func() would have returned None instead.
+ raise DependencyException(f'Dependency {self.display_name!r} is required but not found.')
+ elif dep:
+ # Same as above, but the dependency is not required.
+ return dep
+ return self._notfound_dependency()
diff -Nru meson-0.53.2/mesonbuild/interpreter/__init__.py meson-0.61.2/mesonbuild/interpreter/__init__.py
--- meson-0.53.2/mesonbuild/interpreter/__init__.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/__init__.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,59 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# 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.
+
+"""Meson interpreter."""
+
+__all__ = [
+ 'Interpreter',
+ 'permitted_dependency_kwargs',
+
+ 'CompilerHolder',
+
+ 'ExecutableHolder',
+ 'BuildTargetHolder',
+ 'CustomTargetHolder',
+ 'CustomTargetIndexHolder',
+ 'MachineHolder',
+ 'Test',
+ 'ConfigurationDataObject',
+ 'SubprojectHolder',
+ 'DependencyHolder',
+ 'GeneratedListHolder',
+ 'ExternalProgramHolder',
+ 'extract_required_kwarg',
+
+ 'ArrayHolder',
+ 'BooleanHolder',
+ 'DictHolder',
+ 'IntegerHolder',
+ 'StringHolder',
+]
+
+from .interpreter import Interpreter, permitted_dependency_kwargs
+from .compiler import CompilerHolder
+from .interpreterobjects import (ExecutableHolder, BuildTargetHolder, CustomTargetHolder,
+ CustomTargetIndexHolder, MachineHolder, Test,
+ ConfigurationDataObject, SubprojectHolder, DependencyHolder,
+ GeneratedListHolder, ExternalProgramHolder,
+ extract_required_kwarg)
+
+from .primitives import (
+ ArrayHolder,
+ BooleanHolder,
+ DictHolder,
+ IntegerHolder,
+ StringHolder,
+)
diff -Nru meson-0.53.2/mesonbuild/interpreter/interpreterobjects.py meson-0.61.2/mesonbuild/interpreter/interpreterobjects.py
--- meson-0.53.2/mesonbuild/interpreter/interpreterobjects.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/interpreterobjects.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,995 @@
+import os
+import shlex
+import subprocess
+import copy
+import textwrap
+
+from pathlib import Path, PurePath
+
+from .. import mesonlib
+from .. import coredata
+from .. import build
+from .. import mlog
+
+from ..modules import ModuleReturnValue, ModuleObject, ModuleState, ExtensionModule
+from ..backend.backends import TestProtocol
+from ..interpreterbase import (
+ ContainerTypeInfo, KwargInfo, MesonOperator,
+ InterpreterObject, MesonInterpreterObject, ObjectHolder, MutableInterpreterObject,
+ FeatureCheckBase, FeatureNewKwargs, FeatureNew, FeatureDeprecated,
+ typed_pos_args, typed_kwargs, typed_operator, permittedKwargs,
+ noArgsFlattening, noPosargs, noKwargs, unholder_return, TYPE_var, TYPE_kwargs, TYPE_nvar, TYPE_nkwargs,
+ flatten, resolve_second_level_holders, InterpreterException, InvalidArguments, InvalidCode)
+from ..interpreter.type_checking import NoneType
+from ..dependencies import Dependency, ExternalLibrary, InternalDependency
+from ..programs import ExternalProgram
+from ..mesonlib import HoldableObject, MesonException, OptionKey, listify, Popen_safe
+
+import typing as T
+
+if T.TYPE_CHECKING:
+ from . import kwargs
+ from .interpreter import Interpreter
+ from ..envconfig import MachineInfo
+
+ from typing_extensions import TypedDict
+
+ class EnvironmentSeparatorKW(TypedDict):
+
+ separator: str
+
+
+def extract_required_kwarg(kwargs: 'kwargs.ExtractRequired',
+ subproject: str,
+ feature_check: T.Optional[FeatureCheckBase] = None,
+ default: bool = True) -> T.Tuple[bool, bool, T.Optional[str]]:
+ val = kwargs.get('required', default)
+ disabled = False
+ required = False
+ feature: T.Optional[str] = None
+ if isinstance(val, coredata.UserFeatureOption):
+ if not feature_check:
+ feature_check = FeatureNew('User option "feature"', '0.47.0')
+ feature_check.use(subproject)
+ feature = val.name
+ if val.is_disabled():
+ disabled = True
+ elif val.is_enabled():
+ required = True
+ elif isinstance(val, bool):
+ required = val
+ else:
+ raise InterpreterException('required keyword argument must be boolean or a feature option')
+
+ # Keep boolean value in kwargs to simplify other places where this kwarg is
+ # checked.
+ # TODO: this should be removed, and those callers should learn about FeatureOptions
+ kwargs['required'] = required
+
+ return disabled, required, feature
+
+def extract_search_dirs(kwargs: 'kwargs.ExtractSearchDirs') -> T.List[str]:
+ search_dirs_str = mesonlib.stringlistify(kwargs.get('dirs', []))
+ search_dirs = [Path(d).expanduser() for d in search_dirs_str]
+ for d in search_dirs:
+ if mesonlib.is_windows() and d.root.startswith('\\'):
+ # a Unix-path starting with `/` that is not absolute on Windows.
+ # discard without failing for end-user ease of cross-platform directory arrays
+ continue
+ if not d.is_absolute():
+ raise InvalidCode(f'Search directory {d} is not an absolute path.')
+ return list(map(str, search_dirs))
+
+class FeatureOptionHolder(ObjectHolder[coredata.UserFeatureOption]):
+ def __init__(self, option: coredata.UserFeatureOption, interpreter: 'Interpreter'):
+ super().__init__(option, interpreter)
+ if option and option.is_auto():
+ # TODO: we need to case here because options is not a TypedDict
+ self.held_object = T.cast(coredata.UserFeatureOption, self.env.coredata.options[OptionKey('auto_features')])
+ self.held_object.name = option.name
+ self.methods.update({'enabled': self.enabled_method,
+ 'disabled': self.disabled_method,
+ 'allowed': self.allowed_method,
+ 'auto': self.auto_method,
+ 'require': self.require_method,
+ 'disable_auto_if': self.disable_auto_if_method,
+ })
+
+ @property
+ def value(self) -> str:
+ return 'disabled' if not self.held_object else self.held_object.value
+
+ def as_disabled(self) -> coredata.UserFeatureOption:
+ disabled = copy.deepcopy(self.held_object)
+ disabled.value = 'disabled'
+ return disabled
+
+ @noPosargs
+ @noKwargs
+ def enabled_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.value == 'enabled'
+
+ @noPosargs
+ @noKwargs
+ def disabled_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.value == 'disabled'
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('feature_option.allowed()', '0.59.0')
+ def allowed_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.value != 'disabled'
+
+ @noPosargs
+ @noKwargs
+ def auto_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.value == 'auto'
+
+ @FeatureNew('feature_option.require()', '0.59.0')
+ @permittedKwargs({'error_message'})
+ def require_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> coredata.UserFeatureOption:
+ if len(args) != 1:
+ raise InvalidArguments(f'Expected 1 argument, got {len(args)}.')
+ if not isinstance(args[0], bool):
+ raise InvalidArguments('boolean argument expected.')
+ error_message = kwargs.pop('error_message', '')
+ if error_message and not isinstance(error_message, str):
+ raise InterpreterException("Error message must be a string.")
+ if args[0]:
+ return copy.deepcopy(self.held_object)
+
+ assert isinstance(error_message, str)
+ if self.value == 'enabled':
+ prefix = f'Feature {self.held_object.name} cannot be enabled'
+ if error_message:
+ prefix += ': '
+ raise InterpreterException(prefix + error_message)
+ return self.as_disabled()
+
+ @FeatureNew('feature_option.disable_auto_if()', '0.59.0')
+ @noKwargs
+ def disable_auto_if_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> coredata.UserFeatureOption:
+ if len(args) != 1:
+ raise InvalidArguments(f'Expected 1 argument, got {len(args)}.')
+ if not isinstance(args[0], bool):
+ raise InvalidArguments('boolean argument expected.')
+ return copy.deepcopy(self.held_object) if self.value != 'auto' or not args[0] else self.as_disabled()
+
+
+class RunProcess(MesonInterpreterObject):
+
+ def __init__(self,
+ cmd: ExternalProgram,
+ args: T.List[str],
+ env: build.EnvironmentVariables,
+ source_dir: str,
+ build_dir: str,
+ subdir: str,
+ mesonintrospect: T.List[str],
+ in_builddir: bool = False,
+ check: bool = False,
+ capture: bool = True) -> None:
+ super().__init__()
+ if not isinstance(cmd, ExternalProgram):
+ raise AssertionError('BUG: RunProcess must be passed an ExternalProgram')
+ self.capture = capture
+ self.returncode, self.stdout, self.stderr = self.run_command(cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check)
+ self.methods.update({'returncode': self.returncode_method,
+ 'stdout': self.stdout_method,
+ 'stderr': self.stderr_method,
+ })
+
+ def run_command(self,
+ cmd: ExternalProgram,
+ args: T.List[str],
+ env: build.EnvironmentVariables,
+ source_dir: str,
+ build_dir: str,
+ subdir: str,
+ mesonintrospect: T.List[str],
+ in_builddir: bool,
+ check: bool = False) -> T.Tuple[int, str, str]:
+ command_array = cmd.get_command() + args
+ menv = {'MESON_SOURCE_ROOT': source_dir,
+ 'MESON_BUILD_ROOT': build_dir,
+ 'MESON_SUBDIR': subdir,
+ 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in mesonintrospect]),
+ }
+ if in_builddir:
+ cwd = os.path.join(build_dir, subdir)
+ else:
+ cwd = os.path.join(source_dir, subdir)
+ child_env = os.environ.copy()
+ child_env.update(menv)
+ child_env = env.get_env(child_env)
+ stdout = subprocess.PIPE if self.capture else subprocess.DEVNULL
+ mlog.debug('Running command:', ' '.join(command_array))
+ try:
+ p, o, e = Popen_safe(command_array, stdout=stdout, env=child_env, cwd=cwd)
+ if self.capture:
+ mlog.debug('--- stdout ---')
+ mlog.debug(o)
+ else:
+ o = ''
+ mlog.debug('--- stdout disabled ---')
+ mlog.debug('--- stderr ---')
+ mlog.debug(e)
+ mlog.debug('')
+
+ if check and p.returncode != 0:
+ raise InterpreterException('Command "{}" failed with status {}.'.format(' '.join(command_array), p.returncode))
+
+ return p.returncode, o, e
+ except FileNotFoundError:
+ raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
+
+ @noPosargs
+ @noKwargs
+ def returncode_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> int:
+ return self.returncode
+
+ @noPosargs
+ @noKwargs
+ def stdout_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.stdout
+
+ @noPosargs
+ @noKwargs
+ def stderr_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.stderr
+
+
+_ENV_SEPARATOR_KW = KwargInfo('separator', str, default=os.pathsep)
+
+
+class EnvironmentVariablesHolder(ObjectHolder[build.EnvironmentVariables], MutableInterpreterObject):
+
+ def __init__(self, obj: build.EnvironmentVariables, interpreter: 'Interpreter'):
+ super().__init__(obj, interpreter)
+ self.methods.update({'set': self.set_method,
+ 'append': self.append_method,
+ 'prepend': self.prepend_method,
+ })
+
+ def __repr__(self) -> str:
+ repr_str = "<{0}: {1}>"
+ return repr_str.format(self.__class__.__name__, self.held_object.envvars)
+
+ def __deepcopy__(self, memo: T.Dict[str, object]) -> 'EnvironmentVariablesHolder':
+ # Avoid trying to copy the interpreter
+ return EnvironmentVariablesHolder(copy.deepcopy(self.held_object), self.interpreter)
+
+ def warn_if_has_name(self, name: str) -> None:
+ # Multiple append/prepend operations was not supported until 0.58.0.
+ if self.held_object.has_name(name):
+ m = f'Overriding previous value of environment variable {name!r} with a new one'
+ FeatureNew(m, '0.58.0', location=self.current_node).use(self.subproject)
+
+ @typed_pos_args('environment.set', str, varargs=str, min_varargs=1)
+ @typed_kwargs('environment.set', _ENV_SEPARATOR_KW)
+ def set_method(self, args: T.Tuple[str, T.List[str]], kwargs: 'EnvironmentSeparatorKW') -> None:
+ name, values = args
+ self.held_object.set(name, values, kwargs['separator'])
+
+ @typed_pos_args('environment.append', str, varargs=str, min_varargs=1)
+ @typed_kwargs('environment.append', _ENV_SEPARATOR_KW)
+ def append_method(self, args: T.Tuple[str, T.List[str]], kwargs: 'EnvironmentSeparatorKW') -> None:
+ name, values = args
+ self.warn_if_has_name(name)
+ self.held_object.append(name, values, kwargs['separator'])
+
+ @typed_pos_args('environment.prepend', str, varargs=str, min_varargs=1)
+ @typed_kwargs('environment.prepend', _ENV_SEPARATOR_KW)
+ def prepend_method(self, args: T.Tuple[str, T.List[str]], kwargs: 'EnvironmentSeparatorKW') -> None:
+ name, values = args
+ self.warn_if_has_name(name)
+ self.held_object.prepend(name, values, kwargs['separator'])
+
+
+class ConfigurationDataObject(MutableInterpreterObject, MesonInterpreterObject):
+ def __init__(self, subproject: str, initial_values: T.Optional[T.Dict[str, T.Any]] = None) -> None:
+ self.used = False # These objects become immutable after use in configure_file.
+ super().__init__(subproject=subproject)
+ self.conf_data = build.ConfigurationData()
+ self.methods.update({'set': self.set_method,
+ 'set10': self.set10_method,
+ 'set_quoted': self.set_quoted_method,
+ 'has': self.has_method,
+ 'get': self.get_method,
+ 'keys': self.keys_method,
+ 'get_unquoted': self.get_unquoted_method,
+ 'merge_from': self.merge_from_method,
+ })
+ if isinstance(initial_values, dict):
+ for k, v in initial_values.items():
+ self.set_method([k, v], {})
+ elif initial_values:
+ raise AssertionError('Unsupported ConfigurationDataObject initial_values')
+
+ def is_used(self) -> bool:
+ return self.used
+
+ def mark_used(self) -> None:
+ self.used = True
+
+ def validate_args(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.Tuple[str, T.Union[str, int, bool], T.Optional[str]]:
+ if len(args) == 1 and isinstance(args[0], list) and len(args[0]) == 2:
+ mlog.deprecation('Passing a list as the single argument to '
+ 'configuration_data.set is deprecated. This will '
+ 'become a hard error in the future.',
+ location=self.current_node)
+ args = args[0]
+
+ if len(args) != 2:
+ raise InterpreterException("Configuration set requires 2 arguments.")
+ if self.used:
+ raise InterpreterException("Can not set values on configuration object that has been used.")
+ name, val = args
+ if not isinstance(val, (int, str)):
+ msg = f'Setting a configuration data value to {val!r} is invalid, ' \
+ 'and will fail at configure_file(). If you are using it ' \
+ 'just to store some values, please use a dict instead.'
+ mlog.deprecation(msg, location=self.current_node)
+ desc = kwargs.get('description', None)
+ if not isinstance(name, str):
+ raise InterpreterException("First argument to set must be a string.")
+ if desc is not None and not isinstance(desc, str):
+ raise InterpreterException('Description must be a string.')
+
+ # TODO: Remove the cast once we get rid of the deprecation
+ return name, T.cast(T.Union[str, bool, int], val), desc
+
+ @noArgsFlattening
+ def set_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> None:
+ (name, val, desc) = self.validate_args(args, kwargs)
+ self.conf_data.values[name] = (val, desc)
+
+ def set_quoted_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> None:
+ (name, val, desc) = self.validate_args(args, kwargs)
+ if not isinstance(val, str):
+ raise InterpreterException("Second argument to set_quoted must be a string.")
+ escaped_val = '\\"'.join(val.split('"'))
+ self.conf_data.values[name] = ('"' + escaped_val + '"', desc)
+
+ def set10_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> None:
+ (name, val, desc) = self.validate_args(args, kwargs)
+ if val:
+ self.conf_data.values[name] = (1, desc)
+ else:
+ self.conf_data.values[name] = (0, desc)
+
+ def has_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return args[0] in self.conf_data.values
+
+ @FeatureNew('configuration_data.get()', '0.38.0')
+ @noArgsFlattening
+ def get_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.Union[str, int, bool]:
+ if len(args) < 1 or len(args) > 2:
+ raise InterpreterException('Get method takes one or two arguments.')
+ if not isinstance(args[0], str):
+ raise InterpreterException('The variable name must be a string.')
+ name = args[0]
+ if name in self.conf_data:
+ return self.conf_data.get(name)[0]
+ if len(args) > 1:
+ # Assertion does not work because setting other values is still
+ # supported, but deprecated. Use T.cast in the meantime (even though
+ # this is a lie).
+ # TODO: Fix this once the deprecation is removed
+ # assert isinstance(args[1], (int, str, bool))
+ return T.cast(T.Union[str, int, bool], args[1])
+ raise InterpreterException(f'Entry {name} not in configuration data.')
+
+ @FeatureNew('configuration_data.get_unquoted()', '0.44.0')
+ def get_unquoted_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.Union[str, int, bool]:
+ if len(args) < 1 or len(args) > 2:
+ raise InterpreterException('Get method takes one or two arguments.')
+ if not isinstance(args[0], str):
+ raise InterpreterException('The variable name must be a string.')
+ name = args[0]
+ if name in self.conf_data:
+ val = self.conf_data.get(name)[0]
+ elif len(args) > 1:
+ assert isinstance(args[1], (str, int, bool))
+ val = args[1]
+ else:
+ raise InterpreterException(f'Entry {name} not in configuration data.')
+ if isinstance(val, str) and val[0] == '"' and val[-1] == '"':
+ return val[1:-1]
+ return val
+
+ def get(self, name: str) -> T.Tuple[T.Union[str, int, bool], T.Optional[str]]:
+ return self.conf_data.values[name]
+
+ @FeatureNew('configuration_data.keys()', '0.57.0')
+ @noPosargs
+ def keys_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.List[str]:
+ return sorted(self.keys())
+
+ def keys(self) -> T.List[str]:
+ return list(self.conf_data.values.keys())
+
+ def merge_from_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> None:
+ if len(args) != 1:
+ raise InterpreterException('Merge_from takes one positional argument.')
+ from_object_holder = args[0]
+ if not isinstance(from_object_holder, ConfigurationDataObject):
+ raise InterpreterException('Merge_from argument must be a configuration data object.')
+ from_object = from_object_holder.conf_data
+ for k, v in from_object.values.items():
+ self.conf_data.values[k] = v
+
+
+_PARTIAL_DEP_KWARGS = [
+ KwargInfo('compile_args', bool, default=False),
+ KwargInfo('link_args', bool, default=False),
+ KwargInfo('links', bool, default=False),
+ KwargInfo('includes', bool, default=False),
+ KwargInfo('sources', bool, default=False),
+]
+
+class DependencyHolder(ObjectHolder[Dependency]):
+ def __init__(self, dep: Dependency, interpreter: 'Interpreter'):
+ super().__init__(dep, interpreter)
+ self.methods.update({'found': self.found_method,
+ 'type_name': self.type_name_method,
+ 'version': self.version_method,
+ 'name': self.name_method,
+ 'get_pkgconfig_variable': self.pkgconfig_method,
+ 'get_configtool_variable': self.configtool_method,
+ 'get_variable': self.variable_method,
+ 'partial_dependency': self.partial_dependency_method,
+ 'include_type': self.include_type_method,
+ 'as_system': self.as_system_method,
+ 'as_link_whole': self.as_link_whole_method,
+ })
+
+ def found(self) -> bool:
+ return self.found_method([], {})
+
+ @noPosargs
+ @noKwargs
+ def type_name_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.type_name
+
+ @noPosargs
+ @noKwargs
+ def found_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ if self.held_object.type_name == 'internal':
+ return True
+ return self.held_object.found()
+
+ @noPosargs
+ @noKwargs
+ def version_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.get_version()
+
+ @noPosargs
+ @noKwargs
+ def name_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.get_name()
+
+ @FeatureDeprecated('Dependency.get_pkgconfig_variable', '0.56.0',
+ 'use Dependency.get_variable(pkgconfig : ...) instead')
+ @permittedKwargs({'define_variable', 'default'})
+ def pkgconfig_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ args = listify(args)
+ if len(args) != 1:
+ raise InterpreterException('get_pkgconfig_variable takes exactly one argument.')
+ varname = args[0]
+ if not isinstance(varname, str):
+ raise InterpreterException('Variable name must be a string.')
+ return self.held_object.get_pkgconfig_variable(varname, kwargs)
+
+ @FeatureNew('dep.get_configtool_variable', '0.44.0')
+ @FeatureDeprecated('Dependency.get_configtool_variable', '0.56.0',
+ 'use Dependency.get_variable(configtool : ...) instead')
+ @noKwargs
+ def configtool_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ args = listify(args)
+ if len(args) != 1:
+ raise InterpreterException('get_configtool_variable takes exactly one argument.')
+ varname = args[0]
+ if not isinstance(varname, str):
+ raise InterpreterException('Variable name must be a string.')
+ return self.held_object.get_configtool_variable(varname)
+
+ @FeatureNew('dep.partial_dependency', '0.46.0')
+ @noPosargs
+ @typed_kwargs('dep.partial_dependency', *_PARTIAL_DEP_KWARGS)
+ def partial_dependency_method(self, args: T.List[TYPE_nvar], kwargs: 'kwargs.DependencyMethodPartialDependency') -> Dependency:
+ pdep = self.held_object.get_partial_dependency(**kwargs)
+ return pdep
+
+ @FeatureNew('dep.get_variable', '0.51.0')
+ @typed_pos_args('dep.get_variable', optargs=[str])
+ @permittedKwargs({'cmake', 'pkgconfig', 'configtool', 'internal', 'default_value', 'pkgconfig_define'})
+ @FeatureNewKwargs('dep.get_variable', '0.54.0', ['internal'])
+ def variable_method(self, args: T.Tuple[T.Optional[str]], kwargs: T.Dict[str, T.Any]) -> T.Union[str, T.List[str]]:
+ default_varname = args[0]
+ if default_varname is not None:
+ FeatureNew('Positional argument to dep.get_variable()', '0.58.0', location=self.current_node).use(self.subproject)
+ for k in ['cmake', 'pkgconfig', 'configtool', 'internal']:
+ kwargs.setdefault(k, default_varname)
+ return self.held_object.get_variable(**kwargs)
+
+ @FeatureNew('dep.include_type', '0.52.0')
+ @noPosargs
+ @noKwargs
+ def include_type_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.get_include_type()
+
+ @FeatureNew('dep.as_system', '0.52.0')
+ @noKwargs
+ def as_system_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> Dependency:
+ args = listify(args)
+ new_is_system = 'system'
+ if len(args) > 1:
+ raise InterpreterException('as_system takes only one optional value')
+ if len(args) == 1:
+ if not isinstance(args[0], str):
+ raise InterpreterException('as_system takes exactly one string parameter')
+ new_is_system = args[0]
+ new_dep = self.held_object.generate_system_dependency(new_is_system)
+ return new_dep
+
+ @FeatureNew('dep.as_link_whole', '0.56.0')
+ @noKwargs
+ @noPosargs
+ def as_link_whole_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> Dependency:
+ if not isinstance(self.held_object, InternalDependency):
+ raise InterpreterException('as_link_whole method is only supported on declare_dependency() objects')
+ new_dep = self.held_object.generate_link_whole_dependency()
+ return new_dep
+
+class ExternalProgramHolder(ObjectHolder[ExternalProgram]):
+ def __init__(self, ep: ExternalProgram, interpreter: 'Interpreter') -> None:
+ super().__init__(ep, interpreter)
+ self.methods.update({'found': self.found_method,
+ 'path': self.path_method,
+ 'full_path': self.full_path_method})
+
+ @noPosargs
+ @noKwargs
+ def found_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.found()
+
+ @noPosargs
+ @noKwargs
+ @FeatureDeprecated('ExternalProgram.path', '0.55.0',
+ 'use ExternalProgram.full_path() instead')
+ def path_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self._full_path()
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('ExternalProgram.full_path', '0.55.0')
+ def full_path_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self._full_path()
+
+ def _full_path(self) -> str:
+ if not self.found():
+ raise InterpreterException('Unable to get the path of a not-found external program')
+ path = self.held_object.get_path()
+ assert path is not None
+ return path
+
+ def found(self) -> bool:
+ return self.held_object.found()
+
+class ExternalLibraryHolder(ObjectHolder[ExternalLibrary]):
+ def __init__(self, el: ExternalLibrary, interpreter: 'Interpreter'):
+ super().__init__(el, interpreter)
+ self.methods.update({'found': self.found_method,
+ 'type_name': self.type_name_method,
+ 'partial_dependency': self.partial_dependency_method,
+ })
+
+ @noPosargs
+ @noKwargs
+ def type_name_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.type_name
+
+ @noPosargs
+ @noKwargs
+ def found_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.held_object.found()
+
+ @FeatureNew('dep.partial_dependency', '0.46.0')
+ @noPosargs
+ @typed_kwargs('dep.partial_dependency', *_PARTIAL_DEP_KWARGS)
+ def partial_dependency_method(self, args: T.List[TYPE_nvar], kwargs: 'kwargs.DependencyMethodPartialDependency') -> Dependency:
+ pdep = self.held_object.get_partial_dependency(**kwargs)
+ return pdep
+
+# A machine that's statically known from the cross file
+class MachineHolder(ObjectHolder['MachineInfo']):
+ def __init__(self, machine_info: 'MachineInfo', interpreter: 'Interpreter'):
+ super().__init__(machine_info, interpreter)
+ self.methods.update({'system': self.system_method,
+ 'cpu': self.cpu_method,
+ 'cpu_family': self.cpu_family_method,
+ 'endian': self.endian_method,
+ })
+
+ @noPosargs
+ @noKwargs
+ def cpu_family_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.cpu_family
+
+ @noPosargs
+ @noKwargs
+ def cpu_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.cpu
+
+ @noPosargs
+ @noKwargs
+ def system_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.system
+
+ @noPosargs
+ @noKwargs
+ def endian_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.endian
+
+class IncludeDirsHolder(ObjectHolder[build.IncludeDirs]):
+ pass
+
+class FileHolder(ObjectHolder[mesonlib.File]):
+ pass
+
+class HeadersHolder(ObjectHolder[build.Headers]):
+ pass
+
+class DataHolder(ObjectHolder[build.Data]):
+ pass
+
+class SymlinkDataHolder(ObjectHolder[build.SymlinkData]):
+ pass
+
+class InstallDirHolder(ObjectHolder[build.InstallDir]):
+ pass
+
+class ManHolder(ObjectHolder[build.Man]):
+ pass
+
+class EmptyDirHolder(ObjectHolder[build.EmptyDir]):
+ pass
+
+class GeneratedObjectsHolder(ObjectHolder[build.ExtractedObjects]):
+ pass
+
+class Test(MesonInterpreterObject):
+ def __init__(self, name: str, project: str, suite: T.List[str],
+ exe: T.Union[ExternalProgram, build.Executable, build.CustomTarget],
+ depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]],
+ is_parallel: bool,
+ cmd_args: T.List[T.Union[str, mesonlib.File, build.Target]],
+ env: build.EnvironmentVariables,
+ should_fail: bool, timeout: int, workdir: T.Optional[str], protocol: str,
+ priority: int):
+ super().__init__()
+ self.name = name
+ self.suite = listify(suite)
+ self.project_name = project
+ self.exe = exe
+ self.depends = depends
+ self.is_parallel = is_parallel
+ self.cmd_args = cmd_args
+ self.env = env
+ self.should_fail = should_fail
+ self.timeout = timeout
+ self.workdir = workdir
+ self.protocol = TestProtocol.from_str(protocol)
+ self.priority = priority
+
+ def get_exe(self) -> T.Union[ExternalProgram, build.Executable, build.CustomTarget]:
+ return self.exe
+
+ def get_name(self) -> str:
+ return self.name
+
+class NullSubprojectInterpreter(HoldableObject):
+ pass
+
+# TODO: This should really be an `ObjectHolder`, but the additional stuff in this
+# class prevents this. Thus, this class should be split into a pure
+# `ObjectHolder` and a class specifically for storing in `Interpreter`.
+class SubprojectHolder(MesonInterpreterObject):
+
+ def __init__(self, subinterpreter: T.Union['Interpreter', NullSubprojectInterpreter],
+ subdir: str,
+ warnings: int = 0,
+ disabled_feature: T.Optional[str] = None,
+ exception: T.Optional[MesonException] = None) -> None:
+ super().__init__()
+ self.held_object = subinterpreter
+ self.warnings = warnings
+ self.disabled_feature = disabled_feature
+ self.exception = exception
+ self.subdir = PurePath(subdir).as_posix()
+ self.methods.update({'get_variable': self.get_variable_method,
+ 'found': self.found_method,
+ })
+
+ @noPosargs
+ @noKwargs
+ def found_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.found()
+
+ def found(self) -> bool:
+ return not isinstance(self.held_object, NullSubprojectInterpreter)
+
+ @noKwargs
+ @noArgsFlattening
+ @unholder_return
+ def get_variable_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.Union[TYPE_var, InterpreterObject]:
+ if len(args) < 1 or len(args) > 2:
+ raise InterpreterException('Get_variable takes one or two arguments.')
+ if isinstance(self.held_object, NullSubprojectInterpreter): # == not self.found()
+ raise InterpreterException(f'Subproject "{self.subdir}" disabled can\'t get_variable on it.')
+ varname = args[0]
+ if not isinstance(varname, str):
+ raise InterpreterException('Get_variable first argument must be a string.')
+ try:
+ return self.held_object.variables[varname]
+ except KeyError:
+ pass
+
+ if len(args) == 2:
+ return self.held_object._holderify(args[1])
+
+ raise InvalidArguments(f'Requested variable "{varname}" not found.')
+
+class ModuleObjectHolder(ObjectHolder[ModuleObject]):
+ def method_call(self, method_name: str, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> TYPE_var:
+ modobj = self.held_object
+ method = modobj.methods.get(method_name)
+ if not method:
+ raise InvalidCode(f'Unknown method {method_name!r} in object.')
+ if not getattr(method, 'no-args-flattening', False):
+ args = flatten(args)
+ if not getattr(method, 'no-second-level-holder-flattening', False):
+ args, kwargs = resolve_second_level_holders(args, kwargs)
+ state = ModuleState(self.interpreter)
+ # Many modules do for example self.interpreter.find_program_impl(),
+ # so we have to ensure they use the current interpreter and not the one
+ # that first imported that module, otherwise it will use outdated
+ # overrides.
+ if isinstance(modobj, ExtensionModule):
+ modobj.interpreter = self.interpreter
+ ret = method(state, args, kwargs)
+ if isinstance(ret, ModuleReturnValue):
+ self.interpreter.process_new_values(ret.new_objects)
+ ret = ret.return_value
+ return ret
+
+class MutableModuleObjectHolder(ModuleObjectHolder, MutableInterpreterObject):
+ def __deepcopy__(self, memo: T.Dict[int, T.Any]) -> 'MutableModuleObjectHolder':
+ # Deepcopy only held object, not interpreter
+ modobj = copy.deepcopy(self.held_object, memo)
+ return MutableModuleObjectHolder(modobj, self.interpreter)
+
+
+_BuildTarget = T.TypeVar('_BuildTarget', bound=T.Union[build.BuildTarget, build.BothLibraries])
+
+class BuildTargetHolder(ObjectHolder[_BuildTarget]):
+ def __init__(self, target: _BuildTarget, interp: 'Interpreter'):
+ super().__init__(target, interp)
+ self.methods.update({'extract_objects': self.extract_objects_method,
+ 'extract_all_objects': self.extract_all_objects_method,
+ 'name': self.name_method,
+ 'get_id': self.get_id_method,
+ 'outdir': self.outdir_method,
+ 'full_path': self.full_path_method,
+ 'path': self.path_method,
+ 'found': self.found_method,
+ 'private_dir_include': self.private_dir_include_method,
+ })
+
+ def __repr__(self) -> str:
+ r = '<{} {}: {}>'
+ h = self.held_object
+ assert isinstance(h, build.BuildTarget)
+ return r.format(self.__class__.__name__, h.get_id(), h.filename)
+
+ @property
+ def _target_object(self) -> build.BuildTarget:
+ if isinstance(self.held_object, build.BothLibraries):
+ return self.held_object.get_default_object()
+ assert isinstance(self.held_object, build.BuildTarget)
+ return self.held_object
+
+ def is_cross(self) -> bool:
+ return not self._target_object.environment.machines.matches_build_machine(self._target_object.for_machine)
+
+ @noPosargs
+ @noKwargs
+ def found_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ if not (isinstance(self.held_object, build.Executable) and self.held_object.was_returned_by_find_program):
+ FeatureNew.single_use('BuildTarget.found', '0.59.0', subproject=self.held_object.subproject)
+ return True
+
+ @noPosargs
+ @noKwargs
+ def private_dir_include_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> build.IncludeDirs:
+ return build.IncludeDirs('', [], False, [self.interpreter.backend.get_target_private_dir(self._target_object)])
+
+ @noPosargs
+ @noKwargs
+ def full_path_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.interpreter.backend.get_target_filename_abs(self._target_object)
+
+ @noPosargs
+ @noKwargs
+ @FeatureDeprecated('BuildTarget.path', '0.55.0', 'Use BuildTarget.full_path instead')
+ def path_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.interpreter.backend.get_target_filename_abs(self._target_object)
+
+ @noPosargs
+ @noKwargs
+ def outdir_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.interpreter.backend.get_target_dir(self._target_object)
+
+ @noKwargs
+ @typed_pos_args('extract_objects', varargs=(mesonlib.File, str, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList))
+ def extract_objects_method(self, args: T.Tuple[T.List[T.Union[mesonlib.FileOrString, 'build.GeneratedTypes']]], kwargs: TYPE_nkwargs) -> build.ExtractedObjects:
+ return self._target_object.extract_objects(args[0])
+
+ @noPosargs
+ @typed_kwargs(
+ 'extract_all_objects',
+ KwargInfo(
+ 'recursive', bool, default=False, since='0.46.0',
+ not_set_warning=textwrap.dedent('''\
+ extract_all_objects called without setting recursive
+ keyword argument. Meson currently defaults to
+ non-recursive to maintain backward compatibility but
+ the default will be changed in the future.
+ ''')
+ )
+ )
+ def extract_all_objects_method(self, args: T.List[TYPE_nvar], kwargs: 'kwargs.BuildTargeMethodExtractAllObjects') -> build.ExtractedObjects:
+ return self._target_object.extract_all_objects(kwargs['recursive'])
+
+ @noPosargs
+ @noKwargs
+ def get_id_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self._target_object.get_id()
+
+ @FeatureNew('name', '0.54.0')
+ @noPosargs
+ @noKwargs
+ def name_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self._target_object.name
+
+class ExecutableHolder(BuildTargetHolder[build.Executable]):
+ pass
+
+class StaticLibraryHolder(BuildTargetHolder[build.StaticLibrary]):
+ pass
+
+class SharedLibraryHolder(BuildTargetHolder[build.SharedLibrary]):
+ pass
+
+class BothLibrariesHolder(BuildTargetHolder[build.BothLibraries]):
+ def __init__(self, libs: build.BothLibraries, interp: 'Interpreter'):
+ # FIXME: This build target always represents the shared library, but
+ # that should be configurable.
+ super().__init__(libs, interp)
+ self.methods.update({'get_shared_lib': self.get_shared_lib_method,
+ 'get_static_lib': self.get_static_lib_method,
+ })
+
+ def __repr__(self) -> str:
+ r = '<{} {}: {}, {}: {}>'
+ h1 = self.held_object.shared
+ h2 = self.held_object.static
+ return r.format(self.__class__.__name__, h1.get_id(), h1.filename, h2.get_id(), h2.filename)
+
+ @noPosargs
+ @noKwargs
+ def get_shared_lib_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> build.SharedLibrary:
+ return self.held_object.shared
+
+ @noPosargs
+ @noKwargs
+ def get_static_lib_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> build.StaticLibrary:
+ return self.held_object.static
+
+class SharedModuleHolder(BuildTargetHolder[build.SharedModule]):
+ pass
+
+class JarHolder(BuildTargetHolder[build.Jar]):
+ pass
+
+class CustomTargetIndexHolder(ObjectHolder[build.CustomTargetIndex]):
+ def __init__(self, target: build.CustomTargetIndex, interp: 'Interpreter'):
+ super().__init__(target, interp)
+ self.methods.update({'full_path': self.full_path_method,
+ })
+
+ @FeatureNew('custom_target[i].full_path', '0.54.0')
+ @noPosargs
+ @noKwargs
+ def full_path_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ assert self.interpreter.backend is not None
+ return self.interpreter.backend.get_target_filename_abs(self.held_object)
+
+class CustomTargetHolder(ObjectHolder[build.CustomTarget]):
+ def __init__(self, target: 'build.CustomTarget', interp: 'Interpreter'):
+ super().__init__(target, interp)
+ self.methods.update({'full_path': self.full_path_method,
+ 'to_list': self.to_list_method,
+ })
+
+ self.operators.update({
+ MesonOperator.INDEX: self.op_index,
+ })
+
+ def __repr__(self) -> str:
+ r = '<{} {}: {}>'
+ h = self.held_object
+ return r.format(self.__class__.__name__, h.get_id(), h.command)
+
+ @noPosargs
+ @noKwargs
+ def full_path_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.interpreter.backend.get_target_filename_abs(self.held_object)
+
+ @FeatureNew('custom_target.to_list', '0.54.0')
+ @noPosargs
+ @noKwargs
+ def to_list_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.List[build.CustomTargetIndex]:
+ result = []
+ for i in self.held_object:
+ result.append(i)
+ return result
+
+ @noKwargs
+ @typed_operator(MesonOperator.INDEX, int)
+ def op_index(self, other: int) -> build.CustomTargetIndex:
+ try:
+ return self.held_object[other]
+ except IndexError:
+ raise InvalidArguments(f'Index {other} out of bounds of custom target {self.held_object.name} output of size {len(self.held_object)}.')
+
+class RunTargetHolder(ObjectHolder[build.RunTarget]):
+ pass
+
+class AliasTargetHolder(ObjectHolder[build.AliasTarget]):
+ pass
+
+class GeneratedListHolder(ObjectHolder[build.GeneratedList]):
+ pass
+
+class GeneratorHolder(ObjectHolder[build.Generator]):
+ def __init__(self, gen: build.Generator, interpreter: 'Interpreter'):
+ super().__init__(gen, interpreter)
+ self.methods.update({'process': self.process_method})
+
+ @typed_pos_args('generator.process', min_varargs=1, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList))
+ @typed_kwargs(
+ 'generator.process',
+ KwargInfo('preserve_path_from', (str, NoneType), since='0.45.0'),
+ KwargInfo('extra_args', ContainerTypeInfo(list, str), listify=True, default=[]),
+ )
+ def process_method(self,
+ args: T.Tuple[T.List[T.Union[str, mesonlib.File, 'build.GeneratedTypes']]],
+ kwargs: 'kwargs.GeneratorProcess') -> build.GeneratedList:
+ preserve_path_from = kwargs['preserve_path_from']
+ if preserve_path_from is not None:
+ preserve_path_from = os.path.normpath(preserve_path_from)
+ if not os.path.isabs(preserve_path_from):
+ # This is a bit of a hack. Fix properly before merging.
+ raise InvalidArguments('Preserve_path_from must be an absolute path for now. Sorry.')
+
+ if any(isinstance(a, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for a in args[0]):
+ FeatureNew.single_use(
+ 'Calling generator.process with CustomTarget or Index of CustomTarget.',
+ '0.57.0', self.interpreter.subproject)
+
+ gl = self.held_object.process_files(args[0], self.interpreter,
+ preserve_path_from, extra_args=kwargs['extra_args'])
+
+ return gl
diff -Nru meson-0.53.2/mesonbuild/interpreter/interpreter.py meson-0.61.2/mesonbuild/interpreter/interpreter.py
--- meson-0.53.2/mesonbuild/interpreter/interpreter.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/interpreter.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,2887 @@
+# Copyright 2012-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 .. import mparser
+from .. import environment
+from .. import coredata
+from .. import dependencies
+from .. import mlog
+from .. import build
+from .. import optinterpreter
+from .. import compilers
+from .. import envconfig
+from ..wrap import wrap, WrapMode
+from .. import mesonlib
+from ..mesonlib import MesonBugException, HoldableObject, FileMode, MachineChoice, OptionKey, listify, extract_as_list, has_path_sep
+from ..programs import ExternalProgram, NonExistingExternalProgram
+from ..dependencies import Dependency
+from ..depfile import DepFile
+from ..interpreterbase import ContainerTypeInfo, InterpreterBase, KwargInfo, typed_kwargs, typed_pos_args
+from ..interpreterbase import noPosargs, noKwargs, permittedKwargs, noArgsFlattening, noSecondLevelHolderResolving, unholder_return
+from ..interpreterbase import InterpreterException, InvalidArguments, InvalidCode, SubdirDoneRequest
+from ..interpreterbase import Disabler, disablerIfNotFound
+from ..interpreterbase import FeatureNew, FeatureDeprecated, FeatureNewKwargs, FeatureDeprecatedKwargs
+from ..interpreterbase import ObjectHolder
+from ..interpreterbase.baseobjects import TYPE_var, TYPE_kwargs
+from ..modules import ExtensionModule, ModuleObject, MutableModuleObject, NewExtensionModule, NotFoundExtensionModule
+from ..cmake import CMakeInterpreter
+from ..backend.backends import Backend, ExecutableSerialisation
+
+from . import interpreterobjects as OBJ
+from . import compiler as compilerOBJ
+from .mesonmain import MesonMain
+from .dependencyfallbacks import DependencyFallbacksHolder
+from .interpreterobjects import (
+ SubprojectHolder,
+ ConfigurationDataObject,
+ Test,
+ RunProcess,
+ extract_required_kwarg,
+ extract_search_dirs,
+ NullSubprojectInterpreter,
+)
+from .type_checking import (
+ COMMAND_KW, CT_BUILD_ALWAYS, CT_BUILD_ALWAYS_STALE,
+ CT_BUILD_BY_DEFAULT,
+ CT_INPUT_KW,
+ CT_INSTALL_DIR_KW,
+ CT_OUTPUT_KW,
+ DEFAULT_OPTIONS,
+ DEPENDS_KW,
+ DEPEND_FILES_KW,
+ DEPFILE_KW,
+ DISABLER_KW,
+ ENV_KW,
+ INSTALL_KW,
+ INSTALL_MODE_KW,
+ CT_INSTALL_TAG_KW,
+ LANGUAGE_KW,
+ NATIVE_KW, OVERRIDE_OPTIONS_KW,
+ REQUIRED_KW,
+ NoneType,
+ in_set_validator,
+)
+from . import primitives as P_OBJ
+
+from pathlib import Path
+import os
+import shutil
+import uuid
+import re
+import stat
+import collections
+import typing as T
+import textwrap
+import importlib
+
+if T.TYPE_CHECKING:
+ import argparse
+
+ from . import kwargs
+ from ..programs import OverrideProgram
+
+ # Input source types passed to Targets
+ SourceInputs = T.Union[mesonlib.File, build.GeneratedList, build.BuildTarget, build.BothLibraries,
+ build.CustomTargetIndex, build.CustomTarget, build.GeneratedList,
+ build.ExtractedObjects, str]
+ # Input source types passed to the build.Target classes
+ SourceOutputs = T.Union[mesonlib.File, build.GeneratedList,
+ build.BuildTarget, build.CustomTargetIndex, build.CustomTarget,
+ build.ExtractedObjects, build.GeneratedList]
+
+
+def _project_version_validator(value: T.Union[T.List, str, mesonlib.File, None]) -> T.Optional[str]:
+ if isinstance(value, list):
+ if len(value) != 1:
+ return 'when passed as array must have a length of 1'
+ elif not isinstance(value[0], (str, mesonlib.File)):
+ return 'when passed as array must contain a string or File'
+ return None
+
+
+def stringifyUserArguments(args, quote=False):
+ if isinstance(args, list):
+ return '[%s]' % ', '.join([stringifyUserArguments(x, True) for x in args])
+ elif isinstance(args, dict):
+ return '{%s}' % ', '.join(['{} : {}'.format(stringifyUserArguments(k, True), stringifyUserArguments(v, True)) for k, v in args.items()])
+ elif isinstance(args, bool):
+ return 'true' if args else 'false'
+ elif isinstance(args, int):
+ return str(args)
+ elif isinstance(args, str):
+ return f"'{args}'" if quote else args
+ raise InvalidArguments('Function accepts only strings, integers, bools, lists, dictionaries and lists thereof.')
+
+class Summary:
+ def __init__(self, project_name: str, project_version: str):
+ self.project_name = project_name
+ self.project_version = project_version
+ self.sections = collections.defaultdict(dict)
+ self.max_key_len = 0
+
+ def add_section(self, section: str, values: T.Dict[str, T.Any], bool_yn: bool,
+ list_sep: T.Optional[str], subproject: str) -> None:
+ for k, v in values.items():
+ if k in self.sections[section]:
+ raise InterpreterException(f'Summary section {section!r} already have key {k!r}')
+ formatted_values = []
+ for i in listify(v):
+ if isinstance(i, bool) and bool_yn:
+ formatted_values.append(mlog.green('YES') if i else mlog.red('NO'))
+ elif isinstance(i, (str, int, bool)):
+ formatted_values.append(str(i))
+ elif isinstance(i, (ExternalProgram, Dependency)):
+ FeatureNew.single_use('dependency or external program in summary', '0.57.0', subproject)
+ formatted_values.append(i.summary_value())
+ elif isinstance(i, coredata.UserOption):
+ FeatureNew.single_use('feature option in summary', '0.58.0', subproject)
+ formatted_values.append(i.printable_value())
+ else:
+ m = 'Summary value in section {!r}, key {!r}, must be string, integer, boolean, dependency or external program'
+ raise InterpreterException(m.format(section, k))
+ self.sections[section][k] = (formatted_values, list_sep)
+ self.max_key_len = max(self.max_key_len, len(k))
+
+ def dump(self):
+ mlog.log(self.project_name, mlog.normal_cyan(self.project_version))
+ for section, values in self.sections.items():
+ mlog.log('') # newline
+ if section:
+ mlog.log(' ', mlog.bold(section))
+ for k, v in values.items():
+ v, list_sep = v
+ padding = self.max_key_len - len(k)
+ end = ' ' if v else ''
+ mlog.log(' ' * 3, k + ' ' * padding + ':', end=end)
+ indent = self.max_key_len + 6
+ self.dump_value(v, list_sep, indent)
+ mlog.log('') # newline
+
+ def dump_value(self, arr, list_sep, indent):
+ lines_sep = '\n' + ' ' * indent
+ if list_sep is None:
+ mlog.log(*arr, sep=lines_sep)
+ return
+ max_len = shutil.get_terminal_size().columns
+ line = []
+ line_len = indent
+ lines_sep = list_sep.rstrip() + lines_sep
+ for v in arr:
+ v_len = len(v) + len(list_sep)
+ if line and line_len + v_len > max_len:
+ mlog.log(*line, sep=list_sep, end=lines_sep)
+ line_len = indent
+ line = []
+ line.append(v)
+ line_len += v_len
+ mlog.log(*line, sep=list_sep)
+
+known_library_kwargs = (
+ build.known_shlib_kwargs |
+ build.known_stlib_kwargs
+)
+
+known_build_target_kwargs = (
+ known_library_kwargs |
+ build.known_exe_kwargs |
+ build.known_jar_kwargs |
+ {'target_type'}
+)
+
+TEST_KWARGS: T.List[KwargInfo] = [
+ KwargInfo('args', ContainerTypeInfo(list, (str, mesonlib.File, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex)),
+ listify=True, default=[]),
+ KwargInfo('should_fail', bool, default=False),
+ KwargInfo('timeout', int, default=30),
+ KwargInfo('workdir', (str, NoneType), default=None,
+ validator=lambda x: 'must be an absolute path' if not os.path.isabs(x) else None),
+ KwargInfo('protocol', str,
+ default='exitcode',
+ validator=in_set_validator({'exitcode', 'tap', 'gtest', 'rust'}),
+ since_values={'gtest': '0.55.0', 'rust': '0.57.0'}),
+ KwargInfo('priority', int, default=0, since='0.52.0'),
+ # TODO: env needs reworks of the way the environment variable holder itself works probably
+ ENV_KW,
+ DEPENDS_KW.evolve(since='0.46.0'),
+ KwargInfo('suite', ContainerTypeInfo(list, str), listify=True, default=['']), # yes, a list of empty string
+]
+
+permitted_dependency_kwargs = {
+ 'allow_fallback',
+ 'cmake_args',
+ 'cmake_module_path',
+ 'cmake_package_version',
+ 'components',
+ 'default_options',
+ 'fallback',
+ 'include_type',
+ 'language',
+ 'main',
+ 'method',
+ 'modules',
+ 'native',
+ 'not_found_message',
+ 'optional_modules',
+ 'private_headers',
+ 'required',
+ 'static',
+ 'version',
+}
+
+implicit_check_false_warning = """You should add the boolean check kwarg to the run_command call.
+ It currently defaults to false,
+ but it will default to true in future releases of meson.
+ See also: https://github.com/mesonbuild/meson/issues/9300"""
+class Interpreter(InterpreterBase, HoldableObject):
+
+ def __init__(
+ self,
+ _build: build.Build,
+ backend: T.Optional[Backend] = None,
+ subproject: str = '',
+ subdir: str = '',
+ subproject_dir: str = 'subprojects',
+ default_project_options: T.Optional[T.Dict[str, str]] = None,
+ mock: bool = False,
+ ast: T.Optional[mparser.CodeBlockNode] = None,
+ is_translated: bool = False,
+ user_defined_options: T.Optional['argparse.Namespace'] = None,
+ ) -> None:
+ super().__init__(_build.environment.get_source_dir(), subdir, subproject)
+ self.active_projectname = ''
+ self.build = _build
+ self.environment = self.build.environment
+ self.coredata = self.environment.get_coredata()
+ self.backend = backend
+ self.summary: T.Dict[str, 'Summary'] = {}
+ self.modules = {}
+ # Subproject directory is usually the name of the subproject, but can
+ # be different for dependencies provided by wrap files.
+ self.subproject_directory_name = subdir.split(os.path.sep)[-1]
+ self.subproject_dir = subproject_dir
+ self.option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt')
+ if not mock and ast is None:
+ self.load_root_meson_file()
+ self.sanity_check_ast()
+ elif ast is not None:
+ self.ast = ast
+ self.sanity_check_ast()
+ self.builtin.update({'meson': MesonMain(self.build, self)})
+ self.generators: T.List[build.Generator] = []
+ self.processed_buildfiles = set() # type: T.Set[str]
+ self.project_args_frozen = False
+ self.global_args_frozen = False # implies self.project_args_frozen
+ self.subprojects: T.Dict[str, SubprojectHolder] = {}
+ self.subproject_stack = []
+ self.configure_file_outputs = {}
+ # Passed from the outside, only used in subprojects.
+ if default_project_options:
+ self.default_project_options = default_project_options.copy()
+ else:
+ self.default_project_options = {}
+ self.project_default_options = {}
+ self.build_func_dict()
+ self.build_holder_map()
+ self.user_defined_options = user_defined_options
+
+ # build_def_files needs to be defined before parse_project is called
+ #
+ # For non-meson subprojects, we'll be using the ast. Even if it does
+ # exist we don't want to add a dependency on it, it's autogenerated
+ # from the actual build files, and is just for reference.
+ self.build_def_files = []
+ build_filename = os.path.join(self.subdir, environment.build_filename)
+ if not is_translated:
+ self.build_def_files.append(build_filename)
+ if not mock:
+ self.parse_project()
+ self._redetect_machines()
+
+ def __getnewargs_ex__(self) -> T.Tuple[T.Tuple[object], T.Dict[str, object]]:
+ raise MesonBugException('This class is unpicklable')
+
+ def _redetect_machines(self):
+ # Re-initialize machine descriptions. We can do a better job now because we
+ # have the compilers needed to gain more knowledge, so wipe out old
+ # inference and start over.
+ machines = self.build.environment.machines.miss_defaulting()
+ machines.build = environment.detect_machine_info(self.coredata.compilers.build)
+ self.build.environment.machines = machines.default_missing()
+ assert self.build.environment.machines.build.cpu is not None
+ assert self.build.environment.machines.host.cpu is not None
+ assert self.build.environment.machines.target.cpu is not None
+
+ self.builtin['build_machine'] = \
+ OBJ.MachineHolder(self.build.environment.machines.build, self)
+ self.builtin['host_machine'] = \
+ OBJ.MachineHolder(self.build.environment.machines.host, self)
+ self.builtin['target_machine'] = \
+ OBJ.MachineHolder(self.build.environment.machines.target, self)
+
+ def build_func_dict(self):
+ self.funcs.update({'add_global_arguments': self.func_add_global_arguments,
+ 'add_global_link_arguments': self.func_add_global_link_arguments,
+ 'add_languages': self.func_add_languages,
+ 'add_project_arguments': self.func_add_project_arguments,
+ 'add_project_link_arguments': self.func_add_project_link_arguments,
+ 'add_test_setup': self.func_add_test_setup,
+ 'alias_target': self.func_alias_target,
+ 'assert': self.func_assert,
+ 'benchmark': self.func_benchmark,
+ 'both_libraries': self.func_both_lib,
+ 'build_target': self.func_build_target,
+ 'configuration_data': self.func_configuration_data,
+ 'configure_file': self.func_configure_file,
+ 'custom_target': self.func_custom_target,
+ 'declare_dependency': self.func_declare_dependency,
+ 'dependency': self.func_dependency,
+ 'disabler': self.func_disabler,
+ 'environment': self.func_environment,
+ 'error': self.func_error,
+ 'executable': self.func_executable,
+ 'files': self.func_files,
+ 'find_library': self.func_find_library,
+ 'find_program': self.func_find_program,
+ 'generator': self.func_generator,
+ 'get_option': self.func_get_option,
+ 'get_variable': self.func_get_variable,
+ 'gettext': self.func_gettext,
+ 'import': self.func_import,
+ 'include_directories': self.func_include_directories,
+ 'install_data': self.func_install_data,
+ 'install_emptydir': self.func_install_emptydir,
+ 'install_headers': self.func_install_headers,
+ 'install_man': self.func_install_man,
+ 'install_subdir': self.func_install_subdir,
+ 'install_symlink': self.func_install_symlink,
+ 'is_disabler': self.func_is_disabler,
+ 'is_variable': self.func_is_variable,
+ 'jar': self.func_jar,
+ 'join_paths': self.func_join_paths,
+ 'library': self.func_library,
+ 'message': self.func_message,
+ 'option': self.func_option,
+ 'project': self.func_project,
+ 'range': self.func_range,
+ 'run_command': self.func_run_command,
+ 'run_target': self.func_run_target,
+ 'set_variable': self.func_set_variable,
+ 'subdir': self.func_subdir,
+ 'shared_library': self.func_shared_lib,
+ 'shared_module': self.func_shared_module,
+ 'static_library': self.func_static_lib,
+ 'subdir_done': self.func_subdir_done,
+ 'subproject': self.func_subproject,
+ 'summary': self.func_summary,
+ 'test': self.func_test,
+ 'unset_variable': self.func_unset_variable,
+ 'vcs_tag': self.func_vcs_tag,
+ 'warning': self.func_warning,
+ })
+ if 'MESON_UNIT_TEST' in os.environ:
+ self.funcs.update({'exception': self.func_exception})
+
+ def build_holder_map(self) -> None:
+ '''
+ Build a mapping of `HoldableObject` types to their corresponding
+ `ObjectHolder`s. This mapping is used in `InterpreterBase` to automatically
+ holderify all returned values from methods and functions.
+ '''
+ self.holder_map.update({
+ # Primitives
+ list: P_OBJ.ArrayHolder,
+ dict: P_OBJ.DictHolder,
+ int: P_OBJ.IntegerHolder,
+ bool: P_OBJ.BooleanHolder,
+ str: P_OBJ.StringHolder,
+ P_OBJ.MesonVersionString: P_OBJ.MesonVersionStringHolder,
+
+ # Meson types
+ mesonlib.File: OBJ.FileHolder,
+ build.SharedLibrary: OBJ.SharedLibraryHolder,
+ build.StaticLibrary: OBJ.StaticLibraryHolder,
+ build.BothLibraries: OBJ.BothLibrariesHolder,
+ build.SharedModule: OBJ.SharedModuleHolder,
+ build.Executable: OBJ.ExecutableHolder,
+ build.Jar: OBJ.JarHolder,
+ build.CustomTarget: OBJ.CustomTargetHolder,
+ build.CustomTargetIndex: OBJ.CustomTargetIndexHolder,
+ build.Generator: OBJ.GeneratorHolder,
+ build.GeneratedList: OBJ.GeneratedListHolder,
+ build.ExtractedObjects: OBJ.GeneratedObjectsHolder,
+ build.RunTarget: OBJ.RunTargetHolder,
+ build.AliasTarget: OBJ.AliasTargetHolder,
+ build.Headers: OBJ.HeadersHolder,
+ build.Man: OBJ.ManHolder,
+ build.EmptyDir: OBJ.EmptyDirHolder,
+ build.Data: OBJ.DataHolder,
+ build.SymlinkData: OBJ.SymlinkDataHolder,
+ build.InstallDir: OBJ.InstallDirHolder,
+ build.IncludeDirs: OBJ.IncludeDirsHolder,
+ build.EnvironmentVariables: OBJ.EnvironmentVariablesHolder,
+ compilers.RunResult: compilerOBJ.TryRunResultHolder,
+ dependencies.ExternalLibrary: OBJ.ExternalLibraryHolder,
+ coredata.UserFeatureOption: OBJ.FeatureOptionHolder,
+ envconfig.MachineInfo: OBJ.MachineHolder,
+ })
+
+ '''
+ Build a mapping of `HoldableObject` base classes to their
+ corresponding `ObjectHolder`s. The difference to `self.holder_map`
+ is that the keys here define an upper bound instead of requiring an
+ exact match.
+
+ The mappings defined here are only used when there was no direct hit
+ found in `self.holder_map`.
+ '''
+ self.bound_holder_map.update({
+ dependencies.Dependency: OBJ.DependencyHolder,
+ ExternalProgram: OBJ.ExternalProgramHolder,
+ compilers.Compiler: compilerOBJ.CompilerHolder,
+ ModuleObject: OBJ.ModuleObjectHolder,
+ MutableModuleObject: OBJ.MutableModuleObjectHolder,
+ })
+
+ def append_holder_map(self, held_type: T.Type[mesonlib.HoldableObject], holder_type: T.Type[ObjectHolder]) -> None:
+ '''
+ Adds one additional mapping to the `holder_map`.
+
+ The intended use for this function is in the `initialize` method of
+ modules to register custom object holders.
+ '''
+ self.holder_map.update({
+ held_type: holder_type
+ })
+
+ def process_new_values(self, invalues: T.List[T.Union[TYPE_var, ExecutableSerialisation]]) -> None:
+ invalues = listify(invalues)
+ for v in invalues:
+ if isinstance(v, ObjectHolder):
+ raise InterpreterException('Modules must not return ObjectHolders')
+ if isinstance(v, (build.BuildTarget, build.CustomTarget, build.RunTarget)):
+ self.add_target(v.name, v)
+ elif isinstance(v, list):
+ self.process_new_values(v)
+ elif isinstance(v, ExecutableSerialisation):
+ v.subproject = self.subproject
+ self.build.install_scripts.append(v)
+ elif isinstance(v, build.Data):
+ self.build.data.append(v)
+ elif isinstance(v, build.SymlinkData):
+ self.build.symlinks.append(v)
+ elif isinstance(v, dependencies.InternalDependency):
+ # FIXME: This is special cased and not ideal:
+ # The first source is our new VapiTarget, the rest are deps
+ self.process_new_values(v.sources[0])
+ elif isinstance(v, build.InstallDir):
+ self.build.install_dirs.append(v)
+ elif isinstance(v, Test):
+ self.build.tests.append(v)
+ elif isinstance(v, (int, str, bool, Disabler, ObjectHolder, build.GeneratedList,
+ ExternalProgram)):
+ pass
+ else:
+ raise InterpreterException(f'Module returned a value of unknown type {v!r}.')
+
+ def get_build_def_files(self) -> T.List[str]:
+ return self.build_def_files
+
+ def add_build_def_file(self, f: mesonlib.FileOrString) -> None:
+ # Use relative path for files within source directory, and absolute path
+ # for system files. Skip files within build directory. Also skip not regular
+ # files (e.g. /dev/stdout) Normalize the path to avoid duplicates, this
+ # is especially important to convert '/' to '\' on Windows.
+ if isinstance(f, mesonlib.File):
+ if f.is_built:
+ return
+ f = os.path.normpath(f.relative_name())
+ elif os.path.isfile(f) and not f.startswith('/dev'):
+ srcdir = Path(self.environment.get_source_dir())
+ builddir = Path(self.environment.get_build_dir())
+ try:
+ f = Path(f).resolve()
+ except OSError:
+ f = Path(f)
+ s = f.stat()
+ if (hasattr(s, 'st_file_attributes') and
+ s.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT != 0 and
+ s.st_reparse_tag == stat.IO_REPARSE_TAG_APPEXECLINK):
+ # This is a Windows Store link which we can't
+ # resolve, so just do our best otherwise.
+ f = f.parent.resolve() / f.name
+ else:
+ raise
+ if builddir in f.parents:
+ return
+ if srcdir in f.parents:
+ f = f.relative_to(srcdir)
+ f = str(f)
+ else:
+ return
+ if f not in self.build_def_files:
+ self.build_def_files.append(f)
+
+ def get_variables(self):
+ return self.variables
+
+ def check_stdlibs(self):
+ machine_choices = [MachineChoice.HOST]
+ if self.coredata.is_cross_build():
+ machine_choices.append(MachineChoice.BUILD)
+ for for_machine in machine_choices:
+ props = self.build.environment.properties[for_machine]
+ for l in self.coredata.compilers[for_machine].keys():
+ try:
+ di = mesonlib.stringlistify(props.get_stdlib(l))
+ except KeyError:
+ continue
+ if len(di) == 1:
+ FeatureNew.single_use('stdlib without variable name', '0.56.0', self.subproject, location=self.current_node)
+ kwargs = {'native': for_machine is MachineChoice.BUILD,
+ }
+ name = l + '_stdlib'
+ df = DependencyFallbacksHolder(self, [name])
+ df.set_fallback(di)
+ dep = df.lookup(kwargs, force_fallback=True)
+ self.build.stdlibs[for_machine][l] = dep
+
+ def _import_module(self, modname: str, required: bool) -> T.Union[ExtensionModule, NewExtensionModule, NotFoundExtensionModule]:
+ if modname in self.modules:
+ return self.modules[modname]
+ try:
+ module = importlib.import_module('mesonbuild.modules.' + modname)
+ except ImportError:
+ if required:
+ raise InvalidArguments(f'Module "{modname}" does not exist')
+ ext_module = NotFoundExtensionModule()
+ else:
+ ext_module = module.initialize(self)
+ assert isinstance(ext_module, (ExtensionModule, NewExtensionModule))
+ self.build.modules.append(modname)
+ self.modules[modname] = ext_module
+ return ext_module
+
+ @typed_pos_args('import', str)
+ @typed_kwargs(
+ 'import',
+ REQUIRED_KW.evolve(since='0.59.0'),
+ DISABLER_KW.evolve(since='0.59.0'),
+ )
+ @disablerIfNotFound
+ def func_import(self, node: mparser.BaseNode, args: T.Tuple[str],
+ kwargs: 'kwargs.FuncImportModule') -> T.Union[ExtensionModule, NewExtensionModule, NotFoundExtensionModule]:
+ modname = args[0]
+ disabled, required, _ = extract_required_kwarg(kwargs, self.subproject)
+ if disabled:
+ return NotFoundExtensionModule()
+
+ if modname.startswith('unstable-'):
+ plainname = modname.split('-', 1)[1]
+ try:
+ # check if stable module exists
+ mod = self._import_module(plainname, required)
+ # XXX: this is actually not helpful, since it doesn't do a version check
+ mlog.warning(f'Module {modname} is now stable, please use the {plainname} module instead.')
+ return mod
+ except InvalidArguments:
+ mlog.warning(f'Module {modname} has no backwards or forwards compatibility and might not exist in future releases.', location=node)
+ modname = 'unstable_' + plainname
+ return self._import_module(modname, required)
+
+ @typed_pos_args('files', varargs=str)
+ @noKwargs
+ def func_files(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> T.List[mesonlib.File]:
+ return [mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, fname) for fname in args[0]]
+
+ # Used by declare_dependency() and pkgconfig.generate()
+ def extract_variables(self, kwargs, argname='variables', list_new=False, dict_new=False):
+ variables = kwargs.get(argname, {})
+ if isinstance(variables, dict):
+ if dict_new and variables:
+ FeatureNew.single_use(f'{argname} as dictionary', '0.56.0', self.subproject, location=self.current_node)
+ else:
+ varlist = mesonlib.stringlistify(variables)
+ if list_new:
+ FeatureNew.single_use(f'{argname} as list of strings', '0.56.0', self.subproject, location=self.current_node)
+ variables = collections.OrderedDict()
+ for v in varlist:
+ try:
+ (key, value) = v.split('=', 1)
+ except ValueError:
+ raise InterpreterException(f'Variable {v!r} must have a value separated by equals sign.')
+ variables[key.strip()] = value.strip()
+ for k, v in variables.items():
+ if not k or not v:
+ raise InterpreterException('Empty variable name or value')
+ if any(c.isspace() for c in k):
+ raise InterpreterException(f'Invalid whitespace in variable name "{k}"')
+ if not isinstance(v, str):
+ raise InterpreterException('variables values must be strings.')
+ return variables
+
+ @FeatureNewKwargs('declare_dependency', '0.46.0', ['link_whole'])
+ @FeatureNewKwargs('declare_dependency', '0.54.0', ['variables'])
+ @permittedKwargs({'include_directories', 'link_with', 'sources', 'dependencies',
+ 'compile_args', 'link_args', 'link_whole', 'version',
+ 'variables'})
+ @noPosargs
+ def func_declare_dependency(self, node, args, kwargs):
+ version = kwargs.get('version', self.project_version)
+ if not isinstance(version, str):
+ raise InterpreterException('Version must be a string.')
+ incs = self.extract_incdirs(kwargs)
+ libs = extract_as_list(kwargs, 'link_with')
+ libs_whole = extract_as_list(kwargs, 'link_whole')
+ sources = extract_as_list(kwargs, 'sources')
+ sources = listify(self.source_strings_to_files(sources))
+ deps = extract_as_list(kwargs, 'dependencies')
+ compile_args = mesonlib.stringlistify(kwargs.get('compile_args', []))
+ link_args = mesonlib.stringlistify(kwargs.get('link_args', []))
+ variables = self.extract_variables(kwargs, list_new=True)
+ final_deps = []
+ for d in deps:
+ if not isinstance(d, (dependencies.Dependency, dependencies.ExternalLibrary, dependencies.InternalDependency)):
+ raise InterpreterException('Dependencies must be external deps')
+ final_deps.append(d)
+ for l in libs:
+ if isinstance(l, dependencies.Dependency):
+ raise InterpreterException('''Entries in "link_with" may only be self-built targets,
+external dependencies (including libraries) must go to "dependencies".''')
+ dep = dependencies.InternalDependency(version, incs, compile_args,
+ link_args, libs, libs_whole, sources, final_deps,
+ variables)
+ return dep
+
+ @typed_pos_args('assert', bool, optargs=[str])
+ @noKwargs
+ def func_assert(self, node: mparser.FunctionNode, args: T.Tuple[bool, T.Optional[str]],
+ kwargs: 'TYPE_kwargs') -> None:
+ value, message = args
+ if message is None:
+ FeatureNew.single_use('assert function without message argument', '0.53.0', self.subproject, location=node)
+
+ if not value:
+ if message is None:
+ from ..ast import AstPrinter
+ printer = AstPrinter()
+ node.args.arguments[0].accept(printer)
+ message = printer.result
+ raise InterpreterException('Assert failed: ' + message)
+
+ def validate_arguments(self, args, argcount, arg_types):
+ if argcount is not None:
+ if argcount != len(args):
+ raise InvalidArguments(f'Expected {argcount} arguments, got {len(args)}.')
+ for actual, wanted in zip(args, arg_types):
+ if wanted is not None:
+ if not isinstance(actual, wanted):
+ raise InvalidArguments('Incorrect argument type.')
+
+ # Executables aren't actually accepted, but we allow them here to allow for
+ # better error messages when overridden
+ @typed_pos_args(
+ 'run_command',
+ (build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str),
+ varargs=(build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str))
+ @typed_kwargs(
+ 'run_command',
+ KwargInfo('check', (bool, NoneType), since='0.47.0'),
+ KwargInfo('capture', bool, default=True, since='0.47.0'),
+ ENV_KW.evolve(since='0.50.0'),
+ )
+ def func_run_command(self, node: mparser.BaseNode,
+ args: T.Tuple[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str],
+ T.List[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str]]],
+ kwargs: 'kwargs.RunCommand') -> RunProcess:
+ return self.run_command_impl(node, args, kwargs)
+
+ def run_command_impl(self,
+ node: mparser.BaseNode,
+ args: T.Tuple[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str],
+ T.List[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str]]],
+ kwargs: 'kwargs.RunCommand',
+ in_builddir: bool = False) -> RunProcess:
+ cmd, cargs = args
+ capture = kwargs['capture']
+ env = kwargs['env']
+ srcdir = self.environment.get_source_dir()
+ builddir = self.environment.get_build_dir()
+
+ check = kwargs['check']
+ if check is None:
+ mlog.warning(implicit_check_false_warning, once=True)
+ check = False
+
+ m = 'must be a string, or the output of find_program(), files() '\
+ 'or configure_file(), or a compiler object; not {!r}'
+ overridden_msg = ('Program {!r} was overridden with the compiled '
+ 'executable {!r} and therefore cannot be used during '
+ 'configuration')
+ expanded_args: T.List[str] = []
+ if isinstance(cmd, build.Executable):
+ progname = node.args.arguments[0].value
+ raise InterpreterException(overridden_msg.format(progname, cmd.description()))
+ if isinstance(cmd, ExternalProgram):
+ if not cmd.found():
+ raise InterpreterException(f'command {cmd.get_name()!r} not found or not executable')
+ elif isinstance(cmd, compilers.Compiler):
+ exelist = cmd.get_exelist()
+ cmd = exelist[0]
+ prog = ExternalProgram(cmd, silent=True)
+ if not prog.found():
+ raise InterpreterException(f'Program {cmd!r} not found or not executable')
+ cmd = prog
+ expanded_args = exelist[1:]
+ else:
+ if isinstance(cmd, mesonlib.File):
+ cmd = cmd.absolute_path(srcdir, builddir)
+ # FIXME: This case can only be reached through configure_file, delete once that is typesafe
+ elif not isinstance(cmd, str):
+ raise InterpreterException('First argument ' + m.format(cmd))
+ # Prefer scripts in the current source directory
+ search_dir = os.path.join(srcdir, self.subdir)
+ prog = ExternalProgram(cmd, silent=True, search_dir=search_dir)
+ if not prog.found():
+ raise InterpreterException(f'Program or command {cmd!r} not found or not executable')
+ cmd = prog
+ for a in cargs:
+ if isinstance(a, str):
+ expanded_args.append(a)
+ elif isinstance(a, mesonlib.File):
+ expanded_args.append(a.absolute_path(srcdir, builddir))
+ elif isinstance(a, ExternalProgram):
+ expanded_args.append(a.get_path())
+ elif isinstance(a, compilers.Compiler):
+ FeatureNew.single_use('Compiler object as a variadic argument to `run_command`', '0.61.0', self.subproject, location=node)
+ prog = ExternalProgram(a.exelist[0], silent=True)
+ if not prog.found():
+ raise InterpreterException(f'Program {cmd!r} not found or not executable')
+ expanded_args.append(prog.get_path())
+ else:
+ raise InterpreterException(overridden_msg.format(a.name, cmd.description()))
+
+ # If any file that was used as an argument to the command
+ # changes, we must re-run the configuration step.
+ self.add_build_def_file(cmd.get_path())
+ for a in expanded_args:
+ if not os.path.isabs(a):
+ a = os.path.join(builddir if in_builddir else srcdir, self.subdir, a)
+ self.add_build_def_file(a)
+
+ return RunProcess(cmd, expanded_args, env, srcdir, builddir, self.subdir,
+ self.environment.get_build_command() + ['introspect'],
+ in_builddir=in_builddir, check=check, capture=capture)
+
+ def func_gettext(self, nodes, args, kwargs):
+ raise InterpreterException('Gettext() function has been moved to module i18n. Import it and use i18n.gettext() instead')
+
+ def func_option(self, nodes, args, kwargs):
+ raise InterpreterException('Tried to call option() in build description file. All options must be in the option file.')
+
+ @FeatureNewKwargs('subproject', '0.38.0', ['default_options'])
+ @permittedKwargs({'version', 'default_options', 'required'})
+ @typed_pos_args('subproject', str)
+ def func_subproject(self, nodes: mparser.BaseNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> SubprojectHolder:
+ return self.do_subproject(args[0], 'meson', kwargs)
+
+ def disabled_subproject(self, subp_name, disabled_feature=None, exception=None):
+ sub = SubprojectHolder(NullSubprojectInterpreter(), os.path.join(self.subproject_dir, subp_name),
+ disabled_feature=disabled_feature, exception=exception)
+ self.subprojects[subp_name] = sub
+ self.coredata.initialized_subprojects.add(subp_name)
+ return sub
+
+ def do_subproject(self, subp_name: str, method: str, kwargs):
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
+ if disabled:
+ mlog.log('Subproject', mlog.bold(subp_name), ':', 'skipped: feature', mlog.bold(feature), 'disabled')
+ return self.disabled_subproject(subp_name, disabled_feature=feature)
+
+ default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
+ default_options = coredata.create_options_dict(default_options, subp_name)
+
+ if subp_name == '':
+ raise InterpreterException('Subproject name must not be empty.')
+ if subp_name[0] == '.':
+ raise InterpreterException('Subproject name must not start with a period.')
+ if '..' in subp_name:
+ raise InterpreterException('Subproject name must not contain a ".." path segment.')
+ if os.path.isabs(subp_name):
+ raise InterpreterException('Subproject name must not be an absolute path.')
+ if has_path_sep(subp_name):
+ mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.',
+ location=self.current_node)
+ if subp_name in self.subproject_stack:
+ fullstack = self.subproject_stack + [subp_name]
+ incpath = ' => '.join(fullstack)
+ raise InvalidCode(f'Recursive include of subprojects: {incpath}.')
+ if subp_name in self.subprojects:
+ subproject = self.subprojects[subp_name]
+ if required and not subproject.found():
+ raise InterpreterException(f'Subproject "{subproject.subdir}" required but not found.')
+ return subproject
+
+ r = self.environment.wrap_resolver
+ try:
+ subdir = r.resolve(subp_name, method)
+ except wrap.WrapException as e:
+ if not required:
+ mlog.log(e)
+ mlog.log('Subproject ', mlog.bold(subp_name), 'is buildable:', mlog.red('NO'), '(disabling)')
+ return self.disabled_subproject(subp_name, exception=e)
+ raise e
+
+ subdir_abs = os.path.join(self.environment.get_source_dir(), subdir)
+ os.makedirs(os.path.join(self.build.environment.get_build_dir(), subdir), exist_ok=True)
+ self.global_args_frozen = True
+
+ stack = ':'.join(self.subproject_stack + [subp_name])
+ m = ['\nExecuting subproject', mlog.bold(stack)]
+ if method != 'meson':
+ m += ['method', mlog.bold(method)]
+ mlog.log(*m, '\n', nested=False)
+
+ try:
+ if method == 'meson':
+ return self._do_subproject_meson(subp_name, subdir, default_options, kwargs)
+ elif method == 'cmake':
+ return self._do_subproject_cmake(subp_name, subdir, subdir_abs, default_options, kwargs)
+ else:
+ raise mesonlib.MesonBugException(f'The method {method} is invalid for the subproject {subp_name}')
+ # Invalid code is always an error
+ except InvalidCode:
+ raise
+ except Exception as e:
+ if not required:
+ with mlog.nested(subp_name):
+ # Suppress the 'ERROR:' prefix because this exception is not
+ # fatal and VS CI treat any logs with "ERROR:" as fatal.
+ mlog.exception(e, prefix=mlog.yellow('Exception:'))
+ mlog.log('\nSubproject', mlog.bold(subdir), 'is buildable:', mlog.red('NO'), '(disabling)')
+ return self.disabled_subproject(subp_name, exception=e)
+ raise e
+
+ def _do_subproject_meson(self, subp_name: str, subdir: str, default_options, kwargs,
+ ast: T.Optional[mparser.CodeBlockNode] = None,
+ build_def_files: T.Optional[T.List[str]] = None,
+ is_translated: bool = False) -> SubprojectHolder:
+ with mlog.nested(subp_name):
+ new_build = self.build.copy()
+ subi = Interpreter(new_build, self.backend, subp_name, subdir, self.subproject_dir,
+ default_options, ast=ast, is_translated=is_translated)
+ # Those lists are shared by all interpreters. That means that
+ # even if the subproject fails, any modification that the subproject
+ # made to those lists will affect the parent project.
+ subi.subprojects = self.subprojects
+ subi.modules = self.modules
+ subi.holder_map = self.holder_map
+ subi.bound_holder_map = self.bound_holder_map
+ subi.summary = self.summary
+
+ subi.subproject_stack = self.subproject_stack + [subp_name]
+ current_active = self.active_projectname
+ current_warnings_counter = mlog.log_warnings_counter
+ mlog.log_warnings_counter = 0
+ subi.run()
+ subi_warnings = mlog.log_warnings_counter
+ mlog.log_warnings_counter = current_warnings_counter
+
+ mlog.log('Subproject', mlog.bold(subp_name), 'finished.')
+
+ mlog.log()
+
+ if 'version' in kwargs:
+ pv = subi.project_version
+ wanted = kwargs['version']
+ if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]:
+ raise InterpreterException(f'Subproject {subp_name} version is {pv} but {wanted} required.')
+ self.active_projectname = current_active
+ self.subprojects.update(subi.subprojects)
+ self.subprojects[subp_name] = SubprojectHolder(subi, subdir, warnings=subi_warnings)
+ # Duplicates are possible when subproject uses files from project root
+ if build_def_files:
+ self.build_def_files = list(set(self.build_def_files + build_def_files))
+ # We always need the subi.build_def_files, to propgate sub-sub-projects
+ self.build_def_files = list(set(self.build_def_files + subi.build_def_files))
+ self.build.merge(subi.build)
+ self.build.subprojects[subp_name] = subi.project_version
+ self.coredata.initialized_subprojects.add(subp_name)
+ return self.subprojects[subp_name]
+
+ def _do_subproject_cmake(self, subp_name, subdir, subdir_abs, default_options, kwargs):
+ with mlog.nested(subp_name):
+ new_build = self.build.copy()
+ prefix = self.coredata.options[OptionKey('prefix')].value
+
+ from ..modules.cmake import CMakeSubprojectOptions
+ options = kwargs.get('options', CMakeSubprojectOptions())
+ if not isinstance(options, CMakeSubprojectOptions):
+ raise InterpreterException('"options" kwarg must be CMakeSubprojectOptions'
+ ' object (created by cmake.subproject_options())')
+
+ cmake_options = mesonlib.stringlistify(kwargs.get('cmake_options', []))
+ cmake_options += options.cmake_options
+ cm_int = CMakeInterpreter(new_build, Path(subdir), Path(subdir_abs), Path(prefix), new_build.environment, self.backend)
+ cm_int.initialise(cmake_options)
+ cm_int.analyse()
+
+ # Generate a meson ast and execute it with the normal do_subproject_meson
+ ast = cm_int.pretend_to_be_meson(options.target_options)
+
+ mlog.log()
+ with mlog.nested('cmake-ast'):
+ mlog.log('Processing generated meson AST')
+
+ # Debug print the generated meson file
+ from ..ast import AstIndentationGenerator, AstPrinter
+ printer = AstPrinter()
+ ast.accept(AstIndentationGenerator())
+ ast.accept(printer)
+ printer.post_process()
+ meson_filename = os.path.join(self.build.environment.get_build_dir(), subdir, 'meson.build')
+ with open(meson_filename, "w", encoding='utf-8') as f:
+ f.write(printer.result)
+
+ mlog.log('Build file:', meson_filename)
+ mlog.cmd_ci_include(meson_filename)
+ mlog.log()
+
+ result = self._do_subproject_meson(subp_name, subdir, default_options, kwargs, ast, cm_int.bs_files, is_translated=True)
+ result.cm_interpreter = cm_int
+
+ mlog.log()
+ return result
+
+ def get_option_internal(self, optname: str):
+ key = OptionKey.from_string(optname).evolve(subproject=self.subproject)
+
+ if not key.is_project():
+ for opts in [self.coredata.options, compilers.base_options]:
+ v = opts.get(key)
+ if v is None or v.yielding:
+ v = opts.get(key.as_root())
+ if v is not None:
+ return v
+
+ try:
+ opt = self.coredata.options[key]
+ if opt.yielding and key.subproject and key.as_root() in self.coredata.options:
+ popt = self.coredata.options[key.as_root()]
+ if type(opt) is type(popt):
+ opt = popt
+ else:
+ # Get class name, then option type as a string
+ opt_type = opt.__class__.__name__[4:][:-6].lower()
+ popt_type = popt.__class__.__name__[4:][:-6].lower()
+ # This is not a hard error to avoid dependency hell, the workaround
+ # when this happens is to simply set the subproject's option directly.
+ mlog.warning('Option {0!r} of type {1!r} in subproject {2!r} cannot yield '
+ 'to parent option of type {3!r}, ignoring parent value. '
+ 'Use -D{2}:{0}=value to set the value for this option manually'
+ '.'.format(optname, opt_type, self.subproject, popt_type),
+ location=self.current_node)
+ return opt
+ except KeyError:
+ pass
+
+ raise InterpreterException(f'Tried to access unknown option {optname!r}.')
+
+ @typed_pos_args('get_option', str)
+ @noKwargs
+ def func_get_option(self, nodes: mparser.BaseNode, args: T.Tuple[str],
+ kwargs: 'TYPE_kwargs') -> T.Union[coredata.UserOption, 'TYPE_var']:
+ optname = args[0]
+ if ':' in optname:
+ raise InterpreterException('Having a colon in option name is forbidden, '
+ 'projects are not allowed to directly access '
+ 'options of other subprojects.')
+ opt = self.get_option_internal(optname)
+ if isinstance(opt, coredata.UserFeatureOption):
+ opt.name = optname
+ return opt
+ elif isinstance(opt, coredata.UserOption):
+ return opt.value
+ return opt
+
+ @typed_pos_args('configuration_data', optargs=[dict])
+ @noKwargs
+ def func_configuration_data(self, node: mparser.BaseNode, args: T.Optional[dict], kwargs: 'TYPE_kwargs') -> ConfigurationDataObject:
+ initial_values = args[0]
+ if initial_values is not None:
+ FeatureNew.single_use('configuration_data dictionary', '0.49.0', self.subproject, location=node)
+ else:
+ initial_values = {}
+ return ConfigurationDataObject(self.subproject, initial_values)
+
+ def set_backend(self):
+ # The backend is already set when parsing subprojects
+ if self.backend is not None:
+ return
+ backend = self.coredata.get_option(OptionKey('backend'))
+ from ..backend import backends
+ self.backend = backends.get_backend_from_name(backend, self.build, self)
+
+ if self.backend is None:
+ raise InterpreterException(f'Unknown backend "{backend}".')
+ if backend != self.backend.name:
+ if self.backend.name.startswith('vs'):
+ mlog.log('Auto detected Visual Studio backend:', mlog.bold(self.backend.name))
+ self.coredata.set_option(OptionKey('backend'), self.backend.name)
+
+ # Only init backend options on first invocation otherwise it would
+ # override values previously set from command line.
+ if self.environment.first_invocation:
+ self.coredata.init_backend_options(backend)
+
+ options = {k: v for k, v in self.environment.options.items() if k.is_backend()}
+ self.coredata.set_options(options)
+
+ @typed_pos_args('project', str, varargs=str)
+ @typed_kwargs(
+ 'project',
+ DEFAULT_OPTIONS,
+ KwargInfo('meson_version', (str, NoneType)),
+ KwargInfo(
+ 'version',
+ (str, mesonlib.File, NoneType, list),
+ default='undefined',
+ validator=_project_version_validator,
+ convertor=lambda x: x[0] if isinstance(x, list) else x,
+ ),
+ KwargInfo('license', ContainerTypeInfo(list, str), default=['unknown'], listify=True),
+ KwargInfo('subproject_dir', str, default='subprojects'),
+ )
+ def func_project(self, node: mparser.FunctionNode, args: T.Tuple[str, T.List[str]], kwargs: 'kwargs.Project') -> None:
+ proj_name, proj_langs = args
+ if ':' in proj_name:
+ raise InvalidArguments(f"Project name {proj_name!r} must not contain ':'")
+
+ # This needs to be evaluated as early as possible, as meson uses this
+ # for things like deprecation testing.
+ if kwargs['meson_version']:
+ cv = coredata.version
+ pv = kwargs['meson_version']
+ if not mesonlib.version_compare(cv, pv):
+ raise InterpreterException(f'Meson version is {cv} but project requires {pv}')
+ mesonlib.project_meson_versions[self.subproject] = kwargs['meson_version']
+
+ if os.path.exists(self.option_file):
+ oi = optinterpreter.OptionInterpreter(self.subproject)
+ oi.process(self.option_file)
+ self.coredata.update_project_options(oi.options)
+ self.add_build_def_file(self.option_file)
+
+ # Do not set default_options on reconfigure otherwise it would override
+ # values previously set from command line. That means that changing
+ # default_options in a project will trigger a reconfigure but won't
+ # have any effect.
+ self.project_default_options = coredata.create_options_dict(
+ kwargs['default_options'], self.subproject)
+
+ # If this is the first invocation we always need to initialize
+ # builtins, if this is a subproject that is new in a re-invocation we
+ # need to initialize builtins for that
+ if self.environment.first_invocation or (self.subproject != '' and self.subproject not in self.coredata.initialized_subprojects):
+ default_options = self.project_default_options.copy()
+ default_options.update(self.default_project_options)
+ self.coredata.init_builtins(self.subproject)
+ else:
+ default_options = {}
+ self.coredata.set_default_options(default_options, self.subproject, self.environment)
+
+ if not self.is_subproject():
+ self.build.project_name = proj_name
+ self.active_projectname = proj_name
+
+ version = kwargs['version']
+ if isinstance(version, mesonlib.File):
+ FeatureNew.single_use('version from file', '0.57.0', self.subproject, location=node)
+ self.add_build_def_file(version)
+ ifname = version.absolute_path(self.environment.source_dir,
+ self.environment.build_dir)
+ try:
+ ver_data = Path(ifname).read_text(encoding='utf-8').split('\n')
+ except FileNotFoundError:
+ raise InterpreterException('Version file not found.')
+ if len(ver_data) == 2 and ver_data[1] == '':
+ ver_data = ver_data[0:1]
+ if len(ver_data) != 1:
+ raise InterpreterException('Version file must contain exactly one line of text.')
+ self.project_version = ver_data[0]
+ else:
+ self.project_version = version
+
+ if self.build.project_version is None:
+ self.build.project_version = self.project_version
+ proj_license = kwargs['license']
+ self.build.dep_manifest[proj_name] = build.DepManifest(self.project_version, proj_license)
+ if self.subproject in self.build.projects:
+ raise InvalidCode('Second call to project().')
+
+ # spdirname is the subproject_dir for this project, relative to self.subdir.
+ # self.subproject_dir is the subproject_dir for the main project, relative to top source dir.
+ spdirname = kwargs['subproject_dir']
+ if not isinstance(spdirname, str):
+ raise InterpreterException('Subproject_dir must be a string')
+ if os.path.isabs(spdirname):
+ raise InterpreterException('Subproject_dir must not be an absolute path.')
+ if spdirname.startswith('.'):
+ raise InterpreterException('Subproject_dir must not begin with a period.')
+ if '..' in spdirname:
+ raise InterpreterException('Subproject_dir must not contain a ".." segment.')
+ if not self.is_subproject():
+ self.subproject_dir = spdirname
+ self.build.subproject_dir = self.subproject_dir
+
+ # Load wrap files from this (sub)project.
+ wrap_mode = self.coredata.get_option(OptionKey('wrap_mode'))
+ if not self.is_subproject() or wrap_mode != WrapMode.nopromote:
+ subdir = os.path.join(self.subdir, spdirname)
+ r = wrap.Resolver(self.environment.get_source_dir(), subdir, self.subproject, wrap_mode)
+ if self.is_subproject():
+ self.environment.wrap_resolver.merge_wraps(r)
+ else:
+ self.environment.wrap_resolver = r
+
+ self.build.projects[self.subproject] = proj_name
+ mlog.log('Project name:', mlog.bold(proj_name))
+ mlog.log('Project version:', mlog.bold(self.project_version))
+
+ if not self.is_subproject():
+ # We have to activate VS before adding languages and before calling
+ # self.set_backend() otherwise it wouldn't be able to detect which
+ # vs backend version we need. But after setting default_options in case
+ # the project sets vs backend by default.
+ backend = self.coredata.get_option(OptionKey('backend'))
+ force_vsenv = self.user_defined_options.vsenv or backend.startswith('vs')
+ if mesonlib.setup_vsenv(force_vsenv):
+ self.build.need_vsenv = True
+
+ self.add_languages(proj_langs, True, MachineChoice.HOST)
+ self.add_languages(proj_langs, False, MachineChoice.BUILD)
+
+ self.set_backend()
+ if not self.is_subproject():
+ self.check_stdlibs()
+
+ @typed_kwargs('add_languages', KwargInfo('native', (bool, NoneType), since='0.54.0'), REQUIRED_KW)
+ @typed_pos_args('add_languages', varargs=str)
+ def func_add_languages(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwargs.FuncAddLanguages') -> bool:
+ langs = args[0]
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
+ native = kwargs['native']
+
+ if disabled:
+ for lang in sorted(langs, key=compilers.sort_clink):
+ mlog.log('Compiler for language', mlog.bold(lang), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return False
+ if native is not None:
+ return self.add_languages(langs, required, self.machine_from_native_kwarg(kwargs))
+ else:
+ # absent 'native' means 'both' for backwards compatibility
+ tv = FeatureNew.get_target_version(self.subproject)
+ if FeatureNew.check_version(tv, '0.54.0'):
+ mlog.warning('add_languages is missing native:, assuming languages are wanted for both host and build.',
+ location=node)
+
+ success = self.add_languages(langs, False, MachineChoice.BUILD)
+ success &= self.add_languages(langs, required, MachineChoice.HOST)
+ return success
+
+ @noArgsFlattening
+ @noKwargs
+ def func_message(self, node, args, kwargs):
+ if len(args) > 1:
+ FeatureNew.single_use('message with more than one argument', '0.54.0', self.subproject, location=node)
+ args_str = [stringifyUserArguments(i) for i in args]
+ self.message_impl(args_str)
+
+ def message_impl(self, args):
+ mlog.log(mlog.bold('Message:'), *args)
+
+ @noArgsFlattening
+ @FeatureNew('summary', '0.53.0')
+ @typed_pos_args('summary', (str, dict), optargs=[object])
+ @typed_kwargs(
+ 'summary',
+ KwargInfo('section', str, default=''),
+ KwargInfo('bool_yn', bool, default=False),
+ KwargInfo('list_sep', (str, NoneType), since='0.54.0')
+ )
+ def func_summary(self, node: mparser.BaseNode, args: T.Tuple[T.Union[str, T.Dict[str, T.Any]], T.Optional[T.Any]],
+ kwargs: 'kwargs.Summary') -> None:
+ if args[1] is None:
+ if not isinstance(args[0], dict):
+ raise InterpreterException('Summary first argument must be dictionary.')
+ values = args[0]
+ else:
+ if not isinstance(args[0], str):
+ raise InterpreterException('Summary first argument must be string.')
+ values = {args[0]: args[1]}
+ self.summary_impl(kwargs['section'], values, kwargs)
+
+ def summary_impl(self, section: str, values, kwargs: 'kwargs.Summary') -> None:
+ if self.subproject not in self.summary:
+ self.summary[self.subproject] = Summary(self.active_projectname, self.project_version)
+ self.summary[self.subproject].add_section(
+ section, values, kwargs['bool_yn'], kwargs['list_sep'], self.subproject)
+
+ def _print_summary(self) -> None:
+ # Add automatic 'Supbrojects' section in main project.
+ all_subprojects = collections.OrderedDict()
+ for name, subp in sorted(self.subprojects.items()):
+ value = subp.found()
+ if subp.disabled_feature:
+ value = [value, f'Feature {subp.disabled_feature!r} disabled']
+ elif subp.exception:
+ value = [value, str(subp.exception)]
+ elif subp.warnings > 0:
+ value = [value, f'{subp.warnings} warnings']
+ all_subprojects[name] = value
+ if all_subprojects:
+ self.summary_impl('Subprojects', all_subprojects,
+ {'bool_yn': True,
+ 'list_sep': ' ',
+ })
+ # Add automatic section with all user defined options
+ if self.user_defined_options:
+ values = collections.OrderedDict()
+ if self.user_defined_options.cross_file:
+ values['Cross files'] = self.user_defined_options.cross_file
+ if self.user_defined_options.native_file:
+ values['Native files'] = self.user_defined_options.native_file
+ sorted_options = sorted(self.user_defined_options.cmd_line_options.items())
+ values.update({str(k): v for k, v in sorted_options})
+ if values:
+ self.summary_impl('User defined options', values, {'bool_yn': False, 'list_sep': None})
+ # Print all summaries, main project last.
+ mlog.log('') # newline
+ main_summary = self.summary.pop('', None)
+ for subp_name, summary in sorted(self.summary.items()):
+ if self.subprojects[subp_name].found():
+ summary.dump()
+ if main_summary:
+ main_summary.dump()
+
+ @noArgsFlattening
+ @FeatureNew('warning', '0.44.0')
+ @noKwargs
+ def func_warning(self, node, args, kwargs):
+ if len(args) > 1:
+ FeatureNew.single_use('warning with more than one argument', '0.54.0', self.subproject, location=node)
+ args_str = [stringifyUserArguments(i) for i in args]
+ mlog.warning(*args_str, location=node)
+
+ @noArgsFlattening
+ @noKwargs
+ def func_error(self, node, args, kwargs):
+ if len(args) > 1:
+ FeatureNew.single_use('error with more than one argument', '0.58.0', self.subproject, location=node)
+ args_str = [stringifyUserArguments(i) for i in args]
+ raise InterpreterException('Problem encountered: ' + ' '.join(args_str))
+
+ @noKwargs
+ @noPosargs
+ def func_exception(self, node, args, kwargs):
+ raise Exception()
+
+ def add_languages(self, args: T.Sequence[str], required: bool, for_machine: MachineChoice) -> bool:
+ success = self.add_languages_for(args, required, for_machine)
+ if not self.coredata.is_cross_build():
+ self.coredata.copy_build_options_from_regular_ones()
+ self._redetect_machines()
+ return success
+
+ def should_skip_sanity_check(self, for_machine: MachineChoice) -> bool:
+ should = self.environment.properties.host.get('skip_sanity_check', False)
+ if not isinstance(should, bool):
+ raise InterpreterException('Option skip_sanity_check must be a boolean.')
+ if for_machine != MachineChoice.HOST and not should:
+ return False
+ if not self.environment.is_cross_build() and not should:
+ return False
+ return should
+
+ def add_languages_for(self, args: T.List[str], required: bool, for_machine: MachineChoice) -> None:
+ args = [a.lower() for a in args]
+ langs = set(self.coredata.compilers[for_machine].keys())
+ langs.update(args)
+ # We'd really like to add cython's default language here, but it can't
+ # actually be done because the cython compiler hasn't been initialized,
+ # so we can't actually get the option yet. Because we can't know what
+ # compiler to add by default, and we don't want to add unnecessary
+ # compilers we don't add anything for cython here, and instead do it
+ # When the first cython target using a particular language is used.
+ if 'vala' in langs and 'c' not in langs:
+ FeatureNew.single_use('Adding Vala language without C', '0.59.0', self.subproject, location=self.current_node)
+ args.append('c')
+
+ success = True
+ for lang in sorted(args, key=compilers.sort_clink):
+ clist = self.coredata.compilers[for_machine]
+ machine_name = for_machine.get_lower_case_name()
+ if lang in clist:
+ comp = clist[lang]
+ else:
+ try:
+ comp = compilers.detect_compiler_for(self.environment, lang, for_machine)
+ if comp is None:
+ raise InvalidArguments(f'Tried to use unknown language "{lang}".')
+ if self.should_skip_sanity_check(for_machine):
+ mlog.log_once('Cross compiler sanity tests disabled via the cross file.')
+ else:
+ comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
+ except Exception:
+ if not required:
+ mlog.log('Compiler for language',
+ mlog.bold(lang), 'for the', machine_name,
+ 'machine not found.')
+ success = False
+ continue
+ else:
+ raise
+
+ if for_machine == MachineChoice.HOST or self.environment.is_cross_build():
+ logger_fun = mlog.log
+ else:
+ logger_fun = mlog.debug
+ logger_fun(comp.get_display_language(), 'compiler for the', machine_name, 'machine:',
+ mlog.bold(' '.join(comp.get_exelist())), comp.get_version_string())
+ if comp.linker is not None:
+ logger_fun(comp.get_display_language(), 'linker for the', machine_name, 'machine:',
+ mlog.bold(' '.join(comp.linker.get_exelist())), comp.linker.id, comp.linker.version)
+ self.build.ensure_static_linker(comp)
+
+ return success
+
+ def program_from_file_for(self, for_machine, prognames):
+ for p in prognames:
+ if isinstance(p, mesonlib.File):
+ continue # Always points to a local (i.e. self generated) file.
+ if not isinstance(p, str):
+ raise InterpreterException('Executable name must be a string')
+ prog = ExternalProgram.from_bin_list(self.environment, for_machine, p)
+ if prog.found():
+ return prog
+ return None
+
+ def program_from_system(self, args, search_dirs, extra_info):
+ # Search for scripts relative to current subdir.
+ # Do not cache found programs because find_program('foobar')
+ # might give different results when run from different source dirs.
+ source_dir = os.path.join(self.environment.get_source_dir(), self.subdir)
+ for exename in args:
+ if isinstance(exename, mesonlib.File):
+ if exename.is_built:
+ search_dir = os.path.join(self.environment.get_build_dir(),
+ exename.subdir)
+ else:
+ search_dir = os.path.join(self.environment.get_source_dir(),
+ exename.subdir)
+ exename = exename.fname
+ extra_search_dirs = []
+ elif isinstance(exename, str):
+ search_dir = source_dir
+ extra_search_dirs = search_dirs
+ else:
+ raise InvalidArguments(f'find_program only accepts strings and files, not {exename!r}')
+ extprog = ExternalProgram(exename, search_dir=search_dir,
+ extra_search_dirs=extra_search_dirs,
+ silent=True)
+ if extprog.found():
+ extra_info.append(f"({' '.join(extprog.get_command())})")
+ return extprog
+
+ def program_from_overrides(self, command_names: T.List[str], extra_info: T.List['mlog.TV_Loggable']) -> \
+ T.Optional[T.Union[ExternalProgram, 'OverrideProgram', 'build.Executable']]:
+ for name in command_names:
+ if not isinstance(name, str):
+ continue
+ if name in self.build.find_overrides:
+ exe = self.build.find_overrides[name]
+ extra_info.append(mlog.blue('(overridden)'))
+ return exe
+ return None
+
+ def store_name_lookups(self, command_names):
+ for name in command_names:
+ if isinstance(name, str):
+ self.build.searched_programs.add(name)
+
+ def add_find_program_override(self, name: str, exe: T.Union[build.Executable, ExternalProgram, 'OverrideProgram']) -> None:
+ if name in self.build.searched_programs:
+ raise InterpreterException(f'Tried to override finding of executable "{name}" which has already been found.')
+ if name in self.build.find_overrides:
+ raise InterpreterException(f'Tried to override executable "{name}" which has already been overridden.')
+ self.build.find_overrides[name] = exe
+
+ def notfound_program(self, args):
+ return NonExistingExternalProgram(' '.join(args))
+
+ # TODO update modules to always pass `for_machine`. It is bad-form to assume
+ # the host machine.
+ def find_program_impl(self, args: T.List[mesonlib.FileOrString],
+ for_machine: MachineChoice = MachineChoice.HOST,
+ required: bool = True, silent: bool = True,
+ wanted: T.Union[str, T.List[str]] = '',
+ search_dirs: T.Optional[T.List[str]] = None,
+ version_func: T.Optional[T.Callable[[T.Union['ExternalProgram', 'build.Executable', 'OverrideProgram']], str]] = None
+ ) -> T.Union['ExternalProgram', 'build.Executable', 'OverrideProgram']:
+ args = mesonlib.listify(args)
+
+ extra_info = []
+ progobj = self.program_lookup(args, for_machine, required, search_dirs, extra_info)
+ if progobj is None:
+ progobj = self.notfound_program(args)
+
+ if isinstance(progobj, ExternalProgram) and not progobj.found():
+ if not silent:
+ mlog.log('Program', mlog.bold(progobj.get_name()), 'found:', mlog.red('NO'))
+ if required:
+ m = 'Program {!r} not found or not executable'
+ raise InterpreterException(m.format(progobj.get_name()))
+ return progobj
+
+ if wanted:
+ if version_func:
+ version = version_func(progobj)
+ elif isinstance(progobj, build.Executable):
+ interp = self
+ if progobj.subproject:
+ interp = self.subprojects[progobj.subproject].held_object
+ assert isinstance(interp, Interpreter)
+ version = interp.project_version
+ else:
+ version = progobj.get_version(self)
+ is_found, not_found, found = mesonlib.version_compare_many(version, wanted)
+ if not is_found:
+ mlog.log('Program', mlog.bold(progobj.name), 'found:', mlog.red('NO'),
+ 'found', mlog.normal_cyan(version), 'but need:',
+ mlog.bold(', '.join([f"'{e}'" for e in not_found])), *extra_info)
+ if required:
+ m = 'Invalid version of program, need {!r} {!r} found {!r}.'
+ raise InterpreterException(m.format(progobj.name, not_found, version))
+ return self.notfound_program(args)
+ extra_info.insert(0, mlog.normal_cyan(version))
+
+ # Only store successful lookups
+ self.store_name_lookups(args)
+ if not silent:
+ mlog.log('Program', mlog.bold(progobj.name), 'found:', mlog.green('YES'), *extra_info)
+ if isinstance(progobj, build.Executable):
+ progobj.was_returned_by_find_program = True
+ return progobj
+
+ def program_lookup(self, args, for_machine, required, search_dirs, extra_info):
+ progobj = self.program_from_overrides(args, extra_info)
+ if progobj:
+ return progobj
+
+ fallback = None
+ wrap_mode = self.coredata.get_option(OptionKey('wrap_mode'))
+ if wrap_mode != WrapMode.nofallback and self.environment.wrap_resolver:
+ fallback = self.environment.wrap_resolver.find_program_provider(args)
+ if fallback and wrap_mode == WrapMode.forcefallback:
+ return self.find_program_fallback(fallback, args, required, extra_info)
+
+ progobj = self.program_from_file_for(for_machine, args)
+ if progobj is None:
+ progobj = self.program_from_system(args, search_dirs, extra_info)
+ if progobj is None and args[0].endswith('python3'):
+ prog = ExternalProgram('python3', mesonlib.python_command, silent=True)
+ progobj = prog if prog.found() else None
+ if progobj is None and fallback and required:
+ progobj = self.find_program_fallback(fallback, args, required, extra_info)
+
+ return progobj
+
+ def find_program_fallback(self, fallback, args, required, extra_info):
+ mlog.log('Fallback to subproject', mlog.bold(fallback), 'which provides program',
+ mlog.bold(' '.join(args)))
+ sp_kwargs = {'required': required}
+ self.do_subproject(fallback, 'meson', sp_kwargs)
+ return self.program_from_overrides(args, extra_info)
+
+ @typed_pos_args('find_program', varargs=(str, mesonlib.File), min_varargs=1)
+ @typed_kwargs(
+ 'find_program',
+ DISABLER_KW.evolve(since='0.49.0'),
+ NATIVE_KW,
+ REQUIRED_KW,
+ KwargInfo('dirs', ContainerTypeInfo(list, str), default=[], listify=True, since='0.53.0'),
+ KwargInfo('version', ContainerTypeInfo(list, str), default=[], listify=True, since='0.52.0'),
+ )
+ @disablerIfNotFound
+ def func_find_program(self, node: mparser.BaseNode, args: T.Tuple[T.List[mesonlib.FileOrString]],
+ kwargs: 'kwargs.FindProgram',
+ ) -> T.Union['build.Executable', ExternalProgram, 'OverrideProgram']:
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
+ if disabled:
+ mlog.log('Program', mlog.bold(' '.join(args[0])), 'skipped: feature', mlog.bold(feature), 'disabled')
+ return self.notfound_program(args[0])
+
+ search_dirs = extract_search_dirs(kwargs)
+ return self.find_program_impl(args[0], kwargs['native'], required=required,
+ silent=False, wanted=kwargs['version'],
+ search_dirs=search_dirs)
+
+ def func_find_library(self, node, args, kwargs):
+ raise InvalidCode('find_library() is removed, use meson.get_compiler(\'name\').find_library() instead.\n'
+ 'Look here for documentation: http://mesonbuild.com/Reference-manual.html#compiler-object\n'
+ 'Look here for example: http://mesonbuild.com/howtox.html#add-math-library-lm-portably\n'
+ )
+
+ # When adding kwargs, please check if they make sense in dependencies.get_dep_identifier()
+ @FeatureNewKwargs('dependency', '0.57.0', ['cmake_package_version'])
+ @FeatureNewKwargs('dependency', '0.56.0', ['allow_fallback'])
+ @FeatureNewKwargs('dependency', '0.54.0', ['components'])
+ @FeatureNewKwargs('dependency', '0.52.0', ['include_type'])
+ @FeatureNewKwargs('dependency', '0.50.0', ['not_found_message', 'cmake_module_path', 'cmake_args'])
+ @FeatureNewKwargs('dependency', '0.49.0', ['disabler'])
+ @FeatureNewKwargs('dependency', '0.40.0', ['method'])
+ @FeatureNewKwargs('dependency', '0.38.0', ['default_options'])
+ @disablerIfNotFound
+ @permittedKwargs(permitted_dependency_kwargs)
+ @typed_pos_args('dependency', varargs=str, min_varargs=1)
+ def func_dependency(self, node, args, kwargs):
+ # Replace '' by empty list of names
+ names = [n for n in args[0] if n]
+ if len(names) > 1:
+ FeatureNew('dependency with more than one name', '0.60.0').use(self.subproject)
+ allow_fallback = kwargs.get('allow_fallback')
+ if allow_fallback is not None and not isinstance(allow_fallback, bool):
+ raise InvalidArguments('"allow_fallback" argument must be boolean')
+ fallback = kwargs.get('fallback')
+ default_options = kwargs.get('default_options')
+ df = DependencyFallbacksHolder(self, names, allow_fallback, default_options)
+ df.set_fallback(fallback)
+ not_found_message = kwargs.get('not_found_message', '')
+ if not isinstance(not_found_message, str):
+ raise InvalidArguments('The not_found_message must be a string.')
+ try:
+ d = df.lookup(kwargs)
+ except Exception:
+ if not_found_message:
+ self.message_impl([not_found_message])
+ raise
+ assert isinstance(d, Dependency)
+ if not d.found() and not_found_message:
+ self.message_impl([not_found_message])
+ self.message_impl([not_found_message])
+ # Ensure the correct include type
+ if 'include_type' in kwargs:
+ wanted = kwargs['include_type']
+ if not isinstance(wanted, str):
+ raise InvalidArguments('The `include_type` kwarg must be a string')
+ actual = d.get_include_type()
+ if wanted != actual:
+ mlog.debug(f'Current include type of {args[0]} is {actual}. Converting to requested {wanted}')
+ d = d.generate_system_dependency(wanted)
+ return d
+
+ @FeatureNew('disabler', '0.44.0')
+ @noKwargs
+ @noPosargs
+ def func_disabler(self, node, args, kwargs):
+ return Disabler()
+
+ @FeatureNewKwargs('executable', '0.42.0', ['implib'])
+ @FeatureNewKwargs('executable', '0.56.0', ['win_subsystem'])
+ @FeatureDeprecatedKwargs('executable', '0.56.0', ['gui_app'], extra_message="Use 'win_subsystem' instead.")
+ @permittedKwargs(build.known_exe_kwargs)
+ def func_executable(self, node, args, kwargs):
+ return self.build_target(node, args, kwargs, build.Executable)
+
+ @permittedKwargs(build.known_stlib_kwargs)
+ def func_static_lib(self, node, args, kwargs):
+ return self.build_target(node, args, kwargs, build.StaticLibrary)
+
+ @permittedKwargs(build.known_shlib_kwargs)
+ def func_shared_lib(self, node, args, kwargs):
+ holder = self.build_target(node, args, kwargs, build.SharedLibrary)
+ holder.shared_library_only = True
+ return holder
+
+ @permittedKwargs(known_library_kwargs)
+ def func_both_lib(self, node, args, kwargs):
+ return self.build_both_libraries(node, args, kwargs)
+
+ @FeatureNew('shared_module', '0.37.0')
+ @permittedKwargs(build.known_shmod_kwargs)
+ def func_shared_module(self, node, args, kwargs):
+ return self.build_target(node, args, kwargs, build.SharedModule)
+
+ @permittedKwargs(known_library_kwargs)
+ def func_library(self, node, args, kwargs):
+ return self.build_library(node, args, kwargs)
+
+ @permittedKwargs(build.known_jar_kwargs)
+ def func_jar(self, node, args, kwargs):
+ return self.build_target(node, args, kwargs, build.Jar)
+
+ @FeatureNewKwargs('build_target', '0.40.0', ['link_whole', 'override_options'])
+ @permittedKwargs(known_build_target_kwargs)
+ def func_build_target(self, node, args, kwargs):
+ if 'target_type' not in kwargs:
+ raise InterpreterException('Missing target_type keyword argument')
+ target_type = kwargs.pop('target_type')
+ if target_type == 'executable':
+ return self.build_target(node, args, kwargs, build.Executable)
+ elif target_type == 'shared_library':
+ return self.build_target(node, args, kwargs, build.SharedLibrary)
+ elif target_type == 'shared_module':
+ FeatureNew('build_target(target_type: \'shared_module\')',
+ '0.51.0').use(self.subproject)
+ return self.build_target(node, args, kwargs, build.SharedModule)
+ elif target_type == 'static_library':
+ return self.build_target(node, args, kwargs, build.StaticLibrary)
+ elif target_type == 'both_libraries':
+ return self.build_both_libraries(node, args, kwargs)
+ elif target_type == 'library':
+ return self.build_library(node, args, kwargs)
+ elif target_type == 'jar':
+ return self.build_target(node, args, kwargs, build.Jar)
+ else:
+ raise InterpreterException('Unknown target_type.')
+
+ @permittedKwargs({'input', 'output', 'fallback', 'command', 'replace_string'})
+ @noPosargs
+ def func_vcs_tag(self, node, args, kwargs):
+ if 'input' not in kwargs or 'output' not in kwargs:
+ raise InterpreterException('Keyword arguments input and output must exist')
+ if 'fallback' not in kwargs:
+ FeatureNew.single_use('Optional fallback in vcs_tag', '0.41.0', self.subproject, location=node)
+ fallback = kwargs.pop('fallback', self.project_version)
+ if not isinstance(fallback, str):
+ raise InterpreterException('Keyword argument fallback must be a string.')
+ replace_string = kwargs.pop('replace_string', '@VCS_TAG@')
+ regex_selector = '(.*)' # default regex selector for custom command: use complete output
+ vcs_cmd = kwargs.get('command', None)
+ if vcs_cmd and not isinstance(vcs_cmd, list):
+ vcs_cmd = [vcs_cmd]
+ source_dir = os.path.normpath(os.path.join(self.environment.get_source_dir(), self.subdir))
+ if vcs_cmd:
+ # Is the command an executable in path or maybe a script in the source tree?
+ vcs_cmd[0] = shutil.which(vcs_cmd[0]) or os.path.join(source_dir, vcs_cmd[0])
+ else:
+ vcs = mesonlib.detect_vcs(source_dir)
+ if vcs:
+ mlog.log('Found {} repository at {}'.format(vcs['name'], vcs['wc_dir']))
+ vcs_cmd = vcs['get_rev'].split()
+ regex_selector = vcs['rev_regex']
+ else:
+ vcs_cmd = [' '] # executing this cmd will fail in vcstagger.py and force to use the fallback string
+ # vcstagger.py parameters: infile, outfile, fallback, source_dir, replace_string, regex_selector, command...
+ kwargs['command'] = self.environment.get_build_command() + \
+ ['--internal',
+ 'vcstagger',
+ '@INPUT0@',
+ '@OUTPUT0@',
+ fallback,
+ source_dir,
+ replace_string,
+ regex_selector] + vcs_cmd
+ kwargs.setdefault('build_by_default', True)
+ kwargs.setdefault('build_always_stale', True)
+ return self._func_custom_target_impl(node, [kwargs['output']], kwargs)
+
+ @FeatureNew('subdir_done', '0.46.0')
+ @noPosargs
+ @noKwargs
+ def func_subdir_done(self, node, args, kwargs):
+ raise SubdirDoneRequest()
+
+ @typed_pos_args('custom_target', optargs=[str])
+ @typed_kwargs(
+ 'custom_target',
+ COMMAND_KW,
+ CT_BUILD_ALWAYS,
+ CT_BUILD_ALWAYS_STALE,
+ CT_BUILD_BY_DEFAULT,
+ CT_INPUT_KW,
+ CT_INSTALL_DIR_KW,
+ CT_INSTALL_TAG_KW,
+ CT_OUTPUT_KW,
+ DEPENDS_KW,
+ DEPEND_FILES_KW,
+ DEPFILE_KW,
+ ENV_KW.evolve(since='0.57.0'),
+ INSTALL_KW,
+ INSTALL_MODE_KW.evolve(since='0.47.0'),
+ OVERRIDE_OPTIONS_KW,
+ KwargInfo('feed', bool, default=False, since='0.59.0'),
+ KwargInfo('capture', bool, default=False),
+ KwargInfo('console', bool, default=False, since='0.48.0'),
+ )
+ def func_custom_target(self, node: mparser.FunctionNode, args: T.Tuple[str],
+ kwargs: 'kwargs.CustomTarget') -> build.CustomTarget:
+ if kwargs['depfile'] and ('@BASENAME@' in kwargs['depfile'] or '@PLAINNAME@' in kwargs['depfile']):
+ FeatureNew.single_use('substitutions in custom_target depfile', '0.47.0', self.subproject, location=node)
+
+ # Don't mutate the kwargs
+ kwargs = kwargs.copy()
+
+ # Remap build_always to build_by_default and build_always_stale
+ if kwargs['build_always'] is not None and kwargs['build_always_stale'] is not None:
+ raise InterpreterException('CustomTarget: "build_always" and "build_always_stale" are mutually exclusive')
+
+ if kwargs['build_by_default'] is None and kwargs['install']:
+ kwargs['build_by_default'] = True
+
+ elif kwargs['build_always'] is not None:
+ if kwargs['build_by_default'] is None:
+ kwargs['build_by_default'] = kwargs['build_always']
+ kwargs['build_always_stale'] = kwargs['build_by_default']
+
+ # Set this to None to satisfy process_kwargs
+ kwargs['build_always'] = None
+
+ # These are are nullaable so that we can know whether they're explicitly
+ # set or not. If they haven't been overwritten, set them to their true
+ # default
+ if kwargs['build_by_default'] is None:
+ kwargs['build_by_default'] = False
+ if kwargs['build_always_stale'] is None:
+ kwargs['build_always_stale'] = False
+
+ return self._func_custom_target_impl(node, args, kwargs)
+
+ def _func_custom_target_impl(self, node, args, kwargs):
+ 'Implementation-only, without FeatureNew checks, for internal use'
+ name = args[0]
+ if name is None:
+ # name will default to first output, but we cannot do that yet because
+ # they could need substitutions (e.g. @BASENAME@) first. CustomTarget()
+ # will take care of setting a proper default but name must be an empty
+ # string in the meantime.
+ FeatureNew('custom_target() with no name argument', '0.60.0', location=node).use(self.subproject)
+ name = ''
+ kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
+ if 'input' in kwargs:
+ kwargs['input'] = self.source_strings_to_files(extract_as_list(kwargs, 'input'), strict=False)
+ kwargs['env'] = self.unpack_env_kwarg(kwargs)
+ if 'command' in kwargs and isinstance(kwargs['command'], list) and kwargs['command']:
+ if isinstance(kwargs['command'][0], str):
+ kwargs['command'][0] = self.find_program_impl([kwargs['command'][0]])
+ tg = build.CustomTarget(name, self.subdir, self.subproject, kwargs, backend=self.backend)
+ self.add_target(tg.name, tg)
+ return tg
+
+ @typed_pos_args('run_target', str)
+ @typed_kwargs(
+ 'run_target',
+ COMMAND_KW,
+ DEPENDS_KW,
+ ENV_KW.evolve(since='0.57.0'),
+ )
+ def func_run_target(self, node: mparser.FunctionNode, args: T.Tuple[str],
+ kwargs: 'kwargs.RunTarget') -> build.RunTarget:
+ all_args = kwargs['command'].copy()
+
+ for i in listify(all_args):
+ if isinstance(i, ExternalProgram) and not i.found():
+ raise InterpreterException(f'Tried to use non-existing executable {i.name!r}')
+ if isinstance(all_args[0], str):
+ all_args[0] = self.find_program_impl([all_args[0]])
+ name = args[0]
+ tg = build.RunTarget(name, all_args, kwargs['depends'], self.subdir, self.subproject, kwargs['env'])
+ self.add_target(name, tg)
+ full_name = (self.subproject, name)
+ assert full_name not in self.build.run_target_names
+ self.build.run_target_names.add(full_name)
+ return tg
+
+ @FeatureNew('alias_target', '0.52.0')
+ @typed_pos_args('alias_target', str, varargs=build.Target, min_varargs=1)
+ @noKwargs
+ def func_alias_target(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[build.Target]],
+ kwargs: 'TYPE_kwargs') -> build.AliasTarget:
+ name, deps = args
+ tg = build.AliasTarget(name, deps, self.subdir, self.subproject)
+ self.add_target(name, tg)
+ return tg
+
+ @typed_pos_args('generator', (build.Executable, ExternalProgram))
+ @typed_kwargs(
+ 'generator',
+ KwargInfo('arguments', ContainerTypeInfo(list, str, allow_empty=False), required=True, listify=True),
+ KwargInfo('output', ContainerTypeInfo(list, str, allow_empty=False), required=True, listify=True),
+ DEPFILE_KW,
+ DEPENDS_KW,
+ KwargInfo('capture', bool, default=False, since='0.43.0'),
+ )
+ def func_generator(self, node: mparser.FunctionNode,
+ args: T.Tuple[T.Union[build.Executable, ExternalProgram]],
+ kwargs: 'kwargs.FuncGenerator') -> build.Generator:
+ for rule in kwargs['output']:
+ if '@BASENAME@' not in rule and '@PLAINNAME@' not in rule:
+ raise InvalidArguments('Every element of "output" must contain @BASENAME@ or @PLAINNAME@.')
+ if has_path_sep(rule):
+ raise InvalidArguments('"output" must not contain a directory separator.')
+ if len(kwargs['output']) > 1:
+ for o in kwargs['output']:
+ if '@OUTPUT@' in o:
+ raise InvalidArguments('Tried to use @OUTPUT@ in a rule with more than one output.')
+
+ gen = build.Generator(args[0], **kwargs)
+ self.generators.append(gen)
+ return gen
+
+ @typed_pos_args('benchmark', str, (build.Executable, build.Jar, ExternalProgram, mesonlib.File))
+ @typed_kwargs('benchmark', *TEST_KWARGS)
+ def func_benchmark(self, node: mparser.BaseNode,
+ args: T.Tuple[str, T.Union[build.Executable, build.Jar, ExternalProgram, mesonlib.File]],
+ kwargs: 'kwargs.FuncBenchmark') -> None:
+ self.add_test(node, args, kwargs, False)
+
+ @typed_pos_args('test', str, (build.Executable, build.Jar, ExternalProgram, mesonlib.File))
+ @typed_kwargs('test', *TEST_KWARGS, KwargInfo('is_parallel', bool, default=True))
+ def func_test(self, node: mparser.BaseNode,
+ args: T.Tuple[str, T.Union[build.Executable, build.Jar, ExternalProgram, mesonlib.File]],
+ kwargs: 'kwargs.FuncTest') -> None:
+ self.add_test(node, args, kwargs, True)
+
+ def unpack_env_kwarg(self, kwargs: T.Union[build.EnvironmentVariables, T.Dict[str, 'TYPE_var'], T.List['TYPE_var'], str]) -> build.EnvironmentVariables:
+ envlist = kwargs.get('env')
+ if envlist is None:
+ return build.EnvironmentVariables()
+ msg = ENV_KW.validator(envlist)
+ if msg:
+ raise InvalidArguments(f'"env": {msg}')
+ return ENV_KW.convertor(envlist)
+
+ def make_test(self, node: mparser.BaseNode,
+ args: T.Tuple[str, T.Union[build.Executable, build.Jar, ExternalProgram, mesonlib.File]],
+ kwargs: 'kwargs.BaseTest') -> Test:
+ name = args[0]
+ if ':' in name:
+ mlog.deprecation(f'":" is not allowed in test name "{name}", it has been replaced with "_"',
+ location=node)
+ name = name.replace(':', '_')
+ exe = args[1]
+ if isinstance(exe, mesonlib.File):
+ exe = self.find_program_impl([exe])
+
+ env = self.unpack_env_kwarg(kwargs)
+
+ if kwargs['timeout'] <= 0:
+ FeatureNew.single_use('test() timeout <= 0', '0.57.0', self.subproject, location=node)
+
+ prj = self.subproject if self.is_subproject() else self.build.project_name
+
+ suite: T.List[str] = []
+ for s in kwargs['suite']:
+ if s:
+ s = ':' + s
+ suite.append(prj.replace(' ', '_').replace(':', '_') + s)
+
+ return Test(name,
+ prj,
+ suite,
+ exe,
+ kwargs['depends'],
+ kwargs.get('is_parallel', False),
+ kwargs['args'],
+ env,
+ kwargs['should_fail'],
+ kwargs['timeout'],
+ kwargs['workdir'],
+ kwargs['protocol'],
+ kwargs['priority'])
+
+ def add_test(self, node: mparser.BaseNode, args: T.List, kwargs: T.Dict[str, T.Any], is_base_test: bool):
+ t = self.make_test(node, args, kwargs)
+ if is_base_test:
+ self.build.tests.append(t)
+ mlog.debug('Adding test', mlog.bold(t.name, True))
+ else:
+ self.build.benchmarks.append(t)
+ mlog.debug('Adding benchmark', mlog.bold(t.name, True))
+
+ @typed_pos_args('install_headers', varargs=(str, mesonlib.File))
+ @typed_kwargs(
+ 'install_headers',
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('subdir', (str, NoneType)),
+ INSTALL_MODE_KW.evolve(since='0.47.0'),
+ )
+ def func_install_headers(self, node: mparser.BaseNode,
+ args: T.Tuple[T.List['mesonlib.FileOrString']],
+ kwargs: 'kwargs.FuncInstallHeaders') -> build.Headers:
+ source_files = self.source_strings_to_files(args[0])
+ install_subdir = kwargs['subdir']
+ if install_subdir is not None and os.path.isabs(install_subdir):
+ mlog.deprecation('Subdir keyword must not be an absolute path. This will be a hard error in the next release.')
+
+ h = build.Headers(source_files, install_subdir, kwargs['install_dir'],
+ kwargs['install_mode'], self.subproject)
+ self.build.headers.append(h)
+
+ return h
+
+ @typed_pos_args('install_man', varargs=(str, mesonlib.File))
+ @typed_kwargs(
+ 'install_man',
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('locale', (str, NoneType), since='0.58.0'),
+ INSTALL_MODE_KW.evolve(since='0.47.0')
+ )
+ def func_install_man(self, node: mparser.BaseNode,
+ args: T.Tuple[T.List['mesonlib.FileOrString']],
+ kwargs: 'kwargs.FuncInstallMan') -> build.Man:
+ # We just need to narrow this, because the input is limited to files and
+ # Strings as inputs, so only Files will be returned
+ sources = self.source_strings_to_files(args[0])
+ for s in sources:
+ try:
+ num = int(s.rsplit('.', 1)[-1])
+ except (IndexError, ValueError):
+ num = 0
+ if not 1 <= num <= 9:
+ raise InvalidArguments('Man file must have a file extension of a number between 1 and 9')
+
+ m = build.Man(sources, kwargs['install_dir'], kwargs['install_mode'],
+ self.subproject, kwargs['locale'])
+ self.build.man.append(m)
+
+ return m
+
+ @FeatureNew('install_emptydir', '0.60.0')
+ @typed_kwargs(
+ 'install_emptydir',
+ INSTALL_MODE_KW
+ )
+ def func_install_emptydir(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs) -> None:
+ d = build.EmptyDir(args[0], kwargs['install_mode'], self.subproject)
+ self.build.emptydir.append(d)
+
+ return d
+
+ @FeatureNew('install_symlink', '0.61.0')
+ @typed_pos_args('symlink_name', str)
+ @typed_kwargs(
+ 'install_symlink',
+ KwargInfo('pointing_to', str, required=True),
+ KwargInfo('install_dir', str, required=True),
+ KwargInfo('install_tag', (str, NoneType)),
+ )
+ def func_install_symlink(self, node: mparser.BaseNode,
+ args: T.Tuple[T.List[str]],
+ kwargs) -> build.SymlinkData:
+ name = args[0] # Validation while creating the SymlinkData object
+ target = kwargs['pointing_to']
+ l = build.SymlinkData(target, name, kwargs['install_dir'],
+ self.subproject, kwargs['install_tag'])
+ self.build.symlinks.append(l)
+ return l
+
+ @typed_pos_args('subdir', str)
+ @typed_kwargs(
+ 'subdir',
+ KwargInfo(
+ 'if_found',
+ ContainerTypeInfo(list, object),
+ validator=lambda a: 'Objects must have a found() method' if not all(hasattr(x, 'found') for x in a) else None,
+ since='0.44.0',
+ default=[],
+ listify=True,
+ ),
+ )
+ def func_subdir(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'kwargs.Subdir') -> None:
+ mesonlib.check_direntry_issues(args)
+ if '..' in args[0]:
+ raise InvalidArguments('Subdir contains ..')
+ if self.subdir == '' and args[0] == self.subproject_dir:
+ raise InvalidArguments('Must not go into subprojects dir with subdir(), use subproject() instead.')
+ if self.subdir == '' and args[0].startswith('meson-'):
+ raise InvalidArguments('The "meson-" prefix is reserved and cannot be used for top-level subdir().')
+ for i in kwargs['if_found']:
+ if not i.found():
+ return
+
+ prev_subdir = self.subdir
+ subdir = os.path.join(prev_subdir, args[0])
+ if os.path.isabs(subdir):
+ raise InvalidArguments('Subdir argument must be a relative path.')
+ absdir = os.path.join(self.environment.get_source_dir(), subdir)
+ symlinkless_dir = os.path.realpath(absdir)
+ build_file = os.path.join(symlinkless_dir, 'meson.build')
+ if build_file in self.processed_buildfiles:
+ raise InvalidArguments(f'Tried to enter directory "{subdir}", which has already been visited.')
+ self.processed_buildfiles.add(build_file)
+ self.subdir = subdir
+ os.makedirs(os.path.join(self.environment.build_dir, subdir), exist_ok=True)
+ buildfilename = os.path.join(self.subdir, environment.build_filename)
+ self.build_def_files.append(buildfilename)
+ absname = os.path.join(self.environment.get_source_dir(), buildfilename)
+ if not os.path.isfile(absname):
+ self.subdir = prev_subdir
+ raise InterpreterException(f"Non-existent build file '{buildfilename!s}'")
+ with open(absname, encoding='utf-8') as f:
+ code = f.read()
+ assert isinstance(code, str)
+ try:
+ codeblock = mparser.Parser(code, absname).parse()
+ except mesonlib.MesonException as me:
+ me.file = absname
+ raise me
+ try:
+ self.evaluate_codeblock(codeblock)
+ except SubdirDoneRequest:
+ pass
+ self.subdir = prev_subdir
+
+ def _get_kwarg_install_mode(self, kwargs: T.Dict[str, T.Any]) -> T.Optional[FileMode]:
+ if kwargs.get('install_mode', None) is None:
+ return None
+ if isinstance(kwargs['install_mode'], FileMode):
+ return kwargs['install_mode']
+ install_mode: T.List[str] = []
+ mode = mesonlib.typeslistify(kwargs.get('install_mode', []), (str, int))
+ for m in mode:
+ # We skip any arguments that are set to `false`
+ if m is False:
+ m = None
+ install_mode.append(m)
+ if len(install_mode) > 3:
+ raise InvalidArguments('Keyword argument install_mode takes at '
+ 'most 3 arguments.')
+ if len(install_mode) > 0 and install_mode[0] is not None and \
+ not isinstance(install_mode[0], str):
+ raise InvalidArguments('Keyword argument install_mode requires the '
+ 'permissions arg to be a string or false')
+ return FileMode(*install_mode)
+
+ @typed_pos_args('install_data', varargs=(str, mesonlib.File))
+ @typed_kwargs(
+ 'install_data',
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File)), listify=True, default=[]),
+ KwargInfo('rename', ContainerTypeInfo(list, str), default=[], listify=True, since='0.46.0'),
+ INSTALL_MODE_KW.evolve(since='0.38.0'),
+ KwargInfo('install_tag', (str, NoneType), since='0.60.0'),
+ )
+ def func_install_data(self, node: mparser.BaseNode,
+ args: T.Tuple[T.List['mesonlib.FileOrString']],
+ kwargs: 'kwargs.FuncInstallData') -> build.Data:
+ sources = self.source_strings_to_files(args[0] + kwargs['sources'])
+ rename = kwargs['rename'] or None
+ if rename:
+ if len(rename) != len(sources):
+ raise InvalidArguments(
+ '"rename" and "sources" argument lists must be the same length if "rename" is given. '
+ f'Rename has {len(rename)} elements and sources has {len(sources)}.')
+
+ install_dir_name = kwargs['install_dir']
+ if install_dir_name:
+ if not os.path.isabs(install_dir_name):
+ install_dir_name = os.path.join('{datadir}', install_dir_name)
+ else:
+ install_dir_name = '{datadir}'
+ return self.install_data_impl(sources, kwargs['install_dir'], kwargs['install_mode'],
+ rename, kwargs['install_tag'], install_dir_name)
+
+ def install_data_impl(self, sources: T.List[mesonlib.File], install_dir: str,
+ install_mode: FileMode, rename: T.Optional[str],
+ tag: T.Optional[str],
+ install_dir_name: T.Optional[str] = None,
+ install_data_type: T.Optional[str] = None) -> build.Data:
+
+ """Just the implementation with no validation."""
+ data = build.Data(sources, install_dir, install_dir_name or install_dir, install_mode,
+ self.subproject, rename, tag, install_data_type)
+ self.build.data.append(data)
+ return data
+
+ @typed_pos_args('install_subdir', str)
+ @typed_kwargs(
+ 'install_subdir',
+ KwargInfo('install_dir', str, required=True),
+ KwargInfo('install_tag', (str, NoneType), since='0.60.0'),
+ KwargInfo('strip_directory', bool, default=False),
+ KwargInfo('exclude_files', ContainerTypeInfo(list, str),
+ default=[], listify=True, since='0.42.0',
+ validator=lambda x: 'cannot be absolute' if any(os.path.isabs(d) for d in x) else None),
+ KwargInfo('exclude_directories', ContainerTypeInfo(list, str),
+ default=[], listify=True, since='0.42.0',
+ validator=lambda x: 'cannot be absolute' if any(os.path.isabs(d) for d in x) else None),
+ INSTALL_MODE_KW.evolve(since='0.38.0'),
+ )
+ def func_install_subdir(self, node: mparser.BaseNode, args: T.Tuple[str],
+ kwargs: 'kwargs.FuncInstallSubdir') -> build.InstallDir:
+ exclude = (set(kwargs['exclude_files']), set(kwargs['exclude_directories']))
+ idir = build.InstallDir(
+ self.subdir,
+ args[0],
+ kwargs['install_dir'],
+ kwargs['install_mode'],
+ exclude,
+ kwargs['strip_directory'],
+ self.subproject,
+ install_tag=kwargs['install_tag'])
+ self.build.install_dirs.append(idir)
+ return idir
+
+ @FeatureNewKwargs('configure_file', '0.47.0', ['copy', 'output_format', 'install_mode', 'encoding'])
+ @FeatureNewKwargs('configure_file', '0.46.0', ['format'])
+ @FeatureNewKwargs('configure_file', '0.41.0', ['capture'])
+ @FeatureNewKwargs('configure_file', '0.50.0', ['install'])
+ @FeatureNewKwargs('configure_file', '0.52.0', ['depfile'])
+ @FeatureNewKwargs('configure_file', '0.60.0', ['install_tag'])
+ @permittedKwargs({'input', 'output', 'configuration', 'command', 'copy', 'depfile',
+ 'install_dir', 'install_mode', 'capture', 'install', 'format',
+ 'output_format', 'encoding', 'install_tag'})
+ @noPosargs
+ def func_configure_file(self, node, args, kwargs):
+ if 'output' not in kwargs:
+ raise InterpreterException('Required keyword argument "output" not defined.')
+ actions = {'configuration', 'command', 'copy'}.intersection(kwargs.keys())
+ if len(actions) == 0:
+ raise InterpreterException('Must specify an action with one of these '
+ 'keyword arguments: \'configuration\', '
+ '\'command\', or \'copy\'.')
+ elif len(actions) == 2:
+ raise InterpreterException('Must not specify both {!r} and {!r} '
+ 'keyword arguments since they are '
+ 'mutually exclusive.'.format(*actions))
+ elif len(actions) == 3:
+ raise InterpreterException('Must specify one of {!r}, {!r}, and '
+ '{!r} keyword arguments since they are '
+ 'mutually exclusive.'.format(*actions))
+ if 'capture' in kwargs:
+ if not isinstance(kwargs['capture'], bool):
+ raise InterpreterException('"capture" keyword must be a boolean.')
+ if 'command' not in kwargs:
+ raise InterpreterException('"capture" keyword requires "command" keyword.')
+
+ if 'format' in kwargs:
+ fmt = kwargs['format']
+ if not isinstance(fmt, str):
+ raise InterpreterException('"format" keyword must be a string.')
+ else:
+ fmt = 'meson'
+
+ if fmt not in ('meson', 'cmake', 'cmake@'):
+ raise InterpreterException('"format" possible values are "meson", "cmake" or "cmake@".')
+
+ if 'output_format' in kwargs:
+ output_format = kwargs['output_format']
+ if not isinstance(output_format, str):
+ raise InterpreterException('"output_format" keyword must be a string.')
+ else:
+ output_format = 'c'
+
+ if output_format not in ('c', 'nasm'):
+ raise InterpreterException('"format" possible values are "c" or "nasm".')
+
+ if 'depfile' in kwargs:
+ depfile = kwargs['depfile']
+ if not isinstance(depfile, str):
+ raise InterpreterException('depfile file name must be a string')
+ else:
+ depfile = None
+
+ # Validate input
+ inputs = self.source_strings_to_files(extract_as_list(kwargs, 'input'))
+ inputs_abs = []
+ for f in inputs:
+ if isinstance(f, mesonlib.File):
+ inputs_abs.append(f.absolute_path(self.environment.source_dir,
+ self.environment.build_dir))
+ self.add_build_def_file(f)
+ else:
+ raise InterpreterException('Inputs can only be strings or file objects')
+ # Validate output
+ output = kwargs['output']
+ if not isinstance(output, str):
+ raise InterpreterException('Output file name must be a string')
+ if inputs_abs:
+ values = mesonlib.get_filenames_templates_dict(inputs_abs, None)
+ outputs = mesonlib.substitute_values([output], values)
+ output = outputs[0]
+ if depfile:
+ depfile = mesonlib.substitute_values([depfile], values)[0]
+ ofile_rpath = os.path.join(self.subdir, output)
+ if ofile_rpath in self.configure_file_outputs:
+ mesonbuildfile = os.path.join(self.subdir, 'meson.build')
+ current_call = f"{mesonbuildfile}:{self.current_lineno}"
+ first_call = "{}:{}".format(mesonbuildfile, self.configure_file_outputs[ofile_rpath])
+ mlog.warning('Output file', mlog.bold(ofile_rpath, True), 'for configure_file() at', current_call, 'overwrites configure_file() output at', first_call)
+ else:
+ self.configure_file_outputs[ofile_rpath] = self.current_lineno
+ if os.path.dirname(output) != '':
+ raise InterpreterException('Output file name must not contain a subdirectory.')
+ (ofile_path, ofile_fname) = os.path.split(os.path.join(self.subdir, output))
+ ofile_abs = os.path.join(self.environment.build_dir, ofile_path, ofile_fname)
+ # Perform the appropriate action
+ if 'configuration' in kwargs:
+ conf = kwargs['configuration']
+ if isinstance(conf, dict):
+ FeatureNew.single_use('configure_file.configuration dictionary', '0.49.0', self.subproject, location=node)
+ conf = ConfigurationDataObject(self.subproject, conf)
+ elif not isinstance(conf, ConfigurationDataObject):
+ raise InterpreterException('Argument "configuration" is not of type configuration_data')
+ mlog.log('Configuring', mlog.bold(output), 'using configuration')
+ if len(inputs) > 1:
+ raise InterpreterException('At most one input file can given in configuration mode')
+ if inputs:
+ os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
+ file_encoding = kwargs.setdefault('encoding', 'utf-8')
+ missing_variables, confdata_useless = \
+ mesonlib.do_conf_file(inputs_abs[0], ofile_abs, conf.conf_data,
+ fmt, file_encoding)
+ if missing_variables:
+ var_list = ", ".join(map(repr, sorted(missing_variables)))
+ mlog.warning(
+ f"The variable(s) {var_list} in the input file '{inputs[0]}' are not "
+ "present in the given configuration data.", location=node)
+ if confdata_useless:
+ ifbase = os.path.basename(inputs_abs[0])
+ tv = FeatureNew.get_target_version(self.subproject)
+ if FeatureNew.check_version(tv, '0.47.0'):
+ mlog.warning('Got an empty configuration_data() object and found no '
+ f'substitutions in the input file {ifbase!r}. If you want to '
+ 'copy a file to the build dir, use the \'copy:\' keyword '
+ 'argument added in 0.47.0', location=node)
+ else:
+ mesonlib.dump_conf_header(ofile_abs, conf.conf_data, output_format)
+ conf.mark_used()
+ elif 'command' in kwargs:
+ if len(inputs) > 1:
+ FeatureNew.single_use('multiple inputs in configure_file()', '0.52.0', self.subproject, location=node)
+ # We use absolute paths for input and output here because the cwd
+ # that the command is run from is 'unspecified', so it could change.
+ # Currently it's builddir/subdir for in_builddir else srcdir/subdir.
+ values = mesonlib.get_filenames_templates_dict(inputs_abs, [ofile_abs])
+ if depfile:
+ depfile = os.path.join(self.environment.get_scratch_dir(), depfile)
+ values['@DEPFILE@'] = depfile
+ # Substitute @INPUT@, @OUTPUT@, etc here.
+ _cmd = mesonlib.substitute_values(kwargs['command'], values)
+ mlog.log('Configuring', mlog.bold(output), 'with command')
+ cmd, *args = mesonlib.listify(_cmd)
+ res = self.run_command_impl(node, (cmd, args),
+ {'capture': True, 'check': True, 'env': build.EnvironmentVariables()},
+ True)
+ if 'capture' in kwargs and kwargs['capture']:
+ dst_tmp = ofile_abs + '~'
+ file_encoding = kwargs.setdefault('encoding', 'utf-8')
+ with open(dst_tmp, 'w', encoding=file_encoding) as f:
+ f.writelines(res.stdout)
+ if inputs_abs:
+ shutil.copymode(inputs_abs[0], dst_tmp)
+ mesonlib.replace_if_different(ofile_abs, dst_tmp)
+ if depfile:
+ mlog.log('Reading depfile:', mlog.bold(depfile))
+ with open(depfile, encoding='utf-8') as f:
+ df = DepFile(f.readlines())
+ deps = df.get_all_dependencies(ofile_fname)
+ for dep in deps:
+ self.add_build_def_file(dep)
+
+ elif 'copy' in kwargs:
+ if len(inputs_abs) != 1:
+ raise InterpreterException('Exactly one input file must be given in copy mode')
+ os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
+ shutil.copy2(inputs_abs[0], ofile_abs)
+ else:
+ # Not reachable
+ raise AssertionError
+ # Install file if requested, we check for the empty string
+ # for backwards compatibility. That was the behaviour before
+ # 0.45.0 so preserve it.
+ idir = kwargs.get('install_dir', '')
+ if idir is False:
+ idir = ''
+ FeatureDeprecated.single_use('configure_file install_dir: false', '0.50.0',
+ self.subproject, 'Use the `install:` kwarg instead', location=node)
+ if not isinstance(idir, str):
+ if isinstance(idir, list) and len(idir) == 0:
+ mlog.deprecation('install_dir: kwarg must be a string and not an empty array. '
+ 'Please use the install: kwarg to enable or disable installation. '
+ 'This will be a hard error in the next release.')
+ else:
+ raise InterpreterException('"install_dir" must be a string')
+ install = kwargs.get('install', idir != '')
+ if not isinstance(install, bool):
+ raise InterpreterException('"install" must be a boolean')
+ if install:
+ if not idir:
+ raise InterpreterException('"install_dir" must be specified '
+ 'when "install" in a configure_file '
+ 'is true')
+ cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
+ install_mode = self._get_kwarg_install_mode(kwargs)
+ install_tag = kwargs.get('install_tag')
+ if install_tag is not None and not isinstance(install_tag, str):
+ raise InvalidArguments('install_tag keyword argument must be string')
+ self.build.data.append(build.Data([cfile], idir, idir, install_mode, self.subproject,
+ install_tag=install_tag, data_type='configure'))
+ return mesonlib.File.from_built_file(self.subdir, output)
+
+ def extract_incdirs(self, kwargs):
+ prospectives = extract_as_list(kwargs, 'include_directories')
+ result = []
+ for p in prospectives:
+ if isinstance(p, build.IncludeDirs):
+ result.append(p)
+ elif isinstance(p, str):
+ result.append(self.build_incdir_object([p]))
+ else:
+ raise InterpreterException('Include directory objects can only be created from strings or include directories.')
+ return result
+
+ @typed_pos_args('include_directories', varargs=str)
+ @typed_kwargs('include_directories', KwargInfo('is_system', bool, default=False))
+ def func_include_directories(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]],
+ kwargs: 'kwargs.FuncIncludeDirectories') -> build.IncludeDirs:
+ return self.build_incdir_object(args[0], kwargs['is_system'])
+
+ def build_incdir_object(self, incdir_strings: T.List[str], is_system: bool = False) -> build.IncludeDirs:
+ if not isinstance(is_system, bool):
+ raise InvalidArguments('Is_system must be boolean.')
+ src_root = self.environment.get_source_dir()
+ build_root = self.environment.get_build_dir()
+ absbase_src = os.path.join(src_root, self.subdir)
+ absbase_build = os.path.join(build_root, self.subdir)
+
+ for a in incdir_strings:
+ if a.startswith(src_root):
+ raise InvalidArguments(textwrap.dedent('''\
+ Tried to form an absolute path to a source dir.
+ You should not do that but use relative paths instead.
+
+ To get include path to any directory relative to the current dir do
+
+ incdir = include_directories(dirname)
+
+ After this incdir will contain both the current source dir as well as the
+ corresponding build dir. It can then be used in any subdirectory and
+ Meson will take care of all the busywork to make paths work.
+
+ Dirname can even be '.' to mark the current directory. Though you should
+ remember that the current source and build directories are always
+ put in the include directories by default so you only need to do
+ include_directories('.') if you intend to use the result in a
+ different subdirectory.
+ '''))
+ else:
+ try:
+ self.validate_within_subproject(self.subdir, a)
+ except InterpreterException:
+ mlog.warning('include_directories sandbox violation!')
+ print(textwrap.dedent(f'''\
+ The project is trying to access the directory {a} which belongs to a different
+ subproject. This is a problem as it hardcodes the relative paths of these two projects.
+ This makes it impossible to compile the project in any other directory layout and also
+ prevents the subproject from changing its own directory layout.
+
+ Instead of poking directly at the internals the subproject should be executed and
+ it should set a variable that the caller can then use. Something like:
+
+ # In subproject
+ some_dep = declare_dependency(include_directories: include_directories('include'))
+
+ # In subproject wrap file
+ [provide]
+ some = some_dep
+
+ # In parent project
+ some_dep = dependency('some')
+ executable(..., dependencies: [some_dep])
+
+ This warning will become a hard error in a future Meson release.
+ '''))
+ absdir_src = os.path.join(absbase_src, a)
+ absdir_build = os.path.join(absbase_build, a)
+ if not os.path.isdir(absdir_src) and not os.path.isdir(absdir_build):
+ raise InvalidArguments(f'Include dir {a} does not exist.')
+ i = build.IncludeDirs(self.subdir, incdir_strings, is_system)
+ return i
+
+ @typed_pos_args('add_test_setup', str)
+ @typed_kwargs(
+ 'add_test_setup',
+ KwargInfo('exe_wrapper', ContainerTypeInfo(list, (str, ExternalProgram)), listify=True, default=[]),
+ KwargInfo('gdb', bool, default=False),
+ KwargInfo('timeout_multiplier', int, default=1),
+ KwargInfo('exclude_suites', ContainerTypeInfo(list, str), listify=True, default=[], since='0.57.0'),
+ KwargInfo('is_default', bool, default=False, since='0.49.0'),
+ ENV_KW,
+ )
+ def func_add_test_setup(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'kwargs.AddTestSetup') -> None:
+ setup_name = args[0]
+ if re.fullmatch('([_a-zA-Z][_0-9a-zA-Z]*:)?[_a-zA-Z][_0-9a-zA-Z]*', setup_name) is None:
+ raise InterpreterException('Setup name may only contain alphanumeric characters.')
+ if ":" not in setup_name:
+ setup_name = f'{(self.subproject if self.subproject else self.build.project_name)}:{setup_name}'
+
+ exe_wrapper: T.List[str] = []
+ for i in kwargs['exe_wrapper']:
+ if isinstance(i, str):
+ exe_wrapper.append(i)
+ else:
+ if not i.found():
+ raise InterpreterException('Tried to use non-found executable.')
+ exe_wrapper += i.get_command()
+
+ timeout_multiplier = kwargs['timeout_multiplier']
+ if timeout_multiplier <= 0:
+ FeatureNew('add_test_setup() timeout_multiplier <= 0', '0.57.0').use(self.subproject)
+
+ if kwargs['is_default']:
+ if self.build.test_setup_default_name is not None:
+ raise InterpreterException(f'{self.build.test_setup_default_name!r} is already set as default. '
+ 'is_default can be set to true only once')
+ self.build.test_setup_default_name = setup_name
+ self.build.test_setups[setup_name] = build.TestSetup(exe_wrapper, kwargs['gdb'], timeout_multiplier, kwargs['env'],
+ kwargs['exclude_suites'])
+
+ @typed_pos_args('add_global_arguments', varargs=str)
+ @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
+ def func_add_global_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ self._add_global_arguments(node, self.build.global_args[kwargs['native']], args[0], kwargs)
+
+ @typed_pos_args('add_global_link_arguments', varargs=str)
+ @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
+ def func_add_global_link_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ self._add_global_arguments(node, self.build.global_link_args[kwargs['native']], args[0], kwargs)
+
+ @typed_pos_args('add_project_arguments', varargs=str)
+ @typed_kwargs('add_project_arguments', NATIVE_KW, LANGUAGE_KW)
+ def func_add_project_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ self._add_project_arguments(node, self.build.projects_args[kwargs['native']], args[0], kwargs)
+
+ @typed_pos_args('add_project_link_arguments', varargs=str)
+ @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW)
+ def func_add_project_link_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ self._add_project_arguments(node, self.build.projects_link_args[kwargs['native']], args[0], kwargs)
+
+ def _warn_about_builtin_args(self, args: T.List[str]) -> None:
+ # -Wpedantic is deliberately not included, since some people want to use it but not use -Wextra
+ # see e.g.
+ # https://github.com/mesonbuild/meson/issues/3275#issuecomment-641354956
+ # https://github.com/mesonbuild/meson/issues/3742
+ warnargs = ('/W1', '/W2', '/W3', '/W4', '/Wall', '-Wall', '-Wextra')
+ optargs = ('-O0', '-O2', '-O3', '-Os', '-Oz', '/O1', '/O2', '/Os')
+ for arg in args:
+ if arg in warnargs:
+ mlog.warning(f'Consider using the built-in warning_level option instead of using "{arg}".',
+ location=self.current_node)
+ elif arg in optargs:
+ mlog.warning(f'Consider using the built-in optimization level instead of using "{arg}".',
+ location=self.current_node)
+ elif arg == '-Werror':
+ mlog.warning(f'Consider using the built-in werror option instead of using "{arg}".',
+ location=self.current_node)
+ elif arg == '-g':
+ mlog.warning(f'Consider using the built-in debug option instead of using "{arg}".',
+ location=self.current_node)
+ elif arg.startswith('-fsanitize'):
+ mlog.warning(f'Consider using the built-in option for sanitizers instead of using "{arg}".',
+ location=self.current_node)
+ elif arg.startswith('-std=') or arg.startswith('/std:'):
+ mlog.warning(f'Consider using the built-in option for language standard version instead of using "{arg}".',
+ location=self.current_node)
+
+ def _add_global_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.List[str]],
+ args: T.List[str], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ if self.is_subproject():
+ msg = f'Function \'{node.func_name}\' cannot be used in subprojects because ' \
+ 'there is no way to make that reliable.\nPlease only call ' \
+ 'this if is_subproject() returns false. Alternatively, ' \
+ 'define a variable that\ncontains your language-specific ' \
+ 'arguments and add it to the appropriate *_args kwarg ' \
+ 'in each target.'
+ raise InvalidCode(msg)
+ frozen = self.project_args_frozen or self.global_args_frozen
+ self._add_arguments(node, argsdict, frozen, args, kwargs)
+
+ def _add_project_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.Dict[str, T.List[str]]],
+ args: T.List[str], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ if self.subproject not in argsdict:
+ argsdict[self.subproject] = {}
+ self._add_arguments(node, argsdict[self.subproject],
+ self.project_args_frozen, args, kwargs)
+
+ def _add_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.List[str]],
+ args_frozen: bool, args: T.List[str], kwargs: 'kwargs.FuncAddProjectArgs') -> None:
+ if args_frozen:
+ msg = f'Tried to use \'{node.func_name}\' after a build target has been declared.\n' \
+ 'This is not permitted. Please declare all arguments before your targets.'
+ raise InvalidCode(msg)
+
+ self._warn_about_builtin_args(args)
+
+ for lang in kwargs['language']:
+ argsdict[lang] = argsdict.get(lang, []) + args
+
+ @noKwargs
+ @noArgsFlattening
+ @typed_pos_args('environment', optargs=[(str, list, dict)])
+ def func_environment(self, node: mparser.FunctionNode, args: T.Tuple[T.Union[None, str, T.List['TYPE_var'], T.Dict[str, 'TYPE_var']]],
+ kwargs: 'TYPE_kwargs') -> build.EnvironmentVariables:
+ init = args[0]
+ if init is not None:
+ FeatureNew.single_use('environment positional arguments', '0.52.0', self.subproject, location=node)
+ msg = ENV_KW.validator(init)
+ if msg:
+ raise InvalidArguments(f'"environment": {msg}')
+ return ENV_KW.convertor(init)
+ return build.EnvironmentVariables()
+
+ @typed_pos_args('join_paths', varargs=str, min_varargs=1)
+ @noKwargs
+ def func_join_paths(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> str:
+ return os.path.join(*args[0]).replace('\\', '/')
+
+ def run(self) -> None:
+ super().run()
+ mlog.log('Build targets in project:', mlog.bold(str(len(self.build.targets))))
+ FeatureNew.report(self.subproject)
+ FeatureDeprecated.report(self.subproject)
+ if not self.is_subproject():
+ self.print_extra_warnings()
+ if self.subproject == '':
+ self._print_summary()
+
+ def print_extra_warnings(self) -> None:
+ # TODO cross compilation
+ for c in self.coredata.compilers.host.values():
+ if c.get_id() == 'clang':
+ self.check_clang_asan_lundef()
+ break
+
+ def check_clang_asan_lundef(self) -> None:
+ if OptionKey('b_lundef') not in self.coredata.options:
+ return
+ if OptionKey('b_sanitize') not in self.coredata.options:
+ return
+ if (self.coredata.options[OptionKey('b_lundef')].value and
+ self.coredata.options[OptionKey('b_sanitize')].value != 'none'):
+ mlog.warning('''Trying to use {} sanitizer on Clang with b_lundef.
+This will probably not work.
+Try setting b_lundef to false instead.'''.format(self.coredata.options[OptionKey('b_sanitize')].value),
+ location=self.current_node)
+
+ # Check that the indicated file is within the same subproject
+ # as we currently are. This is to stop people doing
+ # nasty things like:
+ #
+ # f = files('../../master_src/file.c')
+ #
+ # Note that this is validated only when the file
+ # object is generated. The result can be used in a different
+ # subproject than it is defined in (due to e.g. a
+ # declare_dependency).
+ def validate_within_subproject(self, subdir, fname):
+ srcdir = Path(self.environment.source_dir)
+ norm = Path(srcdir, subdir, fname).resolve()
+ if os.path.isdir(norm):
+ inputtype = 'directory'
+ else:
+ inputtype = 'file'
+ if srcdir not in norm.parents:
+ # Grabbing files outside the source tree is ok.
+ # This is for vendor stuff like:
+ #
+ # /opt/vendorsdk/src/file_with_license_restrictions.c
+ return
+ project_root = Path(srcdir, self.root_subdir)
+ if norm == project_root:
+ return
+ if project_root not in norm.parents:
+ raise InterpreterException(f'Sandbox violation: Tried to grab {inputtype} {norm.name} outside current (sub)project.')
+ if project_root / self.subproject_dir in norm.parents:
+ raise InterpreterException(f'Sandbox violation: Tried to grab {inputtype} {norm.name} from a nested subproject.')
+
+ @T.overload
+ def source_strings_to_files(self, sources: T.List['mesonlib.FileOrString'], strict: bool = True) -> T.List['mesonlib.File']: ...
+
+ @T.overload
+ def source_strings_to_files(self, sources: T.List['mesonlib.FileOrString'], strict: bool = False) -> T.List['mesonlib.FileOrString']: ... # noqa: F811
+
+ @T.overload
+ def source_strings_to_files(self, sources: T.List['SourceInputs'], strict: bool = True) -> T.List['SourceOutputs']: ... # noqa: F811
+
+ def source_strings_to_files(self, sources: T.List['SourceInputs'], strict: bool = True) -> T.List['SourceOutputs']: # noqa: F811
+ """Lower inputs to a list of Targets and Files, replacing any strings.
+
+ :param sources: A raw (Meson DSL) list of inputs (targets, files, and
+ strings)
+ :raises InterpreterException: if any of the inputs are of an invalid type
+ :return: A list of Targets and Files
+ """
+ mesonlib.check_direntry_issues(sources)
+ if not isinstance(sources, list):
+ sources = [sources]
+ results: T.List['SourceOutputs'] = []
+ for s in sources:
+ if isinstance(s, str):
+ if not strict and s.startswith(self.environment.get_build_dir()):
+ results.append(s)
+ mlog.warning(f'Source item {s!r} cannot be converted to File object, because it is a generated file. '
+ 'This will become a hard error in the future.', location=self.current_node)
+ else:
+ self.validate_within_subproject(self.subdir, s)
+ results.append(mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, s))
+ elif isinstance(s, mesonlib.File):
+ results.append(s)
+ elif isinstance(s, (build.GeneratedList, build.BuildTarget,
+ build.CustomTargetIndex, build.CustomTarget,
+ build.ExtractedObjects)):
+ results.append(s)
+ else:
+ raise InterpreterException(f'Source item is {s!r} instead of '
+ 'string or File-type object')
+ return results
+
+ def add_target(self, name, tobj):
+ if name == '':
+ raise InterpreterException('Target name must not be empty.')
+ if name.strip() == '':
+ raise InterpreterException('Target name must not consist only of whitespace.')
+ if has_path_sep(name):
+ pathseg = os.path.join(self.subdir, os.path.split(name)[0])
+ if os.path.exists(os.path.join(self.source_root, pathseg)):
+ raise InvalidArguments(textwrap.dedent(f'''\
+ Target "{name}" has a path segment pointing to directory "{pathseg}". This is an error.
+ To define a target that builds in that directory you must define it
+ in the meson.build file in that directory.
+ '''))
+ if name.startswith('meson-'):
+ raise InvalidArguments("Target names starting with 'meson-' are reserved "
+ "for Meson's internal use. Please rename.")
+ if name in coredata.FORBIDDEN_TARGET_NAMES:
+ raise InvalidArguments(f"Target name '{name}' is reserved for Meson's "
+ "internal use. Please rename.")
+ # To permit an executable and a shared library to have the
+ # same name, such as "foo.exe" and "libfoo.a".
+ idname = tobj.get_id()
+ if idname in self.build.targets:
+ raise InvalidCode(f'Tried to create target "{name}", but a target of that name already exists.')
+ self.build.targets[idname] = tobj
+ if idname not in self.coredata.target_guids:
+ self.coredata.target_guids[idname] = str(uuid.uuid4()).upper()
+
+ @FeatureNew('both_libraries', '0.46.0')
+ def build_both_libraries(self, node, args, kwargs):
+ shared_lib = self.build_target(node, args, kwargs, build.SharedLibrary)
+
+ # Check if user forces non-PIC static library.
+ pic = True
+ key = OptionKey('b_staticpic')
+ if 'pic' in kwargs:
+ pic = kwargs['pic']
+ elif key in self.environment.coredata.options:
+ pic = self.environment.coredata.options[key].value
+
+ if self.backend.name == 'xcode':
+ # Xcode is a bit special in that you can't (at least for the moment)
+ # form a library only from object file inputs. The simple but inefficient
+ # solution is to use the sources directly. This will lead to them being
+ # built twice. This is unfortunate and slow, but at least it works.
+ # Feel free to submit patches to get this fixed if it is an
+ # issue for you.
+ reuse_object_files = False
+ else:
+ reuse_object_files = pic
+
+ if reuse_object_files:
+ # Exclude sources from args and kwargs to avoid building them twice
+ static_args = [args[0]]
+ static_kwargs = kwargs.copy()
+ static_kwargs['sources'] = []
+ static_kwargs['objects'] = shared_lib.extract_all_objects()
+ else:
+ static_args = args
+ static_kwargs = kwargs
+
+ static_lib = self.build_target(node, static_args, static_kwargs, build.StaticLibrary)
+
+ return build.BothLibraries(shared_lib, static_lib)
+
+ def build_library(self, node, args, kwargs):
+ default_library = self.coredata.get_option(OptionKey('default_library', subproject=self.subproject))
+ if default_library == 'shared':
+ return self.build_target(node, args, kwargs, build.SharedLibrary)
+ elif default_library == 'static':
+ return self.build_target(node, args, kwargs, build.StaticLibrary)
+ elif default_library == 'both':
+ return self.build_both_libraries(node, args, kwargs)
+ else:
+ raise InterpreterException(f'Unknown default_library value: {default_library}.')
+
+ def build_target(self, node, args, kwargs, targetclass):
+ @FeatureNewKwargs('build target', '0.42.0', ['rust_crate_type', 'build_rpath', 'implicit_include_directories'])
+ @FeatureNewKwargs('build target', '0.41.0', ['rust_args'])
+ @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
+ @FeatureNewKwargs('build target', '0.48.0', ['gnu_symbol_visibility'])
+ def build_target_decorator_caller(self, node, args, kwargs):
+ return True
+
+ build_target_decorator_caller(self, node, args, kwargs)
+
+ if not args:
+ raise InterpreterException('Target does not have a name.')
+ name, *sources = args
+ for_machine = self.machine_from_native_kwarg(kwargs)
+ if 'sources' in kwargs:
+ sources += listify(kwargs['sources'])
+ sources = self.source_strings_to_files(sources)
+ objs = extract_as_list(kwargs, 'objects')
+ kwargs['dependencies'] = extract_as_list(kwargs, 'dependencies')
+ kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
+ if 'extra_files' in kwargs:
+ ef = extract_as_list(kwargs, 'extra_files')
+ kwargs['extra_files'] = self.source_strings_to_files(ef)
+ self.check_sources_exist(os.path.join(self.source_root, self.subdir), sources)
+ if targetclass not in {build.Executable, build.SharedLibrary, build.SharedModule, build.StaticLibrary, build.Jar}:
+ mlog.debug('Unknown target type:', str(targetclass))
+ raise RuntimeError('Unreachable code')
+ self.kwarg_strings_to_includedirs(kwargs)
+
+ # Filter out kwargs from other target types. For example 'soversion'
+ # passed to library() when default_library == 'static'.
+ kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs}
+
+ kwargs['include_directories'] = self.extract_incdirs(kwargs)
+ target = targetclass(name, self.subdir, self.subproject, for_machine, sources, objs, self.environment, kwargs)
+ target.project_version = self.project_version
+
+ self.add_stdlib_info(target)
+ self.add_target(name, target)
+ self.project_args_frozen = True
+ return target
+
+ def kwarg_strings_to_includedirs(self, kwargs):
+ if 'd_import_dirs' in kwargs:
+ items = mesonlib.extract_as_list(kwargs, 'd_import_dirs')
+ cleaned_items = []
+ for i in items:
+ if isinstance(i, str):
+ # BW compatibility. This was permitted so we must support it
+ # for a few releases so people can transition to "correct"
+ # path declarations.
+ if os.path.normpath(i).startswith(self.environment.get_source_dir()):
+ mlog.warning('''Building a path to the source dir is not supported. Use a relative path instead.
+This will become a hard error in the future.''', location=self.current_node)
+ i = os.path.relpath(i, os.path.join(self.environment.get_source_dir(), self.subdir))
+ i = self.build_incdir_object([i])
+ cleaned_items.append(i)
+ kwargs['d_import_dirs'] = cleaned_items
+
+ def get_used_languages(self, target):
+ result = set()
+ for i in target.sources:
+ for lang, c in self.coredata.compilers[target.for_machine].items():
+ if c.can_compile(i):
+ result.add(lang)
+ break
+ return result
+
+ def add_stdlib_info(self, target):
+ for l in self.get_used_languages(target):
+ dep = self.build.stdlibs[target.for_machine].get(l, None)
+ if dep:
+ target.add_deps(dep)
+
+ def check_sources_exist(self, subdir, sources):
+ for s in sources:
+ if not isinstance(s, str):
+ continue # This means a generated source and they always exist.
+ fname = os.path.join(subdir, s)
+ if not os.path.isfile(fname):
+ raise InterpreterException(f'Tried to add non-existing source file {s}.')
+
+ # Only permit object extraction from the same subproject
+ def validate_extraction(self, buildtarget: mesonlib.HoldableObject) -> None:
+ if self.subproject != buildtarget.subproject:
+ raise InterpreterException('Tried to extract objects from a different subproject.')
+
+ def is_subproject(self) -> bool:
+ return self.subproject != ''
+
+ @typed_pos_args('set_variable', str, object)
+ @noKwargs
+ @noArgsFlattening
+ @noSecondLevelHolderResolving
+ def func_set_variable(self, node: mparser.BaseNode, args: T.Tuple[str, object], kwargs: 'TYPE_kwargs') -> None:
+ varname, value = args
+ self.set_variable(varname, value, holderify=True)
+
+ @typed_pos_args('get_variable', (str, Disabler), optargs=[object])
+ @noKwargs
+ @noArgsFlattening
+ @unholder_return
+ def func_get_variable(self, node: mparser.BaseNode, args: T.Tuple[T.Union[str, Disabler], T.Optional[object]],
+ kwargs: 'TYPE_kwargs') -> 'TYPE_var':
+ varname, fallback = args
+ if isinstance(varname, Disabler):
+ return varname
+
+ try:
+ return self.variables[varname]
+ except KeyError:
+ if fallback is not None:
+ return self._holderify(fallback)
+ raise InterpreterException(f'Tried to get unknown variable "{varname}".')
+
+ @typed_pos_args('is_variable', str)
+ @noKwargs
+ def func_is_variable(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool:
+ return args[0] in self.variables
+
+ @FeatureNew('unset_variable', '0.60.0')
+ @typed_pos_args('unset_variable', str)
+ @noKwargs
+ def func_unset_variable(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> None:
+ varname = args[0]
+ try:
+ del self.variables[varname]
+ except KeyError:
+ raise InterpreterException(f'Tried to unset unknown variable "{varname}".')
+
+ @staticmethod
+ def machine_from_native_kwarg(kwargs: T.Dict[str, T.Any]) -> MachineChoice:
+ native = kwargs.get('native', False)
+ if not isinstance(native, bool):
+ raise InvalidArguments('Argument to "native" must be a boolean.')
+ return MachineChoice.BUILD if native else MachineChoice.HOST
+
+ @FeatureNew('is_disabler', '0.52.0')
+ @typed_pos_args('is_disabler', object)
+ @noKwargs
+ def func_is_disabler(self, node: mparser.BaseNode, args: T.Tuple[object], kwargs: 'TYPE_kwargs') -> bool:
+ return isinstance(args[0], Disabler)
+
+ @noKwargs
+ @FeatureNew('range', '0.58.0')
+ @typed_pos_args('range', int, optargs=[int, int])
+ def func_range(self, node, args: T.Tuple[int, T.Optional[int], T.Optional[int]], kwargs: T.Dict[str, T.Any]) -> P_OBJ.RangeHolder:
+ start, stop, step = args
+ # Just like Python's range, we allow range(stop), range(start, stop), or
+ # range(start, stop, step)
+ if stop is None:
+ stop = start
+ start = 0
+ if step is None:
+ step = 1
+ # This is more strict than Python's range()
+ if start < 0:
+ raise InterpreterException('start cannot be negative')
+ if stop < start:
+ raise InterpreterException('stop cannot be less than start')
+ if step < 1:
+ raise InterpreterException('step must be >=1')
+ return P_OBJ.RangeHolder(start, stop, step, subproject=self.subproject)
diff -Nru meson-0.53.2/mesonbuild/interpreter/kwargs.py meson-0.61.2/mesonbuild/interpreter/kwargs.py
--- meson-0.53.2/mesonbuild/interpreter/kwargs.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/kwargs.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,241 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2021 The Meson Developers
+# Copyright © 2021 Intel Corporation
+
+"""Keyword Argument type annotations."""
+
+import typing as T
+
+from typing_extensions import TypedDict, Literal, Protocol
+
+from .. import build
+from .. import coredata
+from ..mesonlib import MachineChoice, File, FileMode, FileOrString, OptionKey
+from ..programs import ExternalProgram
+
+
+class FuncAddProjectArgs(TypedDict):
+
+ """Keyword Arguments for the add_*_arguments family of arguments.
+
+ including `add_global_arguments`, `add_project_arguments`, and their
+ link variants
+
+ Because of the use of a convertor function, we get the native keyword as
+ a MachineChoice instance already.
+ """
+
+ native: MachineChoice
+ language: T.List[str]
+
+
+class BaseTest(TypedDict):
+
+ """Shared base for the Rust module."""
+
+ args: T.List[T.Union[str, File, build.Target]]
+ should_fail: bool
+ timeout: int
+ workdir: T.Optional[str]
+ depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]]
+ priority: int
+ env: build.EnvironmentVariables
+ suite: T.List[str]
+
+
+class FuncBenchmark(BaseTest):
+
+ """Keyword Arguments shared between `test` and `benchmark`."""
+
+ protocol: Literal['exitcode', 'tap', 'gtest', 'rust']
+
+
+class FuncTest(FuncBenchmark):
+
+ """Keyword Arguments for `test`
+
+ `test` only adds the `is_prallel` argument over benchmark, so inherintance
+ is helpful here.
+ """
+
+ is_parallel: bool
+
+
+class ExtractRequired(TypedDict):
+
+ """Keyword Arguments consumed by the `extract_required_kwargs` function.
+
+ Any function that uses the `required` keyword argument which accepts either
+ a boolean or a feature option should inherit it's arguments from this class.
+ """
+
+ required: T.Union[bool, coredata.UserFeatureOption]
+
+
+class ExtractSearchDirs(TypedDict):
+
+ """Keyword arguments consumed by the `extract_search_dirs` function.
+
+ See the not in `ExtractRequired`
+ """
+
+ dirs: T.List[str]
+
+
+class FuncGenerator(TypedDict):
+
+ """Keyword rguments for the generator function."""
+
+ arguments: T.List[str]
+ output: T.List[str]
+ depfile: T.Optional[str]
+ capture: bool
+ depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]]
+
+
+class GeneratorProcess(TypedDict):
+
+ """Keyword Arguments for generator.process."""
+
+ preserve_path_from: T.Optional[str]
+ extra_args: T.List[str]
+
+class DependencyMethodPartialDependency(TypedDict):
+
+ """ Keyword Arguments for the dep.partial_dependency methods """
+
+ compile_args: bool
+ link_args: bool
+ links: bool
+ includes: bool
+ sources: bool
+
+class BuildTargeMethodExtractAllObjects(TypedDict):
+ recursive: bool
+
+class FuncInstallSubdir(TypedDict):
+
+ install_dir: str
+ strip_directory: bool
+ exclude_files: T.List[str]
+ exclude_directories: T.List[str]
+ install_mode: FileMode
+
+
+class FuncInstallData(TypedDict):
+
+ install_dir: str
+ sources: T.List[FileOrString]
+ rename: T.List[str]
+ install_mode: FileMode
+
+
+class FuncInstallHeaders(TypedDict):
+
+ install_dir: T.Optional[str]
+ install_mode: FileMode
+ subdir: T.Optional[str]
+
+
+class FuncInstallMan(TypedDict):
+
+ install_dir: T.Optional[str]
+ install_mode: FileMode
+ locale: T.Optional[str]
+
+
+class FuncImportModule(ExtractRequired):
+
+ disabler: bool
+
+
+class FuncIncludeDirectories(TypedDict):
+
+ is_system: bool
+
+class FuncAddLanguages(ExtractRequired):
+
+ native: T.Optional[bool]
+
+class RunTarget(TypedDict):
+
+ command: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, ExternalProgram, File]]
+ depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]]
+ env: build.EnvironmentVariables
+
+
+class CustomTarget(TypedDict):
+
+ build_always: bool
+ build_always_stale: bool
+ build_by_default: bool
+ capture: bool
+ command: T.List[T.Union[str, build.BuildTarget, build.CustomTarget,
+ build.CustomTargetIndex, ExternalProgram, File]]
+ consonle: bool
+ depend_files: T.List[FileOrString]
+ depends: T.List[T.Union[build.BuildTarget, build.CustomTarget]]
+ depfile: T.Optional[str]
+ env: build.EnvironmentVariables
+ feed: bool
+ input: T.List[T.Union[str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+ build.ExtractedObjects, build.GeneratedList, ExternalProgram, File]]
+ install: bool
+ install_dir: T.List[T.Union[str, bool]]
+ install_mode: FileMode
+ install_tag: T.List[T.Union[str, bool]]
+ output: T.List[str]
+ override_options: T.Dict[OptionKey, str]
+
+class AddTestSetup(TypedDict):
+
+ exe_wrapper: T.List[T.Union[str, ExternalProgram]]
+ gdb: bool
+ timeout_multiplier: int
+ is_default: bool
+ exclude_suites: T.List[str]
+ env: build.EnvironmentVariables
+
+
+class Project(TypedDict):
+
+ version: T.Optional[FileOrString]
+ meson_version: T.Optional[str]
+ default_options: T.List[str]
+ license: T.List[str]
+ subproject_dir: str
+
+
+class _FoundProto(Protocol):
+
+ """Protocol for subdir arguments.
+
+ This allows us to define any objec that has a found(self) -> bool method
+ """
+
+ def found(self) -> bool: ...
+
+
+class Subdir(TypedDict):
+
+ if_found: T.List[_FoundProto]
+
+
+class Summary(TypedDict):
+
+ section: str
+ bool_yn: bool
+ list_sep: T.Optional[str]
+
+
+class FindProgram(ExtractRequired, ExtractSearchDirs):
+
+ native: MachineChoice
+ version: T.List[str]
+
+
+class RunCommand(TypedDict):
+
+ check: bool
+ capture: T.Optional[bool]
+ env: build.EnvironmentVariables
diff -Nru meson-0.53.2/mesonbuild/interpreter/mesonmain.py meson-0.61.2/mesonbuild/interpreter/mesonmain.py
--- meson-0.53.2/mesonbuild/interpreter/mesonmain.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/mesonmain.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,450 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+import os
+import typing as T
+
+from .. import mesonlib
+from .. import dependencies
+from .. import build
+from .. import mlog
+
+from ..mesonlib import MachineChoice, OptionKey
+from ..programs import OverrideProgram, ExternalProgram
+from ..interpreter.type_checking import ENV_KW
+from ..interpreterbase import (MesonInterpreterObject, FeatureNew, FeatureDeprecated,
+ typed_pos_args, noArgsFlattening, noPosargs, noKwargs,
+ typed_kwargs, KwargInfo, InterpreterException)
+from .primitives import MesonVersionString
+from .type_checking import NATIVE_KW, NoneType
+
+if T.TYPE_CHECKING:
+ from ..backend.backends import ExecutableSerialisation
+ from ..compilers import Compiler
+ from ..interpreterbase import TYPE_kwargs, TYPE_var
+ from .interpreter import Interpreter
+
+ from typing_extensions import TypedDict
+
+ class FuncOverrideDependency(TypedDict):
+
+ native: mesonlib.MachineChoice
+ static: T.Optional[bool]
+
+ class AddInstallScriptKW(TypedDict):
+
+ skip_if_destdir: bool
+ install_tag: str
+
+ class NativeKW(TypedDict):
+
+ native: mesonlib.MachineChoice
+
+
+class MesonMain(MesonInterpreterObject):
+ def __init__(self, build: 'build.Build', interpreter: 'Interpreter'):
+ super().__init__(subproject=interpreter.subproject)
+ self.build = build
+ self.interpreter = interpreter
+ self.methods.update({'get_compiler': self.get_compiler_method,
+ 'is_cross_build': self.is_cross_build_method,
+ 'has_exe_wrapper': self.has_exe_wrapper_method,
+ 'can_run_host_binaries': self.can_run_host_binaries_method,
+ 'is_unity': self.is_unity_method,
+ 'is_subproject': self.is_subproject_method,
+ 'current_source_dir': self.current_source_dir_method,
+ 'current_build_dir': self.current_build_dir_method,
+ 'source_root': self.source_root_method,
+ 'build_root': self.build_root_method,
+ 'project_source_root': self.project_source_root_method,
+ 'project_build_root': self.project_build_root_method,
+ 'global_source_root': self.global_source_root_method,
+ 'global_build_root': self.global_build_root_method,
+ 'add_install_script': self.add_install_script_method,
+ 'add_postconf_script': self.add_postconf_script_method,
+ 'add_dist_script': self.add_dist_script_method,
+ 'install_dependency_manifest': self.install_dependency_manifest_method,
+ 'override_dependency': self.override_dependency_method,
+ 'override_find_program': self.override_find_program_method,
+ 'project_version': self.project_version_method,
+ 'project_license': self.project_license_method,
+ 'version': self.version_method,
+ 'project_name': self.project_name_method,
+ 'get_cross_property': self.get_cross_property_method,
+ 'get_external_property': self.get_external_property_method,
+ 'has_external_property': self.has_external_property_method,
+ 'backend': self.backend_method,
+ 'add_devenv': self.add_devenv_method,
+ })
+
+ def _find_source_script(
+ self, name: str, prog: T.Union[str, mesonlib.File, build.Executable, ExternalProgram],
+ args: T.List[str]) -> 'ExecutableSerialisation':
+ largs: T.List[T.Union[str, build.Executable, ExternalProgram]] = []
+
+ if isinstance(prog, (build.Executable, ExternalProgram)):
+ FeatureNew.single_use(f'Passing executable/found program object to script parameter of {name}',
+ '0.55.0', self.subproject, location=self.current_node)
+ largs.append(prog)
+ else:
+ if isinstance(prog, mesonlib.File):
+ FeatureNew.single_use(f'Passing file object to script parameter of {name}',
+ '0.57.0', self.subproject, location=self.current_node)
+ found = self.interpreter.find_program_impl([prog])
+ largs.append(found)
+
+ largs.extend(args)
+ es = self.interpreter.backend.get_executable_serialisation(largs)
+ es.subproject = self.interpreter.subproject
+ return es
+
+ def _process_script_args(
+ self, name: str, args: T.Sequence[T.Union[
+ str, mesonlib.File, build.BuildTarget, build.CustomTarget,
+ build.CustomTargetIndex,
+ ExternalProgram,
+ ]]) -> T.List[str]:
+ script_args = [] # T.List[str]
+ new = False
+ for a in args:
+ if isinstance(a, str):
+ script_args.append(a)
+ elif isinstance(a, mesonlib.File):
+ new = True
+ script_args.append(a.rel_to_builddir(self.interpreter.environment.source_dir))
+ elif isinstance(a, (build.BuildTarget, build.CustomTarget, build.CustomTargetIndex)):
+ new = True
+ script_args.extend([os.path.join(a.get_subdir(), o) for o in a.get_outputs()])
+
+ # This feels really hacky, but I'm not sure how else to fix
+ # this without completely rewriting install script handling.
+ # This is complicated by the fact that the install target
+ # depends on all.
+ if isinstance(a, build.CustomTargetIndex):
+ a.target.build_by_default = True
+ else:
+ a.build_by_default = True
+ else:
+ script_args.extend(a.command)
+ new = True
+
+ if new:
+ FeatureNew.single_use(
+ f'Calling "{name}" with File, CustomTarget, Index of CustomTarget, '
+ 'Executable, or ExternalProgram',
+ '0.55.0', self.interpreter.subproject, location=self.current_node)
+ return script_args
+
+ @typed_pos_args(
+ 'meson.add_install_script',
+ (str, mesonlib.File, build.Executable, ExternalProgram),
+ varargs=(str, mesonlib.File, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, ExternalProgram)
+ )
+ @typed_kwargs(
+ 'meson.add_install_script',
+ KwargInfo('skip_if_destdir', bool, default=False, since='0.57.0'),
+ KwargInfo('install_tag', (str, NoneType), since='0.60.0'),
+ )
+ def add_install_script_method(
+ self,
+ args: T.Tuple[T.Union[str, mesonlib.File, build.Executable, ExternalProgram],
+ T.List[T.Union[str, mesonlib.File, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, ExternalProgram]]],
+ kwargs: 'AddInstallScriptKW') -> None:
+ script_args = self._process_script_args('add_install_script', args[1])
+ script = self._find_source_script('add_install_script', args[0], script_args)
+ script.skip_if_destdir = kwargs['skip_if_destdir']
+ script.tag = kwargs['install_tag']
+ self.build.install_scripts.append(script)
+
+ @typed_pos_args(
+ 'meson.add_postconf_script',
+ (str, mesonlib.File, ExternalProgram),
+ varargs=(str, mesonlib.File, ExternalProgram)
+ )
+ @noKwargs
+ def add_postconf_script_method(
+ self,
+ args: T.Tuple[T.Union[str, mesonlib.File, ExternalProgram],
+ T.List[T.Union[str, mesonlib.File, ExternalProgram]]],
+ kwargs: 'TYPE_kwargs') -> None:
+ script_args = self._process_script_args('add_postconf_script', args[1])
+ script = self._find_source_script('add_postconf_script', args[0], script_args)
+ self.build.postconf_scripts.append(script)
+
+ @typed_pos_args(
+ 'meson.add_dist_script',
+ (str, mesonlib.File, ExternalProgram),
+ varargs=(str, mesonlib.File, ExternalProgram)
+ )
+ @noKwargs
+ def add_dist_script_method(
+ self,
+ args: T.Tuple[T.Union[str, mesonlib.File, ExternalProgram],
+ T.List[T.Union[str, mesonlib.File, ExternalProgram]]],
+ kwargs: 'TYPE_kwargs') -> None:
+ if args[1]:
+ FeatureNew.single_use('Calling "add_dist_script" with multiple arguments',
+ '0.49.0', self.interpreter.subproject, location=self.current_node)
+ if self.interpreter.subproject != '':
+ FeatureNew.single_use('Calling "add_dist_script" in a subproject',
+ '0.58.0', self.interpreter.subproject, location=self.current_node)
+ script_args = self._process_script_args('add_dist_script', args[1])
+ script = self._find_source_script('add_dist_script', args[0], script_args)
+ self.build.dist_scripts.append(script)
+
+ @noPosargs
+ @noKwargs
+ def current_source_dir_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ src = self.interpreter.environment.source_dir
+ sub = self.interpreter.subdir
+ if sub == '':
+ return src
+ return os.path.join(src, sub)
+
+ @noPosargs
+ @noKwargs
+ def current_build_dir_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ src = self.interpreter.environment.build_dir
+ sub = self.interpreter.subdir
+ if sub == '':
+ return src
+ return os.path.join(src, sub)
+
+ @noPosargs
+ @noKwargs
+ def backend_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.interpreter.backend.name
+
+ @noPosargs
+ @noKwargs
+ @FeatureDeprecated('meson.source_root', '0.56.0', 'use meson.project_source_root() or meson.global_source_root() instead.')
+ def source_root_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.interpreter.environment.source_dir
+
+ @noPosargs
+ @noKwargs
+ @FeatureDeprecated('meson.build_root', '0.56.0', 'use meson.project_build_root() or meson.global_build_root() instead.')
+ def build_root_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.interpreter.environment.build_dir
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('meson.project_source_root', '0.56.0')
+ def project_source_root_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ src = self.interpreter.environment.source_dir
+ sub = self.interpreter.root_subdir
+ if sub == '':
+ return src
+ return os.path.join(src, sub)
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('meson.project_build_root', '0.56.0')
+ def project_build_root_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ src = self.interpreter.environment.build_dir
+ sub = self.interpreter.root_subdir
+ if sub == '':
+ return src
+ return os.path.join(src, sub)
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('meson.global_source_root', '0.58.0')
+ def global_source_root_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.interpreter.environment.source_dir
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('meson.global_build_root', '0.58.0')
+ def global_build_root_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.interpreter.environment.build_dir
+
+ @noPosargs
+ @noKwargs
+ @FeatureDeprecated('meson.has_exe_wrapper', '0.55.0', 'use meson.can_run_host_binaries instead.')
+ def has_exe_wrapper_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self._can_run_host_binaries_impl()
+
+ @noPosargs
+ @noKwargs
+ @FeatureNew('meson.can_run_host_binaries', '0.55.0')
+ def can_run_host_binaries_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self._can_run_host_binaries_impl()
+
+ def _can_run_host_binaries_impl(self) -> bool:
+ return not (
+ self.build.environment.is_cross_build() and
+ self.build.environment.need_exe_wrapper() and
+ self.build.environment.exe_wrapper is None
+ )
+
+ @noPosargs
+ @noKwargs
+ def is_cross_build_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self.build.environment.is_cross_build()
+
+ @typed_pos_args('meson.get_compiler', str)
+ @typed_kwargs('meson.get_compiler', NATIVE_KW)
+ def get_compiler_method(self, args: T.Tuple[str], kwargs: 'NativeKW') -> 'Compiler':
+ cname = args[0]
+ for_machine = kwargs['native']
+ clist = self.interpreter.coredata.compilers[for_machine]
+ try:
+ return clist[cname]
+ except KeyError:
+ raise InterpreterException(f'Tried to access compiler for language "{cname}", not specified for {for_machine.get_lower_case_name()} machine.')
+
+ @noPosargs
+ @noKwargs
+ def is_unity_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ optval = self.interpreter.environment.coredata.get_option(OptionKey('unity'))
+ return optval == 'on' or (optval == 'subprojects' and self.interpreter.is_subproject())
+
+ @noPosargs
+ @noKwargs
+ def is_subproject_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self.interpreter.is_subproject()
+
+ @typed_pos_args('meson.install_dependency_manifest', str)
+ @noKwargs
+ def install_dependency_manifest_method(self, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> None:
+ self.build.dep_manifest_name = args[0]
+
+ @FeatureNew('meson.override_find_program', '0.46.0')
+ @typed_pos_args('meson.override_find_program', str, (mesonlib.File, ExternalProgram, build.Executable))
+ @noKwargs
+ def override_find_program_method(self, args: T.Tuple[str, T.Union[mesonlib.File, ExternalProgram, build.Executable]], kwargs: 'TYPE_kwargs') -> None:
+ name, exe = args
+ if isinstance(exe, mesonlib.File):
+ abspath = exe.absolute_path(self.interpreter.environment.source_dir,
+ self.interpreter.environment.build_dir)
+ if not os.path.exists(abspath):
+ raise InterpreterException(f'Tried to override {name} with a file that does not exist.')
+ exe = OverrideProgram(name, [abspath])
+ self.interpreter.add_find_program_override(name, exe)
+
+ @typed_kwargs(
+ 'meson.override_dependency',
+ NATIVE_KW,
+ KwargInfo('static', (bool, NoneType), since='0.60.0'),
+ )
+ @typed_pos_args('meson.override_dependency', str, dependencies.Dependency)
+ @FeatureNew('meson.override_dependency', '0.54.0')
+ def override_dependency_method(self, args: T.Tuple[str, dependencies.Dependency], kwargs: 'FuncOverrideDependency') -> None:
+ name, dep = args
+ if not name:
+ raise InterpreterException('First argument must be a string and cannot be empty')
+
+ optkey = OptionKey('default_library', subproject=self.interpreter.subproject)
+ default_library = self.interpreter.coredata.get_option(optkey)
+ assert isinstance(default_library, str), 'for mypy'
+ static = kwargs['static']
+ if static is None:
+ # We don't know if dep represents a static or shared library, could
+ # be a mix of both. We assume it is following default_library
+ # value.
+ self._override_dependency_impl(name, dep, kwargs, static=None)
+ if default_library == 'static':
+ self._override_dependency_impl(name, dep, kwargs, static=True)
+ elif default_library == 'shared':
+ self._override_dependency_impl(name, dep, kwargs, static=False)
+ else:
+ self._override_dependency_impl(name, dep, kwargs, static=True)
+ self._override_dependency_impl(name, dep, kwargs, static=False)
+ else:
+ # dependency('foo') without specifying static kwarg should find this
+ # override regardless of the static value here. But do not raise error
+ # if it has already been overridden, which would happen when overriding
+ # static and shared separately:
+ # meson.override_dependency('foo', shared_dep, static: false)
+ # meson.override_dependency('foo', static_dep, static: true)
+ # In that case dependency('foo') would return the first override.
+ self._override_dependency_impl(name, dep, kwargs, static=None, permissive=True)
+ self._override_dependency_impl(name, dep, kwargs, static=static)
+
+ def _override_dependency_impl(self, name: str, dep: dependencies.Dependency, kwargs: 'FuncOverrideDependency',
+ static: T.Optional[bool], permissive: bool = False) -> None:
+ # We need the cast here as get_dep_identifier works on such a dict,
+ # which FuncOverrideDependency is, but mypy can't fgure that out
+ nkwargs = T.cast(T.Dict[str, T.Any], kwargs.copy())
+ if static is None:
+ del nkwargs['static']
+ else:
+ nkwargs['static'] = static
+ identifier = dependencies.get_dep_identifier(name, nkwargs)
+ for_machine = kwargs['native']
+ override = self.build.dependency_overrides[for_machine].get(identifier)
+ if override:
+ if permissive:
+ return
+ m = 'Tried to override dependency {!r} which has already been resolved or overridden at {}'
+ location = mlog.get_error_location_string(override.node.filename, override.node.lineno)
+ raise InterpreterException(m.format(name, location))
+ self.build.dependency_overrides[for_machine][identifier] = \
+ build.DependencyOverride(dep, self.interpreter.current_node)
+
+ @noPosargs
+ @noKwargs
+ def project_version_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.build.dep_manifest[self.interpreter.active_projectname].version
+
+ @FeatureNew('meson.project_license()', '0.45.0')
+ @noPosargs
+ @noKwargs
+ def project_license_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> T.List[str]:
+ return self.build.dep_manifest[self.interpreter.active_projectname].license
+
+ @noPosargs
+ @noKwargs
+ def version_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> MesonVersionString:
+ return MesonVersionString(self.interpreter.coredata.version)
+
+ @noPosargs
+ @noKwargs
+ def project_name_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.interpreter.active_projectname
+
+ def __get_external_property_impl(self, propname: str, fallback: T.Optional[object], machine: MachineChoice) -> object:
+ """Shared implementation for get_cross_property and get_external_property."""
+ try:
+ return self.interpreter.environment.properties[machine][propname]
+ except KeyError:
+ if fallback is not None:
+ return fallback
+ raise InterpreterException(f'Unknown property for {machine.get_lower_case_name()} machine: {propname}')
+
+ @noArgsFlattening
+ @FeatureDeprecated('meson.get_cross_property', '0.58.0', 'Use meson.get_external_property() instead')
+ @typed_pos_args('meson.get_cross_property', str, optargs=[object])
+ @noKwargs
+ def get_cross_property_method(self, args: T.Tuple[str, T.Optional[object]], kwargs: 'TYPE_kwargs') -> object:
+ propname, fallback = args
+ return self.__get_external_property_impl(propname, fallback, MachineChoice.HOST)
+
+ @noArgsFlattening
+ @FeatureNew('meson.get_external_property', '0.54.0')
+ @typed_pos_args('meson.get_external_property', str, optargs=[object])
+ @typed_kwargs('meson.get_external_property', NATIVE_KW)
+ def get_external_property_method(self, args: T.Tuple[str, T.Optional[object]], kwargs: 'NativeKW') -> object:
+ propname, fallback = args
+ return self.__get_external_property_impl(propname, fallback, kwargs['native'])
+
+ @FeatureNew('meson.has_external_property', '0.58.0')
+ @typed_pos_args('meson.has_external_property', str)
+ @typed_kwargs('meson.has_external_property', NATIVE_KW)
+ def has_external_property_method(self, args: T.Tuple[str], kwargs: 'NativeKW') -> bool:
+ prop_name = args[0]
+ return prop_name in self.interpreter.environment.properties[kwargs['native']]
+
+ @FeatureNew('add_devenv', '0.58.0')
+ @noKwargs
+ @typed_pos_args('add_devenv', (str, list, dict, build.EnvironmentVariables))
+ def add_devenv_method(self, args: T.Tuple[T.Union[str, list, dict, build.EnvironmentVariables]], kwargs: 'TYPE_kwargs') -> None:
+ env = args[0]
+ msg = ENV_KW.validator(env)
+ if msg:
+ raise build.InvalidArguments(f'"add_devenv": {msg}')
+ converted = ENV_KW.convertor(env)
+ assert isinstance(converted, build.EnvironmentVariables)
+ self.build.devenv.append(converted)
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/array.py meson-0.61.2/mesonbuild/interpreter/primitives/array.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/array.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/array.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,107 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+import typing as T
+
+from ...interpreterbase import (
+ ObjectHolder,
+ IterableObject,
+ MesonOperator,
+ typed_operator,
+ noKwargs,
+ noPosargs,
+ noArgsFlattening,
+ typed_pos_args,
+ FeatureNew,
+
+ TYPE_var,
+ TYPE_kwargs,
+
+ InvalidArguments,
+)
+from ...mparser import PlusAssignmentNode
+
+if T.TYPE_CHECKING:
+ # Object holders need the actual interpreter
+ from ...interpreter import Interpreter
+
+class ArrayHolder(ObjectHolder[T.List[TYPE_var]], IterableObject):
+ def __init__(self, obj: T.List[TYPE_var], interpreter: 'Interpreter') -> None:
+ super().__init__(obj, interpreter)
+ self.methods.update({
+ 'contains': self.contains_method,
+ 'length': self.length_method,
+ 'get': self.get_method,
+ })
+
+ self.trivial_operators.update({
+ MesonOperator.EQUALS: (list, lambda x: self.held_object == x),
+ MesonOperator.NOT_EQUALS: (list, lambda x: self.held_object != x),
+ MesonOperator.IN: (object, lambda x: x in self.held_object),
+ MesonOperator.NOT_IN: (object, lambda x: x not in self.held_object),
+ })
+
+ # Use actual methods for functions that require additional checks
+ self.operators.update({
+ MesonOperator.PLUS: self.op_plus,
+ MesonOperator.INDEX: self.op_index,
+ })
+
+ def display_name(self) -> str:
+ return 'array'
+
+ def iter_tuple_size(self) -> None:
+ return None
+
+ def iter_self(self) -> T.Iterator[TYPE_var]:
+ return iter(self.held_object)
+
+ def size(self) -> int:
+ return len(self.held_object)
+
+ @noArgsFlattening
+ @noKwargs
+ @typed_pos_args('array.contains', object)
+ def contains_method(self, args: T.Tuple[object], kwargs: TYPE_kwargs) -> bool:
+ def check_contains(el: T.List[TYPE_var]) -> bool:
+ for element in el:
+ if isinstance(element, list):
+ found = check_contains(element)
+ if found:
+ return True
+ if element == args[0]:
+ return True
+ return False
+ return check_contains(self.held_object)
+
+ @noKwargs
+ @noPosargs
+ def length_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> int:
+ return len(self.held_object)
+
+ @noArgsFlattening
+ @noKwargs
+ @typed_pos_args('array.get', int, optargs=[object])
+ def get_method(self, args: T.Tuple[int, T.Optional[TYPE_var]], kwargs: TYPE_kwargs) -> TYPE_var:
+ index = args[0]
+ if index < -len(self.held_object) or index >= len(self.held_object):
+ if args[1] is None:
+ raise InvalidArguments(f'Array index {index} is out of bounds for array of size {len(self.held_object)}.')
+ return args[1]
+ return self.held_object[index]
+
+ @typed_operator(MesonOperator.PLUS, object)
+ def op_plus(self, other: TYPE_var) -> T.List[TYPE_var]:
+ if not isinstance(other, list):
+ if not isinstance(self.current_node, PlusAssignmentNode):
+ FeatureNew.single_use('list.', '0.60.0', self.subproject, 'The right hand operand was not a list.',
+ location=self.current_node)
+ other = [other]
+ return self.held_object + other
+
+ @typed_operator(MesonOperator.INDEX, int)
+ def op_index(self, other: int) -> TYPE_var:
+ try:
+ return self.held_object[other]
+ except IndexError:
+ raise InvalidArguments(f'Index {other} out of bounds of array of size {len(self.held_object)}.')
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/boolean.py meson-0.61.2/mesonbuild/interpreter/primitives/boolean.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/boolean.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/boolean.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,53 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+from ...interpreterbase import (
+ ObjectHolder,
+ MesonOperator,
+ typed_pos_args,
+ noKwargs,
+ noPosargs,
+
+ TYPE_var,
+ TYPE_kwargs,
+
+ InvalidArguments
+)
+
+import typing as T
+
+if T.TYPE_CHECKING:
+ # Object holders need the actual interpreter
+ from ...interpreter import Interpreter
+
+class BooleanHolder(ObjectHolder[bool]):
+ def __init__(self, obj: bool, interpreter: 'Interpreter') -> None:
+ super().__init__(obj, interpreter)
+ self.methods.update({
+ 'to_int': self.to_int_method,
+ 'to_string': self.to_string_method,
+ })
+
+ self.trivial_operators.update({
+ MesonOperator.BOOL: (None, lambda x: self.held_object),
+ MesonOperator.NOT: (None, lambda x: not self.held_object),
+ MesonOperator.EQUALS: (bool, lambda x: self.held_object == x),
+ MesonOperator.NOT_EQUALS: (bool, lambda x: self.held_object != x),
+ })
+
+ def display_name(self) -> str:
+ return 'bool'
+
+ @noKwargs
+ @noPosargs
+ def to_int_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> int:
+ return 1 if self.held_object else 0
+
+ @noKwargs
+ @typed_pos_args('bool.to_string', optargs=[str, str])
+ def to_string_method(self, args: T.Tuple[T.Optional[str], T.Optional[str]], kwargs: TYPE_kwargs) -> str:
+ true_str = args[0] or 'true'
+ false_str = args[1] or 'false'
+ if any(x is not None for x in args) and not all(x is not None for x in args):
+ raise InvalidArguments('bool.to_string() must have either no arguments or exactly two string arguments that signify what values to return for true and false.')
+ return true_str if self.held_object else false_str
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/dict.py meson-0.61.2/mesonbuild/interpreter/primitives/dict.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/dict.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/dict.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,87 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+import typing as T
+
+from ...interpreterbase import (
+ ObjectHolder,
+ IterableObject,
+ MesonOperator,
+ typed_operator,
+ noKwargs,
+ noPosargs,
+ noArgsFlattening,
+ typed_pos_args,
+
+ TYPE_var,
+ TYPE_kwargs,
+
+ InvalidArguments,
+)
+
+if T.TYPE_CHECKING:
+ # Object holders need the actual interpreter
+ from ...interpreter import Interpreter
+
+class DictHolder(ObjectHolder[T.Dict[str, TYPE_var]], IterableObject):
+ def __init__(self, obj: T.Dict[str, TYPE_var], interpreter: 'Interpreter') -> None:
+ super().__init__(obj, interpreter)
+ self.methods.update({
+ 'has_key': self.has_key_method,
+ 'keys': self.keys_method,
+ 'get': self.get_method,
+ })
+
+ self.trivial_operators.update({
+ # Arithmetic
+ MesonOperator.PLUS: (dict, lambda x: {**self.held_object, **x}),
+
+ # Comparison
+ MesonOperator.EQUALS: (dict, lambda x: self.held_object == x),
+ MesonOperator.NOT_EQUALS: (dict, lambda x: self.held_object != x),
+ MesonOperator.IN: (str, lambda x: x in self.held_object),
+ MesonOperator.NOT_IN: (str, lambda x: x not in self.held_object),
+ })
+
+ # Use actual methods for functions that require additional checks
+ self.operators.update({
+ MesonOperator.INDEX: self.op_index,
+ })
+
+ def display_name(self) -> str:
+ return 'dict'
+
+ def iter_tuple_size(self) -> int:
+ return 2
+
+ def iter_self(self) -> T.Iterator[T.Tuple[str, TYPE_var]]:
+ return iter(self.held_object.items())
+
+ def size(self) -> int:
+ return len(self.held_object)
+
+ @noKwargs
+ @typed_pos_args('dict.has_key', str)
+ def has_key_method(self, args: T.Tuple[str], kwargs: TYPE_kwargs) -> bool:
+ return args[0] in self.held_object
+
+ @noKwargs
+ @noPosargs
+ def keys_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> T.List[str]:
+ return sorted(self.held_object)
+
+ @noArgsFlattening
+ @noKwargs
+ @typed_pos_args('dict.get', str, optargs=[object])
+ def get_method(self, args: T.Tuple[str, T.Optional[TYPE_var]], kwargs: TYPE_kwargs) -> TYPE_var:
+ if args[0] in self.held_object:
+ return self.held_object[args[0]]
+ if args[1] is not None:
+ return args[1]
+ raise InvalidArguments(f'Key {args[0]!r} is not in the dictionary.')
+
+ @typed_operator(MesonOperator.INDEX, str)
+ def op_index(self, other: str) -> TYPE_var:
+ if other not in self.held_object:
+ raise InvalidArguments(f'Key {other} is not in the dictionary.')
+ return self.held_object[other]
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/__init__.py meson-0.61.2/mesonbuild/interpreter/primitives/__init__.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/__init__.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/__init__.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,20 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+__all__ = [
+ 'ArrayHolder',
+ 'BooleanHolder',
+ 'DictHolder',
+ 'IntegerHolder',
+ 'RangeHolder',
+ 'StringHolder',
+ 'MesonVersionString',
+ 'MesonVersionStringHolder',
+]
+
+from .array import ArrayHolder
+from .boolean import BooleanHolder
+from .dict import DictHolder
+from .integer import IntegerHolder
+from .range import RangeHolder
+from .string import StringHolder, MesonVersionString, MesonVersionStringHolder
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/integer.py meson-0.61.2/mesonbuild/interpreter/primitives/integer.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/integer.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/integer.py 2021-11-02 19:58:13.000000000 +0000
@@ -0,0 +1,82 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+from ...interpreterbase import (
+ ObjectHolder,
+ MesonOperator,
+ typed_operator,
+ noKwargs,
+ noPosargs,
+
+ TYPE_var,
+ TYPE_kwargs,
+
+ InvalidArguments
+)
+
+import typing as T
+
+if T.TYPE_CHECKING:
+ # Object holders need the actual interpreter
+ from ...interpreter import Interpreter
+
+class IntegerHolder(ObjectHolder[int]):
+ def __init__(self, obj: int, interpreter: 'Interpreter') -> None:
+ super().__init__(obj, interpreter)
+ self.methods.update({
+ 'is_even': self.is_even_method,
+ 'is_odd': self.is_odd_method,
+ 'to_string': self.to_string_method,
+ })
+
+ self.trivial_operators.update({
+ # Arithmetic
+ MesonOperator.UMINUS: (None, lambda x: -self.held_object),
+ MesonOperator.PLUS: (int, lambda x: self.held_object + x),
+ MesonOperator.MINUS: (int, lambda x: self.held_object - x),
+ MesonOperator.TIMES: (int, lambda x: self.held_object * x),
+
+ # Comparison
+ MesonOperator.EQUALS: (int, lambda x: self.held_object == x),
+ MesonOperator.NOT_EQUALS: (int, lambda x: self.held_object != x),
+ MesonOperator.GREATER: (int, lambda x: self.held_object > x),
+ MesonOperator.LESS: (int, lambda x: self.held_object < x),
+ MesonOperator.GREATER_EQUALS: (int, lambda x: self.held_object >= x),
+ MesonOperator.LESS_EQUALS: (int, lambda x: self.held_object <= x),
+ })
+
+ # Use actual methods for functions that require additional checks
+ self.operators.update({
+ MesonOperator.DIV: self.op_div,
+ MesonOperator.MOD: self.op_mod,
+ })
+
+ def display_name(self) -> str:
+ return 'int'
+
+ @noKwargs
+ @noPosargs
+ def is_even_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.held_object % 2 == 0
+
+ @noKwargs
+ @noPosargs
+ def is_odd_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> bool:
+ return self.held_object % 2 != 0
+
+ @noKwargs
+ @noPosargs
+ def to_string_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return str(self.held_object)
+
+ @typed_operator(MesonOperator.DIV, int)
+ def op_div(self, other: int) -> int:
+ if other == 0:
+ raise InvalidArguments('Tried to divide by 0')
+ return self.held_object // other
+
+ @typed_operator(MesonOperator.MOD, int)
+ def op_mod(self, other: int) -> int:
+ if other == 0:
+ raise InvalidArguments('Tried to divide by 0')
+ return self.held_object % other
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/range.py meson-0.61.2/mesonbuild/interpreter/primitives/range.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/range.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/range.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,34 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+import typing as T
+
+from ...interpreterbase import (
+ MesonInterpreterObject,
+ IterableObject,
+ MesonOperator,
+ InvalidArguments,
+)
+
+class RangeHolder(MesonInterpreterObject, IterableObject):
+ def __init__(self, start: int, stop: int, step: int, *, subproject: str) -> None:
+ super().__init__(subproject=subproject)
+ self.range = range(start, stop, step)
+ self.operators.update({
+ MesonOperator.INDEX: self.op_index,
+ })
+
+ def op_index(self, other: int) -> int:
+ try:
+ return self.range[other]
+ except:
+ raise InvalidArguments(f'Index {other} out of bounds of range.')
+
+ def iter_tuple_size(self) -> None:
+ return None
+
+ def iter_self(self) -> T.Iterator[int]:
+ return iter(self.range)
+
+ def size(self) -> int:
+ return len(self.range)
diff -Nru meson-0.53.2/mesonbuild/interpreter/primitives/string.py meson-0.61.2/mesonbuild/interpreter/primitives/string.py
--- meson-0.53.2/mesonbuild/interpreter/primitives/string.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/primitives/string.py 2021-11-25 22:00:46.000000000 +0000
@@ -0,0 +1,183 @@
+# Copyright 2021 The Meson development team
+# SPDX-license-identifier: Apache-2.0
+
+import re
+import os
+from pathlib import PurePath
+
+import typing as T
+
+from ...mesonlib import version_compare
+from ...interpreterbase import (
+ ObjectHolder,
+ MesonOperator,
+ FeatureNew,
+ typed_operator,
+ noArgsFlattening,
+ noKwargs,
+ noPosargs,
+ typed_pos_args,
+
+ TYPE_var,
+ TYPE_kwargs,
+
+ InvalidArguments,
+)
+
+
+if T.TYPE_CHECKING:
+ # Object holders need the actual interpreter
+ from ...interpreter import Interpreter
+
+class StringHolder(ObjectHolder[str]):
+ def __init__(self, obj: str, interpreter: 'Interpreter') -> None:
+ super().__init__(obj, interpreter)
+ self.methods.update({
+ 'contains': self.contains_method,
+ 'startswith': self.startswith_method,
+ 'endswith': self.endswith_method,
+ 'format': self.format_method,
+ 'join': self.join_method,
+ 'replace': self.replace_method,
+ 'split': self.split_method,
+ 'strip': self.strip_method,
+ 'substring': self.substring_method,
+ 'to_int': self.to_int_method,
+ 'to_lower': self.to_lower_method,
+ 'to_upper': self.to_upper_method,
+ 'underscorify': self.underscorify_method,
+ 'version_compare': self.version_compare_method,
+ })
+
+ self.trivial_operators.update({
+ # Arithmetic
+ MesonOperator.PLUS: (str, lambda x: self.held_object + x),
+
+ # Comparison
+ MesonOperator.EQUALS: (str, lambda x: self.held_object == x),
+ MesonOperator.NOT_EQUALS: (str, lambda x: self.held_object != x),
+ MesonOperator.GREATER: (str, lambda x: self.held_object > x),
+ MesonOperator.LESS: (str, lambda x: self.held_object < x),
+ MesonOperator.GREATER_EQUALS: (str, lambda x: self.held_object >= x),
+ MesonOperator.LESS_EQUALS: (str, lambda x: self.held_object <= x),
+ })
+
+ # Use actual methods for functions that require additional checks
+ self.operators.update({
+ MesonOperator.DIV: self.op_div,
+ MesonOperator.INDEX: self.op_index,
+ })
+
+ def display_name(self) -> str:
+ return 'str'
+
+ @noKwargs
+ @typed_pos_args('str.contains', str)
+ def contains_method(self, args: T.Tuple[str], kwargs: TYPE_kwargs) -> bool:
+ return self.held_object.find(args[0]) >= 0
+
+ @noKwargs
+ @typed_pos_args('str.startswith', str)
+ def startswith_method(self, args: T.Tuple[str], kwargs: TYPE_kwargs) -> bool:
+ return self.held_object.startswith(args[0])
+
+ @noKwargs
+ @typed_pos_args('str.endswith', str)
+ def endswith_method(self, args: T.Tuple[str], kwargs: TYPE_kwargs) -> bool:
+ return self.held_object.endswith(args[0])
+
+ @noArgsFlattening
+ @noKwargs
+ @typed_pos_args('str.format', varargs=object)
+ def format_method(self, args: T.Tuple[T.List[object]], kwargs: TYPE_kwargs) -> str:
+ arg_strings: T.List[str] = []
+ for arg in args[0]:
+ if isinstance(arg, bool): # Python boolean is upper case.
+ arg = str(arg).lower()
+ arg_strings.append(str(arg))
+
+ def arg_replace(match: T.Match[str]) -> str:
+ idx = int(match.group(1))
+ if idx >= len(arg_strings):
+ raise InvalidArguments(f'Format placeholder @{idx}@ out of range.')
+ return arg_strings[idx]
+
+ return re.sub(r'@(\d+)@', arg_replace, self.held_object)
+
+ @noKwargs
+ @typed_pos_args('str.join', varargs=str)
+ def join_method(self, args: T.Tuple[T.List[str]], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.join(args[0])
+
+ @noKwargs
+ @typed_pos_args('str.replace', str, str)
+ def replace_method(self, args: T.Tuple[str, str], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.replace(args[0], args[1])
+
+ @noKwargs
+ @typed_pos_args('str.split', optargs=[str])
+ def split_method(self, args: T.Tuple[T.Optional[str]], kwargs: TYPE_kwargs) -> T.List[str]:
+ return self.held_object.split(args[0])
+
+ @noKwargs
+ @typed_pos_args('str.strip', optargs=[str])
+ def strip_method(self, args: T.Tuple[T.Optional[str]], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.strip(args[0])
+
+ @noKwargs
+ @typed_pos_args('str.substring', optargs=[int, int])
+ def substring_method(self, args: T.Tuple[T.Optional[int], T.Optional[int]], kwargs: TYPE_kwargs) -> str:
+ start = args[0] if args[0] is not None else 0
+ end = args[1] if args[1] is not None else len(self.held_object)
+ return self.held_object[start:end]
+
+ @noKwargs
+ @noPosargs
+ def to_int_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> int:
+ try:
+ return int(self.held_object)
+ except ValueError:
+ raise InvalidArguments(f'String {self.held_object!r} cannot be converted to int')
+
+ @noKwargs
+ @noPosargs
+ def to_lower_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.lower()
+
+ @noKwargs
+ @noPosargs
+ def to_upper_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return self.held_object.upper()
+
+ @noKwargs
+ @noPosargs
+ def underscorify_method(self, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> str:
+ return re.sub(r'[^a-zA-Z0-9]', '_', self.held_object)
+
+ @noKwargs
+ @typed_pos_args('str.version_compare', str)
+ def version_compare_method(self, args: T.Tuple[str], kwargs: TYPE_kwargs) -> bool:
+ return version_compare(self.held_object, args[0])
+
+ @FeatureNew('/ with string arguments', '0.49.0')
+ @typed_operator(MesonOperator.DIV, str)
+ def op_div(self, other: str) -> str:
+ return os.path.join(self.held_object, other).replace('\\', '/')
+
+ @typed_operator(MesonOperator.INDEX, int)
+ def op_index(self, other: int) -> str:
+ try:
+ return self.held_object[other]
+ except IndexError:
+ raise InvalidArguments(f'Index {other} out of bounds of string of size {len(self.held_object)}.')
+
+
+class MesonVersionString(str):
+ pass
+
+class MesonVersionStringHolder(StringHolder):
+ @noKwargs
+ @typed_pos_args('str.version_compare', str)
+ def version_compare_method(self, args: T.Tuple[str], kwargs: TYPE_kwargs) -> bool:
+ self.interpreter.tmp_meson_version = args[0]
+ return version_compare(self.held_object, args[0])
diff -Nru meson-0.53.2/mesonbuild/interpreter/type_checking.py meson-0.61.2/mesonbuild/interpreter/type_checking.py
--- meson-0.53.2/mesonbuild/interpreter/type_checking.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter/type_checking.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,310 @@
+# SPDX-License-Identifier: Apache-2.0
+# Copyright © 2021 Intel Corporation
+
+"""Helpers for strict type checking."""
+
+import typing as T
+
+from .. import compilers
+from ..build import EnvironmentVariables, CustomTarget, BuildTarget, CustomTargetIndex, ExtractedObjects, GeneratedList, IncludeDirs
+from ..coredata import UserFeatureOption
+from ..interpreterbase import TYPE_var
+from ..interpreterbase.decorators import KwargInfo, ContainerTypeInfo
+from ..mesonlib import File, FileMode, MachineChoice, listify, has_path_sep, OptionKey
+from ..programs import ExternalProgram
+
+# Helper definition for type checks that are `Optional[T]`
+NoneType: T.Type[None] = type(None)
+
+
+def in_set_validator(choices: T.Set[str]) -> T.Callable[[str], T.Optional[str]]:
+ """Check that the choice given was one of the given set."""
+
+ def inner(check: str) -> T.Optional[str]:
+ if check not in choices:
+ return f"must be one of {', '.join(sorted(choices))}, not {check}"
+ return None
+
+ return inner
+
+
+def _language_validator(l: T.List[str]) -> T.Optional[str]:
+ """Validate language keyword argument.
+
+ Particularly for functions like `add_compiler()`, and `add_*_args()`
+ """
+ diff = {a.lower() for a in l}.difference(compilers.all_languages)
+ if diff:
+ return f'unknown languages: {", ".join(diff)}'
+ return None
+
+
+def _install_mode_validator(mode: T.List[T.Union[str, bool, int]]) -> T.Optional[str]:
+ """Validate the `install_mode` keyword argument.
+
+ This is a rather odd thing, it's a scalar, or an array of 3 values in the form:
+ [(str | False), (str | int | False) = False, (str | int | False) = False]
+ where the second and third components are not required and default to False.
+ """
+ if not mode:
+ return None
+ if True in mode:
+ return 'components can only be permission strings, numbers, or False'
+ if len(mode) > 3:
+ return 'may have at most 3 elements'
+
+ perms = mode[0]
+ if not isinstance(perms, (str, bool)):
+ return 'first component must be a permissions string or False'
+
+ if isinstance(perms, str):
+ if not len(perms) == 9:
+ return ('permissions string must be exactly 9 characters in the form rwxr-xr-x,'
+ f' got {len(perms)}')
+ for i in [0, 3, 6]:
+ if perms[i] not in {'-', 'r'}:
+ return f'permissions character {i+1} must be "-" or "r", not {perms[i]}'
+ for i in [1, 4, 7]:
+ if perms[i] not in {'-', 'w'}:
+ return f'permissions character {i+1} must be "-" or "w", not {perms[i]}'
+ for i in [2, 5]:
+ if perms[i] not in {'-', 'x', 's', 'S'}:
+ return f'permissions character {i+1} must be "-", "s", "S", or "x", not {perms[i]}'
+ if perms[8] not in {'-', 'x', 't', 'T'}:
+ return f'permission character 9 must be "-", "t", "T", or "x", not {perms[8]}'
+
+ if len(mode) >= 2 and not isinstance(mode[1], (int, str, bool)):
+ return 'second componenent can only be a string, number, or False'
+ if len(mode) >= 3 and not isinstance(mode[2], (int, str, bool)):
+ return 'third componenent can only be a string, number, or False'
+
+ return None
+
+
+def _install_mode_convertor(mode: T.Optional[T.List[T.Union[str, bool, int]]]) -> FileMode:
+ """Convert the DSL form of the `install_mode` keyword argument to `FileMode`
+
+ This is not required, and if not required returns None
+
+ TODO: It's not clear to me why this needs to be None and not just return an
+ empty FileMode.
+ """
+ # this has already been validated by the validator
+ return FileMode(*(m if isinstance(m, str) else None for m in mode))
+
+
+def _lower_strlist(input: T.List[str]) -> T.List[str]:
+ """Lower a list of strings.
+
+ mypy (but not pyright) gets confused about using a lambda as the convertor function
+ """
+ return [i.lower() for i in input]
+
+
+NATIVE_KW = KwargInfo(
+ 'native', bool,
+ default=False,
+ convertor=lambda n: MachineChoice.BUILD if n else MachineChoice.HOST)
+
+LANGUAGE_KW = KwargInfo(
+ 'language', ContainerTypeInfo(list, str, allow_empty=False),
+ listify=True,
+ required=True,
+ validator=_language_validator,
+ convertor=_lower_strlist)
+
+INSTALL_MODE_KW: KwargInfo[T.List[T.Union[str, bool, int]]] = KwargInfo(
+ 'install_mode',
+ ContainerTypeInfo(list, (str, bool, int)),
+ listify=True,
+ default=[],
+ validator=_install_mode_validator,
+ convertor=_install_mode_convertor,
+)
+
+REQUIRED_KW: KwargInfo[T.Union[bool, UserFeatureOption]] = KwargInfo(
+ 'required',
+ (bool, UserFeatureOption),
+ default=True,
+ # TODO: extract_required_kwarg could be converted to a convertor
+)
+
+DISABLER_KW: KwargInfo[bool] = KwargInfo('disabler', bool, default=False)
+
+def _env_validator(value: T.Union[EnvironmentVariables, T.List['TYPE_var'], T.Dict[str, 'TYPE_var'], str, None]) -> T.Optional[str]:
+ def _splitter(v: str) -> T.Optional[str]:
+ split = v.split('=', 1)
+ if len(split) == 1:
+ return f'"{v}" is not two string values separated by an "="'
+ return None
+
+ if isinstance(value, str):
+ v = _splitter(value)
+ if v is not None:
+ return v
+ elif isinstance(value, list):
+ for i in listify(value):
+ if not isinstance(i, str):
+ return f"All array elements must be a string, not {i!r}"
+ v = _splitter(i)
+ if v is not None:
+ return v
+ elif isinstance(value, dict):
+ # We don't need to spilt here, just do the type checking
+ for k, dv in value.items():
+ if not isinstance(dv, str):
+ return f"Dictionary element {k} must be a string not {dv!r}"
+ # We know that otherwise we have an EnvironmentVariables object or None, and
+ # we're okay at this point
+ return None
+
+
+def split_equal_string(input: str) -> T.Tuple[str, str]:
+ """Split a string in the form `x=y`
+
+ This assumes that the string has already been validated to split properly.
+ """
+ a, b = input.split('=', 1)
+ return (a, b)
+
+
+def _env_convertor(value: T.Union[EnvironmentVariables, T.List[str], T.List[T.List[str]], T.Dict[str, str], str, None]) -> EnvironmentVariables:
+ if isinstance(value, str):
+ return EnvironmentVariables(dict([split_equal_string(value)]))
+ elif isinstance(value, list):
+ return EnvironmentVariables(dict(split_equal_string(v) for v in listify(value)))
+ elif isinstance(value, dict):
+ return EnvironmentVariables(value)
+ elif value is None:
+ return EnvironmentVariables()
+ return value
+
+
+ENV_KW: KwargInfo[T.Union[EnvironmentVariables, T.List, T.Dict, str, None]] = KwargInfo(
+ 'env',
+ (EnvironmentVariables, list, dict, str, NoneType),
+ validator=_env_validator,
+ convertor=_env_convertor,
+)
+
+DEPFILE_KW: KwargInfo[T.Optional[str]] = KwargInfo(
+ 'depfile',
+ (str, type(None)),
+ validator=lambda x: 'Depfile must be a plain filename with a subdirectory' if has_path_sep(x) else None
+)
+
+# TODO: CustomTargetIndex should be supported here as well
+DEPENDS_KW: KwargInfo[T.List[T.Union[BuildTarget, CustomTarget]]] = KwargInfo(
+ 'depends',
+ ContainerTypeInfo(list, (BuildTarget, CustomTarget)),
+ listify=True,
+ default=[],
+)
+
+DEPEND_FILES_KW: KwargInfo[T.List[T.Union[str, File]]] = KwargInfo(
+ 'depend_files',
+ ContainerTypeInfo(list, (File, str)),
+ listify=True,
+ default=[],
+)
+
+COMMAND_KW: KwargInfo[T.List[T.Union[str, BuildTarget, CustomTarget, CustomTargetIndex, ExternalProgram, File]]] = KwargInfo(
+ 'command',
+ # TODO: should accept CustomTargetIndex as well?
+ ContainerTypeInfo(list, (str, BuildTarget, CustomTarget, CustomTargetIndex, ExternalProgram, File), allow_empty=False),
+ required=True,
+ listify=True,
+ default=[],
+)
+
+def _override_options_convertor(raw: T.List[str]) -> T.Dict[OptionKey, str]:
+ output: T.Dict[OptionKey, str] = {}
+ for each in raw:
+ k, v = split_equal_string(each)
+ output[OptionKey.from_string(k)] = v
+ return output
+
+
+OVERRIDE_OPTIONS_KW: KwargInfo[T.List[str]] = KwargInfo(
+ 'override_options',
+ ContainerTypeInfo(list, str),
+ listify=True,
+ default=[],
+ # Reusing the env validator is a littl overkill, but nicer than duplicating the code
+ validator=_env_validator,
+ convertor=_override_options_convertor,
+)
+
+
+def _output_validator(outputs: T.List[str]) -> T.Optional[str]:
+ for i in outputs:
+ if i == '':
+ return 'Output must not be empty.'
+ elif i.strip() == '':
+ return 'Output must not consist only of whitespace.'
+ elif has_path_sep(i):
+ return f'Output {i!r} must not contain a path segment.'
+
+ return None
+
+CT_OUTPUT_KW: KwargInfo[T.List[str]] = KwargInfo(
+ 'output',
+ ContainerTypeInfo(list, str, allow_empty=False),
+ listify=True,
+ required=True,
+ default=[],
+ validator=_output_validator,
+)
+
+CT_INPUT_KW: KwargInfo[T.List[T.Union[str, File, ExternalProgram, BuildTarget, CustomTarget, CustomTargetIndex, ExtractedObjects, GeneratedList]]] = KwargInfo(
+ 'input',
+ ContainerTypeInfo(list, (str, File, ExternalProgram, BuildTarget, CustomTarget, CustomTargetIndex, ExtractedObjects, GeneratedList)),
+ listify=True,
+ default=[],
+)
+
+CT_INSTALL_TAG_KW: KwargInfo[T.List[T.Union[str, bool]]] = KwargInfo(
+ 'install_tag',
+ ContainerTypeInfo(list, (str, bool)),
+ listify=True,
+ default=[],
+ since='0.60.0',
+)
+
+INSTALL_KW = KwargInfo('install', bool, default=False)
+
+CT_INSTALL_DIR_KW: KwargInfo[T.List[T.Union[str, bool]]] = KwargInfo(
+ 'install_dir',
+ ContainerTypeInfo(list, (str, bool)),
+ listify=True,
+ default=[],
+)
+
+CT_BUILD_BY_DEFAULT: KwargInfo[T.Optional[bool]] = KwargInfo('build_by_default', (bool, type(None)), since='0.40.0')
+
+CT_BUILD_ALWAYS: KwargInfo[T.Optional[bool]] = KwargInfo(
+ 'build_always', (bool, NoneType),
+ deprecated='0.47.0',
+ deprecated_message='combine build_by_default and build_always_stale instead.',
+)
+
+CT_BUILD_ALWAYS_STALE: KwargInfo[T.Optional[bool]] = KwargInfo(
+ 'build_always_stale', (bool, NoneType),
+ since='0.47.0',
+)
+
+INCLUDE_DIRECTORIES: KwargInfo[T.List[T.Union[str, IncludeDirs]]] = KwargInfo(
+ 'include_dirs',
+ ContainerTypeInfo(list, (str, IncludeDirs)),
+ listify=True,
+ default=[],
+)
+
+# for cases like default_options and override_options
+DEFAULT_OPTIONS: KwargInfo[T.List[str]] = KwargInfo(
+ 'default_options',
+ ContainerTypeInfo(list, (str, IncludeDirs)),
+ listify=True,
+ default=[],
+ validator=_env_validator,
+)
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/baseobjects.py meson-0.61.2/mesonbuild/interpreterbase/baseobjects.py
--- meson-0.53.2/mesonbuild/interpreterbase/baseobjects.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/baseobjects.py 2021-11-02 19:58:13.000000000 +0000
@@ -0,0 +1,179 @@
+# 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 .. import mparser
+from .exceptions import InvalidCode, InvalidArguments
+from .helpers import flatten, resolve_second_level_holders
+from .operator import MesonOperator
+from ..mesonlib import HoldableObject, MesonBugException
+import textwrap
+
+import typing as T
+from abc import ABCMeta
+
+if T.TYPE_CHECKING:
+ # Object holders need the actual interpreter
+ from ..interpreter import Interpreter
+
+TV_fw_var = T.Union[str, int, bool, list, dict, 'InterpreterObject']
+TV_fw_args = T.List[T.Union[mparser.BaseNode, TV_fw_var]]
+TV_fw_kwargs = T.Dict[str, T.Union[mparser.BaseNode, TV_fw_var]]
+
+TV_func = T.TypeVar('TV_func', bound=T.Callable[..., T.Any])
+
+TYPE_elementary = T.Union[str, int, bool, T.List[T.Any], T.Dict[str, T.Any]]
+TYPE_var = T.Union[TYPE_elementary, HoldableObject, 'MesonInterpreterObject']
+TYPE_nvar = T.Union[TYPE_var, mparser.BaseNode]
+TYPE_kwargs = T.Dict[str, TYPE_var]
+TYPE_nkwargs = T.Dict[str, TYPE_nvar]
+TYPE_key_resolver = T.Callable[[mparser.BaseNode], str]
+
+if T.TYPE_CHECKING:
+ from typing_extensions import Protocol
+ __T = T.TypeVar('__T', bound=TYPE_var, contravariant=True)
+
+ class OperatorCall(Protocol[__T]):
+ def __call__(self, other: __T) -> TYPE_var: ...
+
+class InterpreterObject:
+ def __init__(self, *, subproject: T.Optional[str] = None) -> None:
+ self.methods: T.Dict[
+ str,
+ T.Callable[[T.List[TYPE_var], TYPE_kwargs], TYPE_var]
+ ] = {}
+ self.operators: T.Dict[MesonOperator, 'OperatorCall'] = {}
+ self.trivial_operators: T.Dict[
+ MesonOperator,
+ T.Tuple[
+ T.Union[T.Type, T.Tuple[T.Type, ...]],
+ 'OperatorCall'
+ ]
+ ] = {}
+ # Current node set during a method call. This can be used as location
+ # when printing a warning message during a method call.
+ self.current_node: mparser.BaseNode = None
+ self.subproject: str = subproject or ''
+
+ # Some default operators supported by all objects
+ self.operators.update({
+ MesonOperator.EQUALS: self.op_equals,
+ MesonOperator.NOT_EQUALS: self.op_not_equals,
+ })
+
+ # The type of the object that can be printed to the user
+ def display_name(self) -> str:
+ return type(self).__name__
+
+ def method_call(
+ self,
+ method_name: str,
+ args: T.List[TYPE_var],
+ kwargs: TYPE_kwargs
+ ) -> TYPE_var:
+ if method_name in self.methods:
+ method = self.methods[method_name]
+ if not getattr(method, 'no-args-flattening', False):
+ args = flatten(args)
+ if not getattr(method, 'no-second-level-holder-flattening', False):
+ args, kwargs = resolve_second_level_holders(args, kwargs)
+ return method(args, kwargs)
+ raise InvalidCode(f'Unknown method "{method_name}" in object {self} of type {type(self).__name__}.')
+
+ def operator_call(self, operator: MesonOperator, other: TYPE_var) -> TYPE_var:
+ if operator in self.trivial_operators:
+ op = self.trivial_operators[operator]
+ if op[0] is None and other is not None:
+ raise MesonBugException(f'The unary operator `{operator.value}` of {self.display_name()} was passed the object {other} of type {type(other).__name__}')
+ if op[0] is not None and not isinstance(other, op[0]):
+ raise InvalidArguments(f'The `{operator.value}` operator of {self.display_name()} does not accept objects of type {type(other).__name__} ({other})')
+ return op[1](other)
+ if operator in self.operators:
+ return self.operators[operator](other)
+ raise InvalidCode(f'Object {self} of type {self.display_name()} does not support the `{operator.value}` operator.')
+
+ # Default comparison operator support
+ def _throw_comp_exception(self, other: TYPE_var, opt_type: str) -> T.NoReturn:
+ raise InvalidArguments(textwrap.dedent(
+ f'''
+ Trying to compare values of different types ({self.display_name()}, {type(other).__name__}) using {opt_type}.
+ This was deprecated and undefined behavior previously and is as of 0.60.0 a hard error.
+ '''
+ ))
+
+ def op_equals(self, other: TYPE_var) -> bool:
+ # We use `type(...) == type(...)` here to enforce an *exact* match for comparison. We
+ # don't want comparisons to be possible where `isinstance(derived_obj, type(base_obj))`
+ # would pass because this comparison must never be true: `derived_obj == base_obj`
+ if type(self) != type(other):
+ self._throw_comp_exception(other, '==')
+ return self == other
+
+ def op_not_equals(self, other: TYPE_var) -> bool:
+ if type(self) != type(other):
+ self._throw_comp_exception(other, '!=')
+ return self != other
+
+class MesonInterpreterObject(InterpreterObject):
+ ''' All non-elementary objects and non-object-holders should be derived from this '''
+
+class MutableInterpreterObject:
+ ''' Dummy class to mark the object type as mutable '''
+
+HoldableTypes = (HoldableObject, int, bool, str, list, dict)
+TYPE_HoldableTypes = T.Union[TYPE_elementary, HoldableObject]
+InterpreterObjectTypeVar = T.TypeVar('InterpreterObjectTypeVar', bound=TYPE_HoldableTypes)
+
+class ObjectHolder(InterpreterObject, T.Generic[InterpreterObjectTypeVar]):
+ def __init__(self, obj: InterpreterObjectTypeVar, interpreter: 'Interpreter') -> None:
+ super().__init__(subproject=interpreter.subproject)
+ # This causes some type checkers to assume that obj is a base
+ # HoldableObject, not the specialized type, so only do this assert in
+ # non-type checking situations
+ if not T.TYPE_CHECKING:
+ assert isinstance(obj, HoldableTypes), f'This is a bug: Trying to hold object of type `{type(obj).__name__}` that is not in `{HoldableTypes}`'
+ self.held_object = obj
+ self.interpreter = interpreter
+ self.env = self.interpreter.environment
+
+ # Hide the object holder abstraction from the user
+ def display_name(self) -> str:
+ return type(self.held_object).__name__
+
+ # Override default comparison operators for the held object
+ def op_equals(self, other: TYPE_var) -> bool:
+ # See the comment from InterpreterObject why we are using `type()` here.
+ if type(self.held_object) != type(other):
+ self._throw_comp_exception(other, '==')
+ return self.held_object == other
+
+ def op_not_equals(self, other: TYPE_var) -> bool:
+ if type(self.held_object) != type(other):
+ self._throw_comp_exception(other, '!=')
+ return self.held_object != other
+
+ def __repr__(self) -> str:
+ return f'<[{type(self).__name__}] holds [{type(self.held_object).__name__}]: {self.held_object!r}>'
+
+class IterableObject(metaclass=ABCMeta):
+ '''Base class for all objects that can be iterated over in a foreach loop'''
+
+ def iter_tuple_size(self) -> T.Optional[int]:
+ '''Return the size of the tuple for each iteration. Returns None if only a single value is returned.'''
+ raise MesonBugException(f'iter_tuple_size not implemented for {self.__class__.__name__}')
+
+ def iter_self(self) -> T.Iterator[T.Union[TYPE_var, T.Tuple[TYPE_var, ...]]]:
+ raise MesonBugException(f'iter not implemented for {self.__class__.__name__}')
+
+ def size(self) -> int:
+ raise MesonBugException(f'size not implemented for {self.__class__.__name__}')
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/decorators.py meson-0.61.2/mesonbuild/interpreterbase/decorators.py
--- meson-0.53.2/mesonbuild/interpreterbase/decorators.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/decorators.py 2022-01-17 10:50:45.000000000 +0000
@@ -0,0 +1,775 @@
+# 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 .. import mesonlib, mlog
+from .baseobjects import TV_func, TYPE_var, TYPE_kwargs
+from .disabler import Disabler
+from .exceptions import InterpreterException, InvalidArguments
+from .operator import MesonOperator
+from ._unholder import _unholder
+
+from functools import wraps
+import abc
+import itertools
+import copy
+import typing as T
+if T.TYPE_CHECKING:
+ from .. import mparser
+
+def get_callee_args(wrapped_args: T.Sequence[T.Any]) -> T.Tuple['mparser.BaseNode', T.List['TYPE_var'], 'TYPE_kwargs', str]:
+ # First argument could be InterpreterBase, InterpreterObject or ModuleObject.
+ # In the case of a ModuleObject it is the 2nd argument (ModuleState) that
+ # contains the needed information.
+ s = wrapped_args[0]
+ if not hasattr(s, 'current_node'):
+ s = wrapped_args[1]
+ node = s.current_node
+ subproject = s.subproject
+ args = kwargs = None
+ if len(wrapped_args) >= 3:
+ args = wrapped_args[-2]
+ kwargs = wrapped_args[-1]
+ return node, args, kwargs, subproject
+
+def noPosargs(f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ args = get_callee_args(wrapped_args)[1]
+ if args:
+ raise InvalidArguments('Function does not take positional arguments.')
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapped)
+
+def noKwargs(f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ kwargs = get_callee_args(wrapped_args)[2]
+ if kwargs:
+ raise InvalidArguments('Function does not take keyword arguments.')
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapped)
+
+def stringArgs(f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ args = get_callee_args(wrapped_args)[1]
+ if not isinstance(args, list):
+ mlog.debug('Not a list:', str(args))
+ raise InvalidArguments('Argument not a list.')
+ if not all(isinstance(s, str) for s in args):
+ mlog.debug('Element not a string:', str(args))
+ raise InvalidArguments('Arguments must be strings.')
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapped)
+
+def noArgsFlattening(f: TV_func) -> TV_func:
+ setattr(f, 'no-args-flattening', True) # noqa: B010
+ return f
+
+def noSecondLevelHolderResolving(f: TV_func) -> TV_func:
+ setattr(f, 'no-second-level-holder-flattening', True) # noqa: B010
+ return f
+
+def unholder_return(f: TV_func) -> T.Callable[..., TYPE_var]:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ res = f(*wrapped_args, **wrapped_kwargs)
+ return _unholder(res)
+ return T.cast(T.Callable[..., TYPE_var], wrapped)
+
+def disablerIfNotFound(f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ kwargs = get_callee_args(wrapped_args)[2]
+ disabler = kwargs.pop('disabler', False)
+ ret = f(*wrapped_args, **wrapped_kwargs)
+ if disabler and not ret.found():
+ return Disabler()
+ return ret
+ return T.cast(TV_func, wrapped)
+
+class permittedKwargs:
+
+ def __init__(self, permitted: T.Set[str]):
+ self.permitted = permitted # type: T.Set[str]
+
+ def __call__(self, f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ kwargs = get_callee_args(wrapped_args)[2]
+ unknowns = set(kwargs).difference(self.permitted)
+ if unknowns:
+ ustr = ', '.join([f'"{u}"' for u in sorted(unknowns)])
+ raise InvalidArguments(f'Got unknown keyword arguments {ustr}')
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapped)
+
+if T.TYPE_CHECKING:
+ from .baseobjects import InterpreterObject
+ from typing_extensions import Protocol
+
+ _TV_IntegerObject = T.TypeVar('_TV_IntegerObject', bound=InterpreterObject, contravariant=True)
+ _TV_ARG1 = T.TypeVar('_TV_ARG1', bound=TYPE_var, contravariant=True)
+
+ class FN_Operator(Protocol[_TV_IntegerObject, _TV_ARG1]):
+ def __call__(s, self: _TV_IntegerObject, other: _TV_ARG1) -> TYPE_var: ...
+ _TV_FN_Operator = T.TypeVar('_TV_FN_Operator', bound=FN_Operator)
+
+def typed_operator(operator: MesonOperator,
+ types: T.Union[T.Type, T.Tuple[T.Type, ...]]) -> T.Callable[['_TV_FN_Operator'], '_TV_FN_Operator']:
+ """Decorator that does type checking for operator calls.
+
+ The principle here is similar to typed_pos_args, however much simpler
+ since only one other object ever is passed
+ """
+ def inner(f: '_TV_FN_Operator') -> '_TV_FN_Operator':
+ @wraps(f)
+ def wrapper(self: 'InterpreterObject', other: TYPE_var) -> TYPE_var:
+ if not isinstance(other, types):
+ raise InvalidArguments(f'The `{operator.value}` of {self.display_name()} does not accept objects of type {type(other).__name__} ({other})')
+ return f(self, other)
+ return T.cast('_TV_FN_Operator', wrapper)
+ return inner
+
+def unary_operator(operator: MesonOperator) -> T.Callable[['_TV_FN_Operator'], '_TV_FN_Operator']:
+ """Decorator that does type checking for unary operator calls.
+
+ This decorator is for unary operators that do not take any other objects.
+ It should be impossible for a user to accidentally break this. Triggering
+ this check always indicates a bug in the Meson interpreter.
+ """
+ def inner(f: '_TV_FN_Operator') -> '_TV_FN_Operator':
+ @wraps(f)
+ def wrapper(self: 'InterpreterObject', other: TYPE_var) -> TYPE_var:
+ if other is not None:
+ raise mesonlib.MesonBugException(f'The unary operator `{operator.value}` of {self.display_name()} was passed the object {other} of type {type(other).__name__}')
+ return f(self, other)
+ return T.cast('_TV_FN_Operator', wrapper)
+ return inner
+
+
+def typed_pos_args(name: str, *types: T.Union[T.Type, T.Tuple[T.Type, ...]],
+ varargs: T.Optional[T.Union[T.Type, T.Tuple[T.Type, ...]]] = None,
+ optargs: T.Optional[T.List[T.Union[T.Type, T.Tuple[T.Type, ...]]]] = None,
+ min_varargs: int = 0, max_varargs: int = 0) -> T.Callable[..., T.Any]:
+ """Decorator that types type checking of positional arguments.
+
+ This supports two different models of optional arguments, the first is the
+ variadic argument model. Variadic arguments are a possibly bounded,
+ possibly unbounded number of arguments of the same type (unions are
+ supported). The second is the standard default value model, in this case
+ a number of optional arguments may be provided, but they are still
+ ordered, and they may have different types.
+
+ This function does not support mixing variadic and default arguments.
+
+ :name: The name of the decorated function (as displayed in error messages)
+ :varargs: They type(s) of any variadic arguments the function takes. If
+ None the function takes no variadic args
+ :min_varargs: the minimum number of variadic arguments taken
+ :max_varargs: the maximum number of variadic arguments taken. 0 means unlimited
+ :optargs: The types of any optional arguments parameters taken. If None
+ then no optional parameters are taken.
+
+ Some examples of usage blow:
+ >>> @typed_pos_args('mod.func', str, (str, int))
+ ... def func(self, state: ModuleState, args: T.Tuple[str, T.Union[str, int]], kwargs: T.Dict[str, T.Any]) -> T.Any:
+ ... pass
+
+ >>> @typed_pos_args('method', str, varargs=str)
+ ... def method(self, node: BaseNode, args: T.Tuple[str, T.List[str]], kwargs: T.Dict[str, T.Any]) -> T.Any:
+ ... pass
+
+ >>> @typed_pos_args('method', varargs=str, min_varargs=1)
+ ... def method(self, node: BaseNode, args: T.Tuple[T.List[str]], kwargs: T.Dict[str, T.Any]) -> T.Any:
+ ... pass
+
+ >>> @typed_pos_args('method', str, optargs=[(str, int), str])
+ ... def method(self, node: BaseNode, args: T.Tuple[str, T.Optional[T.Union[str, int]], T.Optional[str]], kwargs: T.Dict[str, T.Any]) -> T.Any:
+ ... pass
+
+ When should you chose `typed_pos_args('name', varargs=str,
+ min_varargs=1)` vs `typed_pos_args('name', str, varargs=str)`?
+
+ The answer has to do with the semantics of the function, if all of the
+ inputs are the same type (such as with `files()`) then the former is
+ correct, all of the arguments are string names of files. If the first
+ argument is something else the it should be separated.
+ """
+ def inner(f: TV_func) -> TV_func:
+
+ @wraps(f)
+ def wrapper(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ args = get_callee_args(wrapped_args)[1]
+
+ # These are implementation programming errors, end users should never see them.
+ assert isinstance(args, list), args
+ assert max_varargs >= 0, 'max_varags cannot be negative'
+ assert min_varargs >= 0, 'min_varags cannot be negative'
+ assert optargs is None or varargs is None, \
+ 'varargs and optargs not supported together as this would be ambiguous'
+
+ num_args = len(args)
+ num_types = len(types)
+ a_types = types
+
+ if varargs:
+ min_args = num_types + min_varargs
+ max_args = num_types + max_varargs
+ if max_varargs == 0 and num_args < min_args:
+ raise InvalidArguments(f'{name} takes at least {min_args} arguments, but got {num_args}.')
+ elif max_varargs != 0 and (num_args < min_args or num_args > max_args):
+ raise InvalidArguments(f'{name} takes between {min_args} and {max_args} arguments, but got {num_args}.')
+ elif optargs:
+ if num_args < num_types:
+ raise InvalidArguments(f'{name} takes at least {num_types} arguments, but got {num_args}.')
+ elif num_args > num_types + len(optargs):
+ raise InvalidArguments(f'{name} takes at most {num_types + len(optargs)} arguments, but got {num_args}.')
+ # Add the number of positional arguments required
+ if num_args > num_types:
+ diff = num_args - num_types
+ a_types = tuple(list(types) + list(optargs[:diff]))
+ elif num_args != num_types:
+ raise InvalidArguments(f'{name} takes exactly {num_types} arguments, but got {num_args}.')
+
+ for i, (arg, type_) in enumerate(itertools.zip_longest(args, a_types, fillvalue=varargs), start=1):
+ if not isinstance(arg, type_):
+ if isinstance(type_, tuple):
+ shouldbe = 'one of: {}'.format(", ".join(f'"{t.__name__}"' for t in type_))
+ else:
+ shouldbe = f'"{type_.__name__}"'
+ raise InvalidArguments(f'{name} argument {i} was of type "{type(arg).__name__}" but should have been {shouldbe}')
+
+ # Ensure that we're actually passing a tuple.
+ # Depending on what kind of function we're calling the length of
+ # wrapped_args can vary.
+ nargs = list(wrapped_args)
+ i = nargs.index(args)
+ if varargs:
+ # if we have varargs we need to split them into a separate
+ # tuple, as python's typing doesn't understand tuples with
+ # fixed elements and variadic elements, only one or the other.
+ # so in that case we need T.Tuple[int, str, float, T.Tuple[str, ...]]
+ pos = args[:len(types)]
+ var = list(args[len(types):])
+ pos.append(var)
+ nargs[i] = tuple(pos)
+ elif optargs:
+ if num_args < num_types + len(optargs):
+ diff = num_types + len(optargs) - num_args
+ nargs[i] = tuple(list(args) + [None] * diff)
+ else:
+ nargs[i] = args
+ else:
+ nargs[i] = tuple(args)
+ return f(*nargs, **wrapped_kwargs)
+
+ return T.cast(TV_func, wrapper)
+ return inner
+
+
+class ContainerTypeInfo:
+
+ """Container information for keyword arguments.
+
+ For keyword arguments that are containers (list or dict), this class encodes
+ that information.
+
+ :param container: the type of container
+ :param contains: the types the container holds
+ :param pairs: if the container is supposed to be of even length.
+ This is mainly used for interfaces that predate the addition of dictionaries, and use
+ `[key, value, key2, value2]` format.
+ :param allow_empty: Whether this container is allowed to be empty
+ There are some cases where containers not only must be passed, but must
+ not be empty, and other cases where an empty container is allowed.
+ """
+
+ def __init__(self, container: T.Type, contains: T.Union[T.Type, T.Tuple[T.Type, ...]], *,
+ pairs: bool = False, allow_empty: bool = True):
+ self.container = container
+ self.contains = contains
+ self.pairs = pairs
+ self.allow_empty = allow_empty
+
+ def check(self, value: T.Any) -> bool:
+ """Check that a value is valid.
+
+ :param value: A value to check
+ :return: True if it is valid, False otherwise
+ """
+ if not isinstance(value, self.container):
+ return False
+ iter_ = iter(value.values()) if isinstance(value, dict) else iter(value)
+ for each in iter_:
+ if not isinstance(each, self.contains):
+ return False
+ if self.pairs and len(value) % 2 != 0:
+ return False
+ if not value and not self.allow_empty:
+ return False
+ return True
+
+ def description(self) -> str:
+ """Human readable description of this container type.
+
+ :return: string to be printed
+ """
+ container = 'dict' if self.container is dict else 'array'
+ if isinstance(self.contains, tuple):
+ contains = ' | '.join([t.__name__ for t in self.contains])
+ else:
+ contains = self.contains.__name__
+ s = f'{container}[{contains}]'
+ if self.pairs:
+ s += ' that has even size'
+ if not self.allow_empty:
+ s += ' that cannot be empty'
+ return s
+
+_T = T.TypeVar('_T')
+
+class _NULL_T:
+ """Special null type for evolution, this is an implementation detail."""
+
+
+_NULL = _NULL_T()
+
+class KwargInfo(T.Generic[_T]):
+
+ """A description of a keyword argument to a meson function
+
+ This is used to describe a value to the :func:typed_kwargs function.
+
+ :param name: the name of the parameter
+ :param types: A type or tuple of types that are allowed, or a :class:ContainerType
+ :param required: Whether this is a required keyword argument. defaults to False
+ :param listify: If true, then the argument will be listified before being
+ checked. This is useful for cases where the Meson DSL allows a scalar or
+ a container, but internally we only want to work with containers
+ :param default: A default value to use if this isn't set. defaults to None,
+ this may be safely set to a mutable type, as long as that type does not
+ itself contain mutable types, typed_kwargs will copy the default
+ :param since: Meson version in which this argument has been added. defaults to None
+ :param since_message: An extra message to pass to FeatureNew when since is triggered
+ :param deprecated: Meson version in which this argument has been deprecated. defaults to None
+ :param deprecated_message: An extra message to pass to FeatureDeprecated
+ when since is triggered
+ :param validator: A callable that does additional validation. This is mainly
+ intended for cases where a string is expected, but only a few specific
+ values are accepted. Must return None if the input is valid, or a
+ message if the input is invalid
+ :param convertor: A callable that converts the raw input value into a
+ different type. This is intended for cases such as the meson DSL using a
+ string, but the implementation using an Enum. This should not do
+ validation, just conversion.
+ :param deprecated_values: a dictionary mapping a value to the version of
+ meson it was deprecated in. The Value may be any valid value for this
+ argument.
+ :param since_values: a dictionary mapping a value to the version of meson it was
+ added in.
+ :param not_set_warning: A warning message that is logged if the kwarg is not
+ set by the user.
+ """
+ def __init__(self, name: str,
+ types: T.Union[T.Type[_T], T.Tuple[T.Union[T.Type[_T], ContainerTypeInfo], ...], ContainerTypeInfo],
+ *, required: bool = False, listify: bool = False,
+ default: T.Optional[_T] = None,
+ since: T.Optional[str] = None,
+ since_message: T.Optional[str] = None,
+ since_values: T.Optional[T.Dict[_T, T.Union[str, T.Tuple[str, str]]]] = None,
+ deprecated: T.Optional[str] = None,
+ deprecated_message: T.Optional[str] = None,
+ deprecated_values: T.Optional[T.Dict[_T, T.Union[str, T.Tuple[str, str]]]] = None,
+ validator: T.Optional[T.Callable[[T.Any], T.Optional[str]]] = None,
+ convertor: T.Optional[T.Callable[[_T], object]] = None,
+ not_set_warning: T.Optional[str] = None):
+ self.name = name
+ self.types = types
+ self.required = required
+ self.listify = listify
+ self.default = default
+ self.since = since
+ self.since_message = since_message
+ self.since_values = since_values
+ self.deprecated = deprecated
+ self.deprecated_message = deprecated_message
+ self.deprecated_values = deprecated_values
+ self.validator = validator
+ self.convertor = convertor
+ self.not_set_warning = not_set_warning
+
+ def evolve(self, *,
+ name: T.Union[str, _NULL_T] = _NULL,
+ required: T.Union[bool, _NULL_T] = _NULL,
+ listify: T.Union[bool, _NULL_T] = _NULL,
+ default: T.Union[_T, None, _NULL_T] = _NULL,
+ since: T.Union[str, None, _NULL_T] = _NULL,
+ since_message: T.Union[str, None, _NULL_T] = _NULL,
+ since_values: T.Union[T.Dict[_T, T.Union[str, T.Tuple[str, str]]], None, _NULL_T] = _NULL,
+ deprecated: T.Union[str, None, _NULL_T] = _NULL,
+ deprecated_message: T.Union[str, None, _NULL_T] = _NULL,
+ deprecated_values: T.Union[T.Dict[_T, T.Union[str, T.Tuple[str, str]]], None, _NULL_T] = _NULL,
+ validator: T.Union[T.Callable[[_T], T.Optional[str]], None, _NULL_T] = _NULL,
+ convertor: T.Union[T.Callable[[_T], TYPE_var], None, _NULL_T] = _NULL) -> 'KwargInfo':
+ """Create a shallow copy of this KwargInfo, with modifications.
+
+ This allows us to create a new copy of a KwargInfo with modifications.
+ This allows us to use a shared kwarg that implements complex logic, but
+ has slight differences in usage, such as being added to different
+ functions in different versions of Meson.
+
+ The use the _NULL special value here allows us to pass None, which has
+ meaning in many of these cases. _NULL itself is never stored, always
+ being replaced by either the copy in self, or the provided new version.
+ """
+ return type(self)(
+ name if not isinstance(name, _NULL_T) else self.name,
+ self.types,
+ listify=listify if not isinstance(listify, _NULL_T) else self.listify,
+ required=required if not isinstance(required, _NULL_T) else self.required,
+ default=default if not isinstance(default, _NULL_T) else self.default,
+ since=since if not isinstance(since, _NULL_T) else self.since,
+ since_message=since_message if not isinstance(since_message, _NULL_T) else self.since_message,
+ since_values=since_values if not isinstance(since_values, _NULL_T) else self.since_values,
+ deprecated=deprecated if not isinstance(deprecated, _NULL_T) else self.deprecated,
+ deprecated_message=deprecated_message if not isinstance(deprecated_message, _NULL_T) else self.deprecated_message,
+ deprecated_values=deprecated_values if not isinstance(deprecated_values, _NULL_T) else self.deprecated_values,
+ validator=validator if not isinstance(validator, _NULL_T) else self.validator,
+ convertor=convertor if not isinstance(convertor, _NULL_T) else self.convertor,
+ )
+
+
+def typed_kwargs(name: str, *types: KwargInfo) -> T.Callable[..., T.Any]:
+ """Decorator for type checking keyword arguments.
+
+ Used to wrap a meson DSL implementation function, where it checks various
+ things about keyword arguments, including the type, and various other
+ information. For non-required values it sets the value to a default, which
+ means the value will always be provided.
+
+ If type tyhpe is a :class:ContainerTypeInfo, then the default value will be
+ passed as an argument to the container initializer, making a shallow copy
+
+ :param name: the name of the function, including the object it's attached to
+ (if applicable)
+ :param *types: KwargInfo entries for each keyword argument.
+ """
+ def inner(f: TV_func) -> TV_func:
+
+ def types_description(types_tuple: T.Tuple[T.Union[T.Type, ContainerTypeInfo], ...]) -> str:
+ candidates = []
+ for t in types_tuple:
+ if isinstance(t, ContainerTypeInfo):
+ candidates.append(t.description())
+ else:
+ candidates.append(t.__name__)
+ shouldbe = 'one of: ' if len(candidates) > 1 else ''
+ shouldbe += ', '.join(candidates)
+ return shouldbe
+
+ def raw_description(t: object) -> str:
+ """describe a raw type (ie, one that is not a ContainerTypeInfo)."""
+ if isinstance(t, list):
+ if t:
+ return f"array[{' | '.join(sorted(mesonlib.OrderedSet(type(v).__name__ for v in t)))}]"
+ return 'array[]'
+ elif isinstance(t, dict):
+ if t:
+ return f"dict[{' | '.join(sorted(mesonlib.OrderedSet(type(v).__name__ for v in t.values())))}]"
+ return 'dict[]'
+ return type(t).__name__
+
+ def check_value_type(types_tuple: T.Tuple[T.Union[T.Type, ContainerTypeInfo], ...],
+ value: T.Any) -> bool:
+ for t in types_tuple:
+ if isinstance(t, ContainerTypeInfo):
+ if t.check(value):
+ return True
+ elif isinstance(value, t):
+ return True
+ return False
+
+ @wraps(f)
+ def wrapper(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+
+ def emit_feature_change(values: T.Dict[str, T.Union[str, T.Tuple[str, str]]], feature: T.Union[T.Type['FeatureDeprecated'], T.Type['FeatureNew']]) -> None:
+ for n, version in values.items():
+ if isinstance(value, (dict, list)):
+ warn = n in value
+ else:
+ warn = n == value
+
+ if warn:
+ if isinstance(version, tuple):
+ version, msg = version
+ else:
+ msg = None
+ feature.single_use(f'"{name}" keyword argument "{info.name}" value "{n}"', version, subproject, msg, location=node)
+
+ node, _, _kwargs, subproject = get_callee_args(wrapped_args)
+ # Cast here, as the convertor function may place something other than a TYPE_var in the kwargs
+ kwargs = T.cast(T.Dict[str, object], _kwargs)
+
+ all_names = {t.name for t in types}
+ unknowns = set(kwargs).difference(all_names)
+ if unknowns:
+ ustr = ', '.join([f'"{u}"' for u in sorted(unknowns)])
+ raise InvalidArguments(f'{name} got unknown keyword arguments {ustr}')
+
+ for info in types:
+ types_tuple = info.types if isinstance(info.types, tuple) else (info.types,)
+ value = kwargs.get(info.name)
+ if value is not None:
+ if info.since:
+ feature_name = info.name + ' arg in ' + name
+ FeatureNew.single_use(feature_name, info.since, subproject, info.since_message, location=node)
+ if info.deprecated:
+ feature_name = info.name + ' arg in ' + name
+ FeatureDeprecated.single_use(feature_name, info.deprecated, subproject, info.deprecated_message, location=node)
+ if info.listify:
+ kwargs[info.name] = value = mesonlib.listify(value)
+ if not check_value_type(types_tuple, value):
+ shouldbe = types_description(types_tuple)
+ raise InvalidArguments(f'{name} keyword argument {info.name!r} was of type {raw_description(value)} but should have been {shouldbe}')
+
+ if info.validator is not None:
+ msg = info.validator(value)
+ if msg is not None:
+ raise InvalidArguments(f'{name} keyword argument "{info.name}" {msg}')
+
+ if info.deprecated_values is not None:
+ emit_feature_change(info.deprecated_values, FeatureDeprecated)
+
+ if info.since_values is not None:
+ emit_feature_change(info.since_values, FeatureNew)
+
+ elif info.required:
+ raise InvalidArguments(f'{name} is missing required keyword argument "{info.name}"')
+ else:
+ # set the value to the default, this ensuring all kwargs are present
+ # This both simplifies the typing checking and the usage
+ assert check_value_type(types_tuple, info.default), f'In funcion {name} default value of {info.name} is not a valid type, got {type(info.default)} expected {types_description(types_tuple)}'
+ # Create a shallow copy of the container. This allows mutable
+ # types to be used safely as default values
+ kwargs[info.name] = copy.copy(info.default)
+ if info.not_set_warning:
+ mlog.warning(info.not_set_warning)
+
+ if info.convertor:
+ kwargs[info.name] = info.convertor(kwargs[info.name])
+
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapper)
+ return inner
+
+
+class FeatureCheckBase(metaclass=abc.ABCMeta):
+ "Base class for feature version checks"
+
+ feature_registry: T.ClassVar[T.Dict[str, T.Dict[str, T.Set[T.Tuple[str, T.Optional['mparser.BaseNode']]]]]]
+ emit_notice = False
+
+ def __init__(self, feature_name: str, feature_version: str, extra_message: str = '', location: T.Optional['mparser.BaseNode'] = None):
+ self.feature_name = feature_name # type: str
+ self.feature_version = feature_version # type: str
+ self.extra_message = extra_message # type: str
+ self.location = location
+
+ @staticmethod
+ def get_target_version(subproject: str) -> str:
+ # Don't do any checks if project() has not been parsed yet
+ if subproject not in mesonlib.project_meson_versions:
+ return ''
+ return mesonlib.project_meson_versions[subproject]
+
+ @staticmethod
+ @abc.abstractmethod
+ def check_version(target_version: str, feature_version: str) -> bool:
+ pass
+
+ def use(self, subproject: str) -> None:
+ tv = self.get_target_version(subproject)
+ # No target version
+ if tv == '':
+ return
+ # Target version is new enough, don't warn
+ if self.check_version(tv, self.feature_version) and not self.emit_notice:
+ return
+ # Feature is too new for target version or we want to emit notices, register it
+ if subproject not in self.feature_registry:
+ self.feature_registry[subproject] = {self.feature_version: set()}
+ register = self.feature_registry[subproject]
+ if self.feature_version not in register:
+ register[self.feature_version] = set()
+
+ feature_key = (self.feature_name, self.location)
+ if feature_key in register[self.feature_version]:
+ # Don't warn about the same feature multiple times
+ # FIXME: This is needed to prevent duplicate warnings, but also
+ # means we won't warn about a feature used in multiple places.
+ return
+ register[self.feature_version].add(feature_key)
+ # Target version is new enough, don't warn even if it is registered for notice
+ if self.check_version(tv, self.feature_version):
+ return
+ self.log_usage_warning(tv)
+
+ @classmethod
+ def report(cls, subproject: str) -> None:
+ if subproject not in cls.feature_registry:
+ return
+ warning_str = cls.get_warning_str_prefix(cls.get_target_version(subproject))
+ notice_str = cls.get_notice_str_prefix(cls.get_target_version(subproject))
+ fv = cls.feature_registry[subproject]
+ tv = cls.get_target_version(subproject)
+ for version in sorted(fv.keys()):
+ if cls.check_version(tv, version):
+ notice_str += '\n * {}: {}'.format(version, {i[0] for i in fv[version]})
+ else:
+ warning_str += '\n * {}: {}'.format(version, {i[0] for i in fv[version]})
+ if '\n' in notice_str:
+ mlog.notice(notice_str, fatal=False)
+ if '\n' in warning_str:
+ mlog.warning(warning_str)
+
+ def log_usage_warning(self, tv: str) -> None:
+ raise InterpreterException('log_usage_warning not implemented')
+
+ @staticmethod
+ def get_warning_str_prefix(tv: str) -> str:
+ raise InterpreterException('get_warning_str_prefix not implemented')
+
+ @staticmethod
+ def get_notice_str_prefix(tv: str) -> str:
+ raise InterpreterException('get_notice_str_prefix not implemented')
+
+ def __call__(self, f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ node, _, _, subproject = get_callee_args(wrapped_args)
+ if subproject is None:
+ raise AssertionError(f'{wrapped_args!r}')
+ self.location = node
+ self.use(subproject)
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapped)
+
+ @classmethod
+ def single_use(cls, feature_name: str, version: str, subproject: str,
+ extra_message: str = '', location: T.Optional['mparser.BaseNode'] = None) -> None:
+ """Oneline version that instantiates and calls use()."""
+ cls(feature_name, version, extra_message, location).use(subproject)
+
+
+class FeatureNew(FeatureCheckBase):
+ """Checks for new features"""
+
+ # Class variable, shared across all instances
+ #
+ # Format: {subproject: {feature_version: set(feature_names)}}
+ feature_registry = {} # type: T.ClassVar[T.Dict[str, T.Dict[str, T.Set[T.Tuple[str, T.Optional[mparser.BaseNode]]]]]]
+
+ @staticmethod
+ def check_version(target_version: str, feature_version: str) -> bool:
+ return mesonlib.version_compare_condition_with_min(target_version, feature_version)
+
+ @staticmethod
+ def get_warning_str_prefix(tv: str) -> str:
+ return f'Project specifies a minimum meson_version \'{tv}\' but uses features which were added in newer versions:'
+
+ @staticmethod
+ def get_notice_str_prefix(tv: str) -> str:
+ return ''
+
+ def log_usage_warning(self, tv: str) -> None:
+ args = [
+ 'Project targeting', f"'{tv}'",
+ 'but tried to use feature introduced in',
+ f"'{self.feature_version}':",
+ f'{self.feature_name}.',
+ ]
+ if self.extra_message:
+ args.append(self.extra_message)
+ mlog.warning(*args, location=self.location)
+
+class FeatureDeprecated(FeatureCheckBase):
+ """Checks for deprecated features"""
+
+ # Class variable, shared across all instances
+ #
+ # Format: {subproject: {feature_version: set(feature_names)}}
+ feature_registry = {} # type: T.ClassVar[T.Dict[str, T.Dict[str, T.Set[T.Tuple[str, T.Optional[mparser.BaseNode]]]]]]
+ emit_notice = True
+
+ @staticmethod
+ def check_version(target_version: str, feature_version: str) -> bool:
+ # For deprecation checks we need to return the inverse of FeatureNew checks
+ return not mesonlib.version_compare_condition_with_min(target_version, feature_version)
+
+ @staticmethod
+ def get_warning_str_prefix(tv: str) -> str:
+ return 'Deprecated features used:'
+
+ @staticmethod
+ def get_notice_str_prefix(tv: str) -> str:
+ return 'Future-deprecated features used:'
+
+ def log_usage_warning(self, tv: str) -> None:
+ args = [
+ 'Project targeting', f"'{tv}'",
+ 'but tried to use feature deprecated since',
+ f"'{self.feature_version}':",
+ f'{self.feature_name}.',
+ ]
+ if self.extra_message:
+ args.append(self.extra_message)
+ mlog.warning(*args, location=self.location)
+
+
+class FeatureCheckKwargsBase(metaclass=abc.ABCMeta):
+
+ @property
+ @abc.abstractmethod
+ def feature_check_class(self) -> T.Type[FeatureCheckBase]:
+ pass
+
+ def __init__(self, feature_name: str, feature_version: str,
+ kwargs: T.List[str], extra_message: T.Optional[str] = None, location: T.Optional['mparser.BaseNode'] = None):
+ self.feature_name = feature_name
+ self.feature_version = feature_version
+ self.kwargs = kwargs
+ self.extra_message = extra_message
+ self.location = location
+
+ def __call__(self, f: TV_func) -> TV_func:
+ @wraps(f)
+ def wrapped(*wrapped_args: T.Any, **wrapped_kwargs: T.Any) -> T.Any:
+ node, _, kwargs, subproject = get_callee_args(wrapped_args)
+ if subproject is None:
+ raise AssertionError(f'{wrapped_args!r}')
+ for arg in self.kwargs:
+ if arg not in kwargs:
+ continue
+ name = arg + ' arg in ' + self.feature_name
+ self.feature_check_class.single_use(
+ name, self.feature_version, subproject, self.extra_message, node)
+ return f(*wrapped_args, **wrapped_kwargs)
+ return T.cast(TV_func, wrapped)
+
+class FeatureNewKwargs(FeatureCheckKwargsBase):
+ feature_check_class = FeatureNew
+
+class FeatureDeprecatedKwargs(FeatureCheckKwargsBase):
+ feature_check_class = FeatureDeprecated
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/disabler.py meson-0.61.2/mesonbuild/interpreterbase/disabler.py
--- meson-0.53.2/mesonbuild/interpreterbase/disabler.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/disabler.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,40 @@
+# 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 .baseobjects import MesonInterpreterObject, TYPE_var, TYPE_kwargs
+import typing as T
+
+class Disabler(MesonInterpreterObject):
+ def method_call(self, method_name: str, args: T.List[TYPE_var], kwargs: TYPE_kwargs) -> TYPE_var:
+ if method_name == 'found':
+ return False
+ return Disabler()
+
+def _is_arg_disabled(arg: T.Any) -> bool:
+ if isinstance(arg, Disabler):
+ return True
+ if isinstance(arg, list):
+ for i in arg:
+ if _is_arg_disabled(i):
+ return True
+ return False
+
+def is_disabled(args: T.Sequence[T.Any], kwargs: T.Dict[str, T.Any]) -> bool:
+ for i in args:
+ if _is_arg_disabled(i):
+ return True
+ for i in kwargs.values():
+ if _is_arg_disabled(i):
+ return True
+ return False
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/exceptions.py meson-0.61.2/mesonbuild/interpreterbase/exceptions.py
--- meson-0.53.2/mesonbuild/interpreterbase/exceptions.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/exceptions.py 2021-08-18 11:22:15.000000000 +0000
@@ -0,0 +1,33 @@
+# 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 ..mesonlib import MesonException
+
+class InterpreterException(MesonException):
+ pass
+
+class InvalidCode(InterpreterException):
+ pass
+
+class InvalidArguments(InterpreterException):
+ pass
+
+class SubdirDoneRequest(BaseException):
+ pass
+
+class ContinueRequest(BaseException):
+ pass
+
+class BreakRequest(BaseException):
+ pass
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/helpers.py meson-0.61.2/mesonbuild/interpreterbase/helpers.py
--- meson-0.53.2/mesonbuild/interpreterbase/helpers.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/helpers.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,55 @@
+# 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 .. import mesonlib, mparser
+from .exceptions import InterpreterException
+
+import collections.abc
+import typing as T
+
+if T.TYPE_CHECKING:
+ from .baseobjects import TYPE_var, TYPE_kwargs
+
+def flatten(args: T.Union['TYPE_var', T.List['TYPE_var']]) -> T.List['TYPE_var']:
+ if isinstance(args, mparser.StringNode):
+ assert isinstance(args.value, str)
+ return [args.value]
+ if not isinstance(args, collections.abc.Sequence):
+ return [args]
+ result: T.List['TYPE_var'] = []
+ for a in args:
+ if isinstance(a, list):
+ rest = flatten(a)
+ result = result + rest
+ elif isinstance(a, mparser.StringNode):
+ result.append(a.value)
+ else:
+ result.append(a)
+ return result
+
+def resolve_second_level_holders(args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> T.Tuple[T.List['TYPE_var'], 'TYPE_kwargs']:
+ def resolver(arg: 'TYPE_var') -> 'TYPE_var':
+ if isinstance(arg, list):
+ return [resolver(x) for x in arg]
+ if isinstance(arg, dict):
+ return {k: resolver(v) for k, v in arg.items()}
+ if isinstance(arg, mesonlib.SecondLevelHolder):
+ return arg.get_default_object()
+ return arg
+ return [resolver(x) for x in args], {k: resolver(v) for k, v in kwargs.items()}
+
+def default_resolve_key(key: mparser.BaseNode) -> str:
+ if not isinstance(key, mparser.IdNode):
+ raise InterpreterException('Invalid kwargs format.')
+ return key.value
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/__init__.py meson-0.61.2/mesonbuild/interpreterbase/__init__.py
--- meson-0.53.2/mesonbuild/interpreterbase/__init__.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/__init__.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,131 @@
+# 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.
+
+__all__ = [
+ 'InterpreterObject',
+ 'MesonInterpreterObject',
+ 'ObjectHolder',
+ 'IterableObject',
+ 'MutableInterpreterObject',
+
+ 'MesonOperator',
+
+ 'Disabler',
+ 'is_disabled',
+
+ 'InterpreterException',
+ 'InvalidCode',
+ 'InvalidArguments',
+ 'SubdirDoneRequest',
+ 'ContinueRequest',
+ 'BreakRequest',
+
+ 'default_resolve_key',
+ 'flatten',
+ 'resolve_second_level_holders',
+
+ 'noPosargs',
+ 'noKwargs',
+ 'stringArgs',
+ 'noArgsFlattening',
+ 'noSecondLevelHolderResolving',
+ 'unholder_return',
+ 'disablerIfNotFound',
+ 'permittedKwargs',
+ 'typed_operator',
+ 'unary_operator',
+ 'typed_pos_args',
+ 'ContainerTypeInfo',
+ 'KwargInfo',
+ 'typed_kwargs',
+ 'FeatureCheckBase',
+ 'FeatureNew',
+ 'FeatureDeprecated',
+ 'FeatureNewKwargs',
+ 'FeatureDeprecatedKwargs',
+
+ 'InterpreterBase',
+
+ 'TV_fw_var',
+ 'TV_fw_args',
+ 'TV_fw_kwargs',
+ 'TV_func',
+ 'TYPE_elementary',
+ 'TYPE_var',
+ 'TYPE_nvar',
+ 'TYPE_kwargs',
+ 'TYPE_nkwargs',
+ 'TYPE_key_resolver',
+ 'TYPE_HoldableTypes',
+
+ 'HoldableTypes',
+]
+
+from .baseobjects import (
+ InterpreterObject,
+ MesonInterpreterObject,
+ ObjectHolder,
+ IterableObject,
+ MutableInterpreterObject,
+
+ TV_fw_var,
+ TV_fw_args,
+ TV_fw_kwargs,
+ TV_func,
+ TYPE_elementary,
+ TYPE_var,
+ TYPE_nvar,
+ TYPE_kwargs,
+ TYPE_nkwargs,
+ TYPE_key_resolver,
+ TYPE_HoldableTypes,
+
+ HoldableTypes,
+)
+
+from .decorators import (
+ noPosargs,
+ noKwargs,
+ stringArgs,
+ noArgsFlattening,
+ noSecondLevelHolderResolving,
+ unholder_return,
+ disablerIfNotFound,
+ permittedKwargs,
+ typed_pos_args,
+ ContainerTypeInfo,
+ KwargInfo,
+ typed_operator,
+ unary_operator,
+ typed_kwargs,
+ FeatureCheckBase,
+ FeatureNew,
+ FeatureDeprecated,
+ FeatureNewKwargs,
+ FeatureDeprecatedKwargs,
+)
+
+from .exceptions import (
+ InterpreterException,
+ InvalidCode,
+ InvalidArguments,
+ SubdirDoneRequest,
+ ContinueRequest,
+ BreakRequest,
+)
+
+from .disabler import Disabler, is_disabled
+from .helpers import default_resolve_key, flatten, resolve_second_level_holders
+from .interpreterbase import InterpreterBase
+from .operator import MesonOperator
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/interpreterbase.py meson-0.61.2/mesonbuild/interpreterbase/interpreterbase.py
--- meson-0.53.2/mesonbuild/interpreterbase/interpreterbase.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/interpreterbase.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,598 @@
+# Copyright 2016-2017 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.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+
+from .. import mparser, mesonlib
+from .. import environment
+
+from .baseobjects import (
+ InterpreterObject,
+ MesonInterpreterObject,
+ MutableInterpreterObject,
+ InterpreterObjectTypeVar,
+ ObjectHolder,
+ IterableObject,
+
+ TYPE_var,
+ TYPE_kwargs,
+
+ HoldableTypes,
+)
+
+from .exceptions import (
+ InterpreterException,
+ InvalidCode,
+ InvalidArguments,
+ SubdirDoneRequest,
+ ContinueRequest,
+ BreakRequest
+)
+
+from .decorators import FeatureNew
+from .disabler import Disabler, is_disabled
+from .helpers import default_resolve_key, flatten, resolve_second_level_holders
+from .operator import MesonOperator
+from ._unholder import _unholder
+
+import os, copy, re, pathlib
+import typing as T
+import textwrap
+
+if T.TYPE_CHECKING:
+ from ..interpreter import Interpreter
+
+HolderMapType = T.Dict[
+ T.Union[
+ T.Type[mesonlib.HoldableObject],
+ T.Type[int],
+ T.Type[bool],
+ T.Type[str],
+ T.Type[list],
+ T.Type[dict],
+ ],
+ # For some reason, this has to be a callable and can't just be ObjectHolder[InterpreterObjectTypeVar]
+ T.Callable[[InterpreterObjectTypeVar, 'Interpreter'], ObjectHolder[InterpreterObjectTypeVar]]
+]
+
+FunctionType = T.Dict[
+ str,
+ T.Callable[[mparser.BaseNode, T.List[TYPE_var], T.Dict[str, TYPE_var]], TYPE_var]
+]
+
+class InterpreterBase:
+ def __init__(self, source_root: str, subdir: str, subproject: str):
+ self.source_root = source_root
+ self.funcs: FunctionType = {}
+ self.builtin: T.Dict[str, InterpreterObject] = {}
+ # Holder maps store a mapping from an HoldableObject to a class ObjectHolder
+ self.holder_map: HolderMapType = {}
+ self.bound_holder_map: HolderMapType = {}
+ self.subdir = subdir
+ self.root_subdir = subdir
+ self.subproject = subproject
+ self.variables: T.Dict[str, InterpreterObject] = {}
+ self.argument_depth = 0
+ self.current_lineno = -1
+ # Current node set during a function call. This can be used as location
+ # when printing a warning message during a method call.
+ self.current_node = None # type: mparser.BaseNode
+ # This is set to `version_string` when this statement is evaluated:
+ # meson.version().compare_version(version_string)
+ # If it was part of a if-clause, it is used to temporally override the
+ # current meson version target within that if-block.
+ self.tmp_meson_version = None # type: T.Optional[str]
+
+ def load_root_meson_file(self) -> None:
+ mesonfile = os.path.join(self.source_root, self.subdir, environment.build_filename)
+ if not os.path.isfile(mesonfile):
+ raise InvalidArguments(f'Missing Meson file in {mesonfile}')
+ with open(mesonfile, encoding='utf-8') as mf:
+ code = mf.read()
+ if code.isspace():
+ raise InvalidCode('Builder file is empty.')
+ assert isinstance(code, str)
+ try:
+ self.ast = mparser.Parser(code, mesonfile).parse()
+ except mesonlib.MesonException as me:
+ me.file = mesonfile
+ raise me
+
+ def parse_project(self) -> None:
+ """
+ Parses project() and initializes languages, compilers etc. Do this
+ early because we need this before we parse the rest of the AST.
+ """
+ self.evaluate_codeblock(self.ast, end=1)
+
+ def sanity_check_ast(self) -> None:
+ if not isinstance(self.ast, mparser.CodeBlockNode):
+ raise InvalidCode('AST is of invalid type. Possibly a bug in the parser.')
+ if not self.ast.lines:
+ raise InvalidCode('No statements in code.')
+ first = self.ast.lines[0]
+ if not isinstance(first, mparser.FunctionNode) or first.func_name != 'project':
+ p = pathlib.Path(self.source_root).resolve()
+ found = p
+ for parent in p.parents:
+ if (parent / 'meson.build').is_file():
+ with open(parent / 'meson.build', encoding='utf-8') as f:
+ if f.readline().startswith('project('):
+ found = parent
+ break
+ else:
+ break
+
+ error = 'first statement must be a call to project()'
+ if found != p:
+ raise InvalidCode(f'Not the project root: {error}\n\nDid you mean to run meson from the directory: "{found}"?')
+ else:
+ raise InvalidCode(f'Invalid source tree: {error}')
+
+ def run(self) -> None:
+ # Evaluate everything after the first line, which is project() because
+ # we already parsed that in self.parse_project()
+ try:
+ self.evaluate_codeblock(self.ast, start=1)
+ except SubdirDoneRequest:
+ pass
+
+ def evaluate_codeblock(self, node: mparser.CodeBlockNode, start: int = 0, end: T.Optional[int] = None) -> None:
+ if node is None:
+ return
+ if not isinstance(node, mparser.CodeBlockNode):
+ e = InvalidCode('Tried to execute a non-codeblock. Possibly a bug in the parser.')
+ e.lineno = node.lineno
+ e.colno = node.colno
+ raise e
+ statements = node.lines[start:end]
+ i = 0
+ while i < len(statements):
+ cur = statements[i]
+ try:
+ self.current_lineno = cur.lineno
+ self.evaluate_statement(cur)
+ except Exception as e:
+ if getattr(e, 'lineno', None) is None:
+ # We are doing the equivalent to setattr here and mypy does not like it
+ e.lineno = cur.lineno # type: ignore
+ e.colno = cur.colno # type: ignore
+ e.file = os.path.join(self.source_root, self.subdir, environment.build_filename) # type: ignore
+ raise e
+ i += 1 # In THE FUTURE jump over blocks and stuff.
+
+ def evaluate_statement(self, cur: mparser.BaseNode) -> T.Optional[InterpreterObject]:
+ self.current_node = cur
+ if isinstance(cur, mparser.FunctionNode):
+ return self.function_call(cur)
+ elif isinstance(cur, mparser.AssignmentNode):
+ self.assignment(cur)
+ elif isinstance(cur, mparser.MethodNode):
+ return self.method_call(cur)
+ elif isinstance(cur, mparser.StringNode):
+ return self._holderify(cur.value)
+ elif isinstance(cur, mparser.BooleanNode):
+ return self._holderify(cur.value)
+ elif isinstance(cur, mparser.IfClauseNode):
+ return self.evaluate_if(cur)
+ elif isinstance(cur, mparser.IdNode):
+ return self.get_variable(cur.value)
+ elif isinstance(cur, mparser.ComparisonNode):
+ return self.evaluate_comparison(cur)
+ elif isinstance(cur, mparser.ArrayNode):
+ return self.evaluate_arraystatement(cur)
+ elif isinstance(cur, mparser.DictNode):
+ return self.evaluate_dictstatement(cur)
+ elif isinstance(cur, mparser.NumberNode):
+ return self._holderify(cur.value)
+ elif isinstance(cur, mparser.AndNode):
+ return self.evaluate_andstatement(cur)
+ elif isinstance(cur, mparser.OrNode):
+ return self.evaluate_orstatement(cur)
+ elif isinstance(cur, mparser.NotNode):
+ return self.evaluate_notstatement(cur)
+ elif isinstance(cur, mparser.UMinusNode):
+ return self.evaluate_uminusstatement(cur)
+ elif isinstance(cur, mparser.ArithmeticNode):
+ return self.evaluate_arithmeticstatement(cur)
+ elif isinstance(cur, mparser.ForeachClauseNode):
+ self.evaluate_foreach(cur)
+ elif isinstance(cur, mparser.PlusAssignmentNode):
+ self.evaluate_plusassign(cur)
+ elif isinstance(cur, mparser.IndexNode):
+ return self.evaluate_indexing(cur)
+ elif isinstance(cur, mparser.TernaryNode):
+ return self.evaluate_ternary(cur)
+ elif isinstance(cur, mparser.FormatStringNode):
+ return self.evaluate_fstring(cur)
+ elif isinstance(cur, mparser.ContinueNode):
+ raise ContinueRequest()
+ elif isinstance(cur, mparser.BreakNode):
+ raise BreakRequest()
+ else:
+ raise InvalidCode("Unknown statement.")
+ return None
+
+ def evaluate_arraystatement(self, cur: mparser.ArrayNode) -> InterpreterObject:
+ (arguments, kwargs) = self.reduce_arguments(cur.args)
+ if len(kwargs) > 0:
+ raise InvalidCode('Keyword arguments are invalid in array construction.')
+ return self._holderify([_unholder(x) for x in arguments])
+
+ @FeatureNew('dict', '0.47.0')
+ def evaluate_dictstatement(self, cur: mparser.DictNode) -> InterpreterObject:
+ def resolve_key(key: mparser.BaseNode) -> str:
+ if not isinstance(key, mparser.StringNode):
+ FeatureNew.single_use('Dictionary entry using non literal key', '0.53.0', self.subproject)
+ str_key = _unholder(self.evaluate_statement(key))
+ if not isinstance(str_key, str):
+ raise InvalidArguments('Key must be a string')
+ return str_key
+ arguments, kwargs = self.reduce_arguments(cur.args, key_resolver=resolve_key, duplicate_key_error='Duplicate dictionary key: {}')
+ assert not arguments
+ return self._holderify({k: _unholder(v) for k, v in kwargs.items()})
+
+ def evaluate_notstatement(self, cur: mparser.NotNode) -> InterpreterObject:
+ v = self.evaluate_statement(cur.value)
+ if isinstance(v, Disabler):
+ return v
+ return self._holderify(v.operator_call(MesonOperator.NOT, None))
+
+ def evaluate_if(self, node: mparser.IfClauseNode) -> T.Optional[Disabler]:
+ assert isinstance(node, mparser.IfClauseNode)
+ for i in node.ifs:
+ # Reset self.tmp_meson_version to know if it gets set during this
+ # statement evaluation.
+ self.tmp_meson_version = None
+ result = self.evaluate_statement(i.condition)
+ if isinstance(result, Disabler):
+ return result
+ if not isinstance(result, InterpreterObject):
+ raise mesonlib.MesonBugException(f'Argument to not ({result}) is not an InterpreterObject but {type(result).__name__}.')
+ res = result.operator_call(MesonOperator.BOOL, None)
+ if not isinstance(res, bool):
+ raise InvalidCode(f'If clause {result!r} does not evaluate to true or false.')
+ if res:
+ prev_meson_version = mesonlib.project_meson_versions[self.subproject]
+ if self.tmp_meson_version:
+ mesonlib.project_meson_versions[self.subproject] = self.tmp_meson_version
+ try:
+ self.evaluate_codeblock(i.block)
+ finally:
+ mesonlib.project_meson_versions[self.subproject] = prev_meson_version
+ return None
+ if not isinstance(node.elseblock, mparser.EmptyNode):
+ self.evaluate_codeblock(node.elseblock)
+ return None
+
+ def evaluate_comparison(self, node: mparser.ComparisonNode) -> InterpreterObject:
+ val1 = self.evaluate_statement(node.left)
+ if isinstance(val1, Disabler):
+ return val1
+ val2 = self.evaluate_statement(node.right)
+ if isinstance(val2, Disabler):
+ return val2
+
+ # New code based on InterpreterObjects
+ operator = {
+ 'in': MesonOperator.IN,
+ 'notin': MesonOperator.NOT_IN,
+ '==': MesonOperator.EQUALS,
+ '!=': MesonOperator.NOT_EQUALS,
+ '>': MesonOperator.GREATER,
+ '<': MesonOperator.LESS,
+ '>=': MesonOperator.GREATER_EQUALS,
+ '<=': MesonOperator.LESS_EQUALS,
+ }[node.ctype]
+
+ # Check if the arguments should be reversed for simplicity (this essentially converts `in` to `contains`)
+ if operator in (MesonOperator.IN, MesonOperator.NOT_IN):
+ val1, val2 = val2, val1
+
+ val1.current_node = node
+ return self._holderify(val1.operator_call(operator, _unholder(val2)))
+
+ def evaluate_andstatement(self, cur: mparser.AndNode) -> InterpreterObject:
+ l = self.evaluate_statement(cur.left)
+ if isinstance(l, Disabler):
+ return l
+ l_bool = l.operator_call(MesonOperator.BOOL, None)
+ if not l_bool:
+ return self._holderify(l_bool)
+ r = self.evaluate_statement(cur.right)
+ if isinstance(r, Disabler):
+ return r
+ return self._holderify(r.operator_call(MesonOperator.BOOL, None))
+
+ def evaluate_orstatement(self, cur: mparser.OrNode) -> InterpreterObject:
+ l = self.evaluate_statement(cur.left)
+ if isinstance(l, Disabler):
+ return l
+ l_bool = l.operator_call(MesonOperator.BOOL, None)
+ if l_bool:
+ return self._holderify(l_bool)
+ r = self.evaluate_statement(cur.right)
+ if isinstance(r, Disabler):
+ return r
+ return self._holderify(r.operator_call(MesonOperator.BOOL, None))
+
+ def evaluate_uminusstatement(self, cur: mparser.UMinusNode) -> InterpreterObject:
+ v = self.evaluate_statement(cur.value)
+ if isinstance(v, Disabler):
+ return v
+ v.current_node = cur
+ return self._holderify(v.operator_call(MesonOperator.UMINUS, None))
+
+ def evaluate_arithmeticstatement(self, cur: mparser.ArithmeticNode) -> InterpreterObject:
+ l = self.evaluate_statement(cur.left)
+ if isinstance(l, Disabler):
+ return l
+ r = self.evaluate_statement(cur.right)
+ if isinstance(r, Disabler):
+ return r
+
+ mapping: T.Dict[str, MesonOperator] = {
+ 'add': MesonOperator.PLUS,
+ 'sub': MesonOperator.MINUS,
+ 'mul': MesonOperator.TIMES,
+ 'div': MesonOperator.DIV,
+ 'mod': MesonOperator.MOD,
+ }
+ l.current_node = cur
+ res = l.operator_call(mapping[cur.operation], _unholder(r))
+ return self._holderify(res)
+
+ def evaluate_ternary(self, node: mparser.TernaryNode) -> T.Optional[InterpreterObject]:
+ assert isinstance(node, mparser.TernaryNode)
+ result = self.evaluate_statement(node.condition)
+ if isinstance(result, Disabler):
+ return result
+ result.current_node = node
+ result_bool = result.operator_call(MesonOperator.BOOL, None)
+ if result_bool:
+ return self.evaluate_statement(node.trueblock)
+ else:
+ return self.evaluate_statement(node.falseblock)
+
+ @FeatureNew('format strings', '0.58.0')
+ def evaluate_fstring(self, node: mparser.FormatStringNode) -> InterpreterObject:
+ assert isinstance(node, mparser.FormatStringNode)
+
+ def replace(match: T.Match[str]) -> str:
+ var = str(match.group(1))
+ try:
+ val = _unholder(self.variables[var])
+ if not isinstance(val, (str, int, float, bool)):
+ raise InvalidCode(f'Identifier "{var}" does not name a formattable variable ' +
+ '(has to be an integer, a string, a floating point number or a boolean).')
+
+ return str(val)
+ except KeyError:
+ raise InvalidCode(f'Identifier "{var}" does not name a variable.')
+
+ res = re.sub(r'@([_a-zA-Z][_0-9a-zA-Z]*)@', replace, node.value)
+ return self._holderify(res)
+
+ def evaluate_foreach(self, node: mparser.ForeachClauseNode) -> None:
+ assert isinstance(node, mparser.ForeachClauseNode)
+ items = self.evaluate_statement(node.items)
+ if not isinstance(items, IterableObject):
+ raise InvalidArguments('Items of foreach loop do not support iterating')
+
+ tsize = items.iter_tuple_size()
+ if len(node.varnames) != (tsize or 1):
+ raise InvalidArguments(f'Foreach expects exactly {tsize or 1} variables for iterating over objects of type {items.display_name()}')
+
+ for i in items.iter_self():
+ if tsize is None:
+ if isinstance(i, tuple):
+ raise mesonlib.MesonBugException(f'Iteration of {items} returned a tuple even though iter_tuple_size() is None')
+ self.set_variable(node.varnames[0], self._holderify(i))
+ else:
+ if not isinstance(i, tuple):
+ raise mesonlib.MesonBugException(f'Iteration of {items} did not return a tuple even though iter_tuple_size() is {tsize}')
+ if len(i) != tsize:
+ raise mesonlib.MesonBugException(f'Iteration of {items} did not return a tuple even though iter_tuple_size() is {tsize}')
+ for j in range(tsize):
+ self.set_variable(node.varnames[j], self._holderify(i[j]))
+ try:
+ self.evaluate_codeblock(node.block)
+ except ContinueRequest:
+ continue
+ except BreakRequest:
+ break
+
+ def evaluate_plusassign(self, node: mparser.PlusAssignmentNode) -> None:
+ assert isinstance(node, mparser.PlusAssignmentNode)
+ varname = node.var_name
+ addition = self.evaluate_statement(node.value)
+
+ # Remember that all variables are immutable. We must always create a
+ # full new variable and then assign it.
+ old_variable = self.get_variable(varname)
+ old_variable.current_node = node
+ new_value = self._holderify(old_variable.operator_call(MesonOperator.PLUS, _unholder(addition)))
+ self.set_variable(varname, new_value)
+
+ def evaluate_indexing(self, node: mparser.IndexNode) -> InterpreterObject:
+ assert isinstance(node, mparser.IndexNode)
+ iobject = self.evaluate_statement(node.iobject)
+ if isinstance(iobject, Disabler):
+ return iobject
+ index = _unholder(self.evaluate_statement(node.index))
+
+ if iobject is None:
+ raise InterpreterException('Tried to evaluate indexing on None')
+ iobject.current_node = node
+ return self._holderify(iobject.operator_call(MesonOperator.INDEX, index))
+
+ def function_call(self, node: mparser.FunctionNode) -> T.Optional[InterpreterObject]:
+ func_name = node.func_name
+ (h_posargs, h_kwargs) = self.reduce_arguments(node.args)
+ (posargs, kwargs) = self._unholder_args(h_posargs, h_kwargs)
+ if is_disabled(posargs, kwargs) and func_name not in {'get_variable', 'set_variable', 'unset_variable', 'is_disabler'}:
+ return Disabler()
+ if func_name in self.funcs:
+ func = self.funcs[func_name]
+ func_args = posargs
+ if not getattr(func, 'no-args-flattening', False):
+ func_args = flatten(posargs)
+ if not getattr(func, 'no-second-level-holder-flattening', False):
+ func_args, kwargs = resolve_second_level_holders(func_args, kwargs)
+ res = func(node, func_args, kwargs)
+ return self._holderify(res) if res is not None else None
+ else:
+ self.unknown_function_called(func_name)
+ return None
+
+ def method_call(self, node: mparser.MethodNode) -> T.Optional[InterpreterObject]:
+ invokable = node.source_object
+ obj: T.Optional[InterpreterObject]
+ if isinstance(invokable, mparser.IdNode):
+ object_name = invokable.value
+ obj = self.get_variable(object_name)
+ else:
+ obj = self.evaluate_statement(invokable)
+ method_name = node.name
+ (h_args, h_kwargs) = self.reduce_arguments(node.args)
+ (args, kwargs) = self._unholder_args(h_args, h_kwargs)
+ if is_disabled(args, kwargs):
+ return Disabler()
+ if not isinstance(obj, InterpreterObject):
+ raise InvalidArguments(f'Variable "{object_name}" is not callable.')
+ # TODO: InterpreterBase **really** shouldn't be in charge of checking this
+ if method_name == 'extract_objects':
+ if isinstance(obj, ObjectHolder):
+ self.validate_extraction(obj.held_object)
+ elif not isinstance(obj, Disabler):
+ raise InvalidArguments(f'Invalid operation "extract_objects" on variable "{object_name}" of type {type(obj).__name__}')
+ obj.current_node = node
+ res = obj.method_call(method_name, args, kwargs)
+ return self._holderify(res) if res is not None else None
+
+ def _holderify(self, res: T.Union[TYPE_var, InterpreterObject]) -> InterpreterObject:
+ if isinstance(res, HoldableTypes):
+ # Always check for an exact match first.
+ cls = self.holder_map.get(type(res), None)
+ if cls is not None:
+ # Casts to Interpreter are required here since an assertion would
+ # not work for the `ast` module.
+ return cls(res, T.cast('Interpreter', self))
+ # Try the boundary types next.
+ for typ, cls in self.bound_holder_map.items():
+ if isinstance(res, typ):
+ return cls(res, T.cast('Interpreter', self))
+ raise mesonlib.MesonBugException(f'Object {res} of type {type(res).__name__} is neither in self.holder_map nor self.bound_holder_map.')
+ elif isinstance(res, ObjectHolder):
+ raise mesonlib.MesonBugException(f'Returned object {res} of type {type(res).__name__} is an object holder.')
+ elif isinstance(res, MesonInterpreterObject):
+ return res
+ raise mesonlib.MesonBugException(f'Unknown returned object {res} of type {type(res).__name__} in the parameters.')
+
+ def _unholder_args(self,
+ args: T.List[InterpreterObject],
+ kwargs: T.Dict[str, InterpreterObject]) -> T.Tuple[T.List[TYPE_var], TYPE_kwargs]:
+ return [_unholder(x) for x in args], {k: _unholder(v) for k, v in kwargs.items()}
+
+ def unknown_function_called(self, func_name: str) -> None:
+ raise InvalidCode(f'Unknown function "{func_name}".')
+
+ def reduce_arguments(
+ self,
+ args: mparser.ArgumentNode,
+ key_resolver: T.Callable[[mparser.BaseNode], str] = default_resolve_key,
+ duplicate_key_error: T.Optional[str] = None,
+ ) -> T.Tuple[
+ T.List[InterpreterObject],
+ T.Dict[str, InterpreterObject]
+ ]:
+ assert isinstance(args, mparser.ArgumentNode)
+ if args.incorrect_order():
+ raise InvalidArguments('All keyword arguments must be after positional arguments.')
+ self.argument_depth += 1
+ reduced_pos = [self.evaluate_statement(arg) for arg in args.arguments]
+ if any(x is None for x in reduced_pos):
+ raise InvalidArguments(f'At least one value in the arguments is void.')
+ reduced_kw: T.Dict[str, InterpreterObject] = {}
+ for key, val in args.kwargs.items():
+ reduced_key = key_resolver(key)
+ assert isinstance(val, mparser.BaseNode)
+ reduced_val = self.evaluate_statement(val)
+ if reduced_val is None:
+ raise InvalidArguments(f'Value of key {reduced_key} is void.')
+ if duplicate_key_error and reduced_key in reduced_kw:
+ raise InvalidArguments(duplicate_key_error.format(reduced_key))
+ reduced_kw[reduced_key] = reduced_val
+ self.argument_depth -= 1
+ final_kw = self.expand_default_kwargs(reduced_kw)
+ return reduced_pos, final_kw
+
+ def expand_default_kwargs(self, kwargs: T.Dict[str, T.Optional[InterpreterObject]]) -> T.Dict[str, T.Optional[InterpreterObject]]:
+ if 'kwargs' not in kwargs:
+ return kwargs
+ to_expand = _unholder(kwargs.pop('kwargs'))
+ if not isinstance(to_expand, dict):
+ raise InterpreterException('Value of "kwargs" must be dictionary.')
+ if 'kwargs' in to_expand:
+ raise InterpreterException('Kwargs argument must not contain a "kwargs" entry. Points for thinking meta, though. :P')
+ for k, v in to_expand.items():
+ if k in kwargs:
+ raise InterpreterException(f'Entry "{k}" defined both as a keyword argument and in a "kwarg" entry.')
+ kwargs[k] = self._holderify(v)
+ return kwargs
+
+ def assignment(self, node: mparser.AssignmentNode) -> None:
+ assert isinstance(node, mparser.AssignmentNode)
+ if self.argument_depth != 0:
+ raise InvalidArguments(textwrap.dedent('''\
+ Tried to assign values inside an argument list.
+ To specify a keyword argument, use : instead of =.
+ '''))
+ var_name = node.var_name
+ if not isinstance(var_name, str):
+ raise InvalidArguments('Tried to assign value to a non-variable.')
+ value = self.evaluate_statement(node.value)
+ # For mutable objects we need to make a copy on assignment
+ if isinstance(value, MutableInterpreterObject):
+ value = copy.deepcopy(value)
+ self.set_variable(var_name, value)
+ return None
+
+ def set_variable(self, varname: str, variable: T.Union[TYPE_var, InterpreterObject], *, holderify: bool = False) -> None:
+ if variable is None:
+ raise InvalidCode('Can not assign None to variable.')
+ if holderify:
+ variable = self._holderify(variable)
+ else:
+ # Ensure that we are always storing ObjectHolders
+ if not isinstance(variable, InterpreterObject):
+ raise mesonlib.MesonBugException(f'set_variable in InterpreterBase called with a non InterpreterObject {variable} of type {type(variable).__name__}')
+ if not isinstance(varname, str):
+ raise InvalidCode('First argument to set_variable must be a string.')
+ if re.match('[_a-zA-Z][_0-9a-zA-Z]*$', varname) is None:
+ raise InvalidCode('Invalid variable name: ' + varname)
+ if varname in self.builtin:
+ raise InvalidCode(f'Tried to overwrite internal variable "{varname}"')
+ self.variables[varname] = variable
+
+ def get_variable(self, varname: str) -> InterpreterObject:
+ if varname in self.builtin:
+ return self.builtin[varname]
+ if varname in self.variables:
+ return self.variables[varname]
+ raise InvalidCode(f'Unknown variable "{varname}".')
+
+ def validate_extraction(self, buildtarget: mesonlib.HoldableObject) -> None:
+ raise InterpreterException('validate_extraction is not implemented in this context (please file a bug)')
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/operator.py meson-0.61.2/mesonbuild/interpreterbase/operator.py
--- meson-0.53.2/mesonbuild/interpreterbase/operator.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/operator.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,32 @@
+# SPDX-license-identifier: Apache-2.0
+
+from enum import Enum
+
+class MesonOperator(Enum):
+ # Arithmetic
+ PLUS = '+'
+ MINUS = '-'
+ TIMES = '*'
+ DIV = '/'
+ MOD = '%'
+
+ UMINUS = 'uminus'
+
+ # Logic
+ NOT = 'not'
+
+ # Should return the boolsche interpretation of the value (`'' == false` for instance)
+ BOOL = 'bool()'
+
+ # Comparison
+ EQUALS = '=='
+ NOT_EQUALS = '!='
+ GREATER = '>'
+ LESS = '<'
+ GREATER_EQUALS = '>='
+ LESS_EQUALS = '<='
+
+ # Container
+ IN = 'in'
+ NOT_IN = 'not in'
+ INDEX = '[]'
diff -Nru meson-0.53.2/mesonbuild/interpreterbase/_unholder.py meson-0.61.2/mesonbuild/interpreterbase/_unholder.py
--- meson-0.53.2/mesonbuild/interpreterbase/_unholder.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase/_unholder.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,29 @@
+# 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 .baseobjects import InterpreterObject, MesonInterpreterObject, ObjectHolder, TYPE_var, HoldableTypes
+from .exceptions import InvalidArguments
+from ..mesonlib import HoldableObject, MesonBugException
+
+def _unholder(obj: InterpreterObject) -> TYPE_var:
+ if isinstance(obj, ObjectHolder):
+ assert isinstance(obj.held_object, HoldableTypes)
+ return obj.held_object
+ elif isinstance(obj, MesonInterpreterObject):
+ return obj
+ elif isinstance(obj, HoldableObject):
+ raise MesonBugException(f'Argument {obj} of type {type(obj).__name__} is not held by an ObjectHolder.')
+ elif isinstance(obj, InterpreterObject):
+ raise InvalidArguments(f'Argument {obj} of type {type(obj).__name__} cannot be passed to a method or function')
+ raise MesonBugException(f'Unknown object {obj} of type {type(obj).__name__} in the parameters.')
diff -Nru meson-0.53.2/mesonbuild/interpreterbase.py meson-0.61.2/mesonbuild/interpreterbase.py
--- meson-0.53.2/mesonbuild/interpreterbase.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreterbase.py 1970-01-01 00:00:00.000000000 +0000
@@ -1,1098 +0,0 @@
-# Copyright 2016-2017 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.
-
-# This class contains the basic functionality needed to run any interpreter
-# or an interpreter-based tool.
-
-from . import mparser, mesonlib, mlog
-from . import environment, dependencies
-
-import os, copy, re
-from functools import wraps
-
-class ObjectHolder:
- def __init__(self, obj, subproject=None):
- self.held_object = obj
- self.subproject = subproject
-
- def __repr__(self):
- return ''.format(self.held_object)
-
-# Decorators for method calls.
-
-def check_stringlist(a, msg='Arguments must be strings.'):
- if not isinstance(a, list):
- mlog.debug('Not a list:', str(a))
- raise InvalidArguments('Argument not a list.')
- if not all(isinstance(s, str) for s in a):
- mlog.debug('Element not a string:', str(a))
- raise InvalidArguments(msg)
-
-def _get_callee_args(wrapped_args, want_subproject=False):
- s = wrapped_args[0]
- n = len(wrapped_args)
- # Raise an error if the codepaths are not there
- subproject = None
- if want_subproject and n == 2:
- if hasattr(s, 'subproject'):
- # Interpreter base types have 2 args: self, node
- node = wrapped_args[1]
- # args and kwargs are inside the node
- args = None
- kwargs = None
- subproject = s.subproject
- elif hasattr(wrapped_args[1], 'subproject'):
- # Module objects have 2 args: self, interpreter
- node = wrapped_args[1].current_node
- # args and kwargs are inside the node
- args = None
- kwargs = None
- subproject = wrapped_args[1].subproject
- else:
- raise AssertionError('Unknown args: {!r}'.format(wrapped_args))
- elif n == 3:
- # Methods on objects (*Holder, MesonMain, etc) have 3 args: self, args, kwargs
- node = s.current_node
- args = wrapped_args[1]
- kwargs = wrapped_args[2]
- if want_subproject:
- if hasattr(s, 'subproject'):
- subproject = s.subproject
- elif hasattr(s, 'interpreter'):
- subproject = s.interpreter.subproject
- elif n == 4:
- # Meson functions have 4 args: self, node, args, kwargs
- # Module functions have 4 args: self, state, args, kwargs
- if isinstance(s, InterpreterBase):
- node = wrapped_args[1]
- else:
- node = wrapped_args[1].current_node
- args = wrapped_args[2]
- kwargs = wrapped_args[3]
- if want_subproject:
- if isinstance(s, InterpreterBase):
- subproject = s.subproject
- else:
- subproject = wrapped_args[1].subproject
- elif n == 5:
- # Module snippets have 5 args: self, interpreter, state, args, kwargs
- node = wrapped_args[2].current_node
- args = wrapped_args[3]
- kwargs = wrapped_args[4]
- if want_subproject:
- subproject = wrapped_args[2].subproject
- else:
- raise AssertionError('Unknown args: {!r}'.format(wrapped_args))
- # Sometimes interpreter methods are called internally with None instead of
- # empty list/dict
- args = args if args is not None else []
- kwargs = kwargs if kwargs is not None else {}
- return s, node, args, kwargs, subproject
-
-def flatten(args):
- if isinstance(args, mparser.StringNode):
- return args.value
- if isinstance(args, (int, str, mesonlib.File, InterpreterObject)):
- return args
- result = []
- for a in args:
- if isinstance(a, list):
- rest = flatten(a)
- result = result + rest
- elif isinstance(a, mparser.StringNode):
- result.append(a.value)
- else:
- result.append(a)
- return result
-
-def noPosargs(f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- args = _get_callee_args(wrapped_args)[2]
- if args:
- raise InvalidArguments('Function does not take positional arguments.')
- return f(*wrapped_args, **wrapped_kwargs)
- return wrapped
-
-def noKwargs(f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- kwargs = _get_callee_args(wrapped_args)[3]
- if kwargs:
- raise InvalidArguments('Function does not take keyword arguments.')
- return f(*wrapped_args, **wrapped_kwargs)
- return wrapped
-
-def stringArgs(f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- args = _get_callee_args(wrapped_args)[2]
- assert(isinstance(args, list))
- check_stringlist(args)
- return f(*wrapped_args, **wrapped_kwargs)
- return wrapped
-
-def noArgsFlattening(f):
- setattr(f, 'no-args-flattening', True) # noqa: B010
- return f
-
-def disablerIfNotFound(f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- kwargs = _get_callee_args(wrapped_args)[3]
- disabler = kwargs.pop('disabler', False)
- ret = f(*wrapped_args, **wrapped_kwargs)
- if disabler and not ret.held_object.found():
- return Disabler()
- return ret
- return wrapped
-
-class permittedKwargs:
-
- def __init__(self, permitted):
- self.permitted = permitted
-
- def __call__(self, f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- s, node, args, kwargs, _ = _get_callee_args(wrapped_args)
- for k in kwargs:
- if k not in self.permitted:
- mlog.warning('''Passed invalid keyword argument "{}".'''.format(k), location=node)
- mlog.warning('This will become a hard error in the future.')
- return f(*wrapped_args, **wrapped_kwargs)
- return wrapped
-
-
-class FeatureCheckBase:
- "Base class for feature version checks"
-
- def __init__(self, feature_name, version):
- self.feature_name = feature_name
- self.feature_version = version
-
- @staticmethod
- def get_target_version(subproject):
- # Don't do any checks if project() has not been parsed yet
- if subproject not in mesonlib.project_meson_versions:
- return ''
- return mesonlib.project_meson_versions[subproject]
-
- def use(self, subproject):
- tv = self.get_target_version(subproject)
- # No target version
- if tv == '':
- return
- # Target version is new enough
- if mesonlib.version_compare_condition_with_min(tv, self.feature_version):
- return
- # Feature is too new for target version, register it
- if subproject not in self.feature_registry:
- self.feature_registry[subproject] = {self.feature_version: set()}
- register = self.feature_registry[subproject]
- if self.feature_version not in register:
- register[self.feature_version] = set()
- if self.feature_name in register[self.feature_version]:
- # Don't warn about the same feature multiple times
- # FIXME: This is needed to prevent duplicate warnings, but also
- # means we won't warn about a feature used in multiple places.
- return
- register[self.feature_version].add(self.feature_name)
- self.log_usage_warning(tv)
-
- @classmethod
- def report(cls, subproject):
- if subproject not in cls.feature_registry:
- return
- warning_str = cls.get_warning_str_prefix(cls.get_target_version(subproject))
- fv = cls.feature_registry[subproject]
- for version in sorted(fv.keys()):
- warning_str += '\n * {}: {}'.format(version, fv[version])
- mlog.warning(warning_str)
-
- def __call__(self, f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- subproject = _get_callee_args(wrapped_args, want_subproject=True)[4]
- if subproject is None:
- raise AssertionError('{!r}'.format(wrapped_args))
- self.use(subproject)
- return f(*wrapped_args, **wrapped_kwargs)
- return wrapped
-
-class FeatureNew(FeatureCheckBase):
- """Checks for new features"""
- # Class variable, shared across all instances
- #
- # Format: {subproject: {feature_version: set(feature_names)}}
- feature_registry = {}
-
- @staticmethod
- def get_warning_str_prefix(tv):
- return 'Project specifies a minimum meson_version \'{}\' but uses features which were added in newer versions:'.format(tv)
-
- def log_usage_warning(self, tv):
- mlog.warning('Project targeting \'{}\' but tried to use feature introduced '
- 'in \'{}\': {}'.format(tv, self.feature_version, self.feature_name))
-
-class FeatureDeprecated(FeatureCheckBase):
- """Checks for deprecated features"""
- # Class variable, shared across all instances
- #
- # Format: {subproject: {feature_version: set(feature_names)}}
- feature_registry = {}
-
- @staticmethod
- def get_warning_str_prefix(tv):
- return 'Deprecated features used:'
-
- def log_usage_warning(self, tv):
- mlog.deprecation('Project targeting \'{}\' but tried to use feature '
- 'deprecated since \'{}\': {}'
- ''.format(tv, self.feature_version, self.feature_name))
-
-
-class FeatureCheckKwargsBase:
- def __init__(self, feature_name, feature_version, kwargs):
- self.feature_name = feature_name
- self.feature_version = feature_version
- self.kwargs = kwargs
-
- def __call__(self, f):
- @wraps(f)
- def wrapped(*wrapped_args, **wrapped_kwargs):
- # Which FeatureCheck class to invoke
- FeatureCheckClass = self.feature_check_class
- kwargs, subproject = _get_callee_args(wrapped_args, want_subproject=True)[3:5]
- if subproject is None:
- raise AssertionError('{!r}'.format(wrapped_args))
- for arg in self.kwargs:
- if arg not in kwargs:
- continue
- name = arg + ' arg in ' + self.feature_name
- FeatureCheckClass(name, self.feature_version).use(subproject)
- return f(*wrapped_args, **wrapped_kwargs)
- return wrapped
-
-class FeatureNewKwargs(FeatureCheckKwargsBase):
- feature_check_class = FeatureNew
-
-class FeatureDeprecatedKwargs(FeatureCheckKwargsBase):
- feature_check_class = FeatureDeprecated
-
-
-class InterpreterException(mesonlib.MesonException):
- pass
-
-class InvalidCode(InterpreterException):
- pass
-
-class InvalidArguments(InterpreterException):
- pass
-
-class SubdirDoneRequest(BaseException):
- pass
-
-class ContinueRequest(BaseException):
- pass
-
-class BreakRequest(BaseException):
- pass
-
-class InterpreterObject:
- def __init__(self):
- self.methods = {}
- # Current node set during a method call. This can be used as location
- # when printing a warning message during a method call.
- self.current_node = None
-
- def method_call(self, method_name, args, kwargs):
- if method_name in self.methods:
- method = self.methods[method_name]
- if not getattr(method, 'no-args-flattening', False):
- args = flatten(args)
- return method(args, kwargs)
- raise InvalidCode('Unknown method "%s" in object.' % method_name)
-
-class MutableInterpreterObject(InterpreterObject):
- def __init__(self):
- super().__init__()
-
-class Disabler(InterpreterObject):
- def __init__(self):
- super().__init__()
- self.methods.update({'found': self.found_method})
-
- def found_method(self, args, kwargs):
- return False
-
-def is_disabler(i) -> bool:
- return isinstance(i, Disabler)
-
-def is_arg_disabled(arg) -> bool:
- if is_disabler(arg):
- return True
- if isinstance(arg, list):
- for i in arg:
- if is_arg_disabled(i):
- return True
- return False
-
-def is_disabled(args, kwargs) -> bool:
- for i in args:
- if is_arg_disabled(i):
- return True
- for i in kwargs.values():
- if is_arg_disabled(i):
- return True
- return False
-
-class InterpreterBase:
- def __init__(self, source_root, subdir):
- self.source_root = source_root
- self.funcs = {}
- self.builtin = {}
- self.subdir = subdir
- self.variables = {}
- self.argument_depth = 0
- self.current_lineno = -1
- # Current node set during a function call. This can be used as location
- # when printing a warning message during a method call.
- self.current_node = None
-
- def load_root_meson_file(self):
- mesonfile = os.path.join(self.source_root, self.subdir, environment.build_filename)
- if not os.path.isfile(mesonfile):
- raise InvalidArguments('Missing Meson file in %s' % mesonfile)
- with open(mesonfile, encoding='utf8') as mf:
- code = mf.read()
- if code.isspace():
- raise InvalidCode('Builder file is empty.')
- assert(isinstance(code, str))
- try:
- self.ast = mparser.Parser(code, self.subdir).parse()
- except mesonlib.MesonException as me:
- me.file = mesonfile
- raise me
-
- def join_path_strings(self, args):
- return os.path.join(*args).replace('\\', '/')
-
- def parse_project(self):
- """
- Parses project() and initializes languages, compilers etc. Do this
- early because we need this before we parse the rest of the AST.
- """
- self.evaluate_codeblock(self.ast, end=1)
-
- def sanity_check_ast(self):
- if not isinstance(self.ast, mparser.CodeBlockNode):
- raise InvalidCode('AST is of invalid type. Possibly a bug in the parser.')
- if not self.ast.lines:
- raise InvalidCode('No statements in code.')
- first = self.ast.lines[0]
- if not isinstance(first, mparser.FunctionNode) or first.func_name != 'project':
- raise InvalidCode('First statement must be a call to project')
-
- def run(self):
- # Evaluate everything after the first line, which is project() because
- # we already parsed that in self.parse_project()
- try:
- self.evaluate_codeblock(self.ast, start=1)
- except SubdirDoneRequest:
- pass
-
- def evaluate_codeblock(self, node, start=0, end=None):
- if node is None:
- return
- if not isinstance(node, mparser.CodeBlockNode):
- e = InvalidCode('Tried to execute a non-codeblock. Possibly a bug in the parser.')
- e.lineno = node.lineno
- e.colno = node.colno
- raise e
- statements = node.lines[start:end]
- i = 0
- while i < len(statements):
- cur = statements[i]
- try:
- self.current_lineno = cur.lineno
- self.evaluate_statement(cur)
- except Exception as e:
- if not hasattr(e, 'lineno'):
- e.lineno = cur.lineno
- e.colno = cur.colno
- e.file = os.path.join(self.subdir, 'meson.build')
- raise e
- i += 1 # In THE FUTURE jump over blocks and stuff.
-
- def evaluate_statement(self, cur):
- if isinstance(cur, mparser.FunctionNode):
- return self.function_call(cur)
- elif isinstance(cur, mparser.AssignmentNode):
- return self.assignment(cur)
- elif isinstance(cur, mparser.MethodNode):
- return self.method_call(cur)
- elif isinstance(cur, mparser.StringNode):
- return cur.value
- elif isinstance(cur, mparser.BooleanNode):
- return cur.value
- elif isinstance(cur, mparser.IfClauseNode):
- return self.evaluate_if(cur)
- elif isinstance(cur, mparser.IdNode):
- return self.get_variable(cur.value)
- elif isinstance(cur, mparser.ComparisonNode):
- return self.evaluate_comparison(cur)
- elif isinstance(cur, mparser.ArrayNode):
- return self.evaluate_arraystatement(cur)
- elif isinstance(cur, mparser.DictNode):
- return self.evaluate_dictstatement(cur)
- elif isinstance(cur, mparser.NumberNode):
- return cur.value
- elif isinstance(cur, mparser.AndNode):
- return self.evaluate_andstatement(cur)
- elif isinstance(cur, mparser.OrNode):
- return self.evaluate_orstatement(cur)
- elif isinstance(cur, mparser.NotNode):
- return self.evaluate_notstatement(cur)
- elif isinstance(cur, mparser.UMinusNode):
- return self.evaluate_uminusstatement(cur)
- elif isinstance(cur, mparser.ArithmeticNode):
- return self.evaluate_arithmeticstatement(cur)
- elif isinstance(cur, mparser.ForeachClauseNode):
- return self.evaluate_foreach(cur)
- elif isinstance(cur, mparser.PlusAssignmentNode):
- return self.evaluate_plusassign(cur)
- elif isinstance(cur, mparser.IndexNode):
- return self.evaluate_indexing(cur)
- elif isinstance(cur, mparser.TernaryNode):
- return self.evaluate_ternary(cur)
- elif isinstance(cur, mparser.ContinueNode):
- raise ContinueRequest()
- elif isinstance(cur, mparser.BreakNode):
- raise BreakRequest()
- elif self.is_elementary_type(cur):
- return cur
- else:
- raise InvalidCode("Unknown statement.")
-
- def evaluate_arraystatement(self, cur):
- (arguments, kwargs) = self.reduce_arguments(cur.args)
- if len(kwargs) > 0:
- raise InvalidCode('Keyword arguments are invalid in array construction.')
- return arguments
-
- @FeatureNew('dict', '0.47.0')
- def evaluate_dictstatement(self, cur):
- (arguments, kwargs) = self.reduce_arguments(cur.args)
- assert (not arguments)
- result = {}
- self.argument_depth += 1
- for key, value in kwargs.items():
- if not isinstance(key, mparser.StringNode):
- FeatureNew('Dictionary entry using non literal key', '0.53.0').use(self.subproject)
- key = self.evaluate_statement(key)
- if not isinstance(key, str):
- raise InvalidArguments('Key must be a string')
- if key in result:
- raise InvalidArguments('Duplicate dictionary key: {}'.format(key))
- result[key] = value
- self.argument_depth -= 1
- return result
-
- def evaluate_notstatement(self, cur):
- v = self.evaluate_statement(cur.value)
- if is_disabler(v):
- return v
- if not isinstance(v, bool):
- raise InterpreterException('Argument to "not" is not a boolean.')
- return not v
-
- def evaluate_if(self, node):
- assert(isinstance(node, mparser.IfClauseNode))
- for i in node.ifs:
- result = self.evaluate_statement(i.condition)
- if is_disabler(result):
- return result
- if not(isinstance(result, bool)):
- raise InvalidCode('If clause {!r} does not evaluate to true or false.'.format(result))
- if result:
- self.evaluate_codeblock(i.block)
- return
- if not isinstance(node.elseblock, mparser.EmptyNode):
- self.evaluate_codeblock(node.elseblock)
-
- def validate_comparison_types(self, val1, val2):
- if type(val1) != type(val2):
- return False
- return True
-
- def evaluate_in(self, val1, val2):
- if not isinstance(val1, (str, int, float, ObjectHolder)):
- raise InvalidArguments('lvalue of "in" operator must be a string, integer, float, or object')
- if not isinstance(val2, (list, dict)):
- raise InvalidArguments('rvalue of "in" operator must be an array or a dict')
- return val1 in val2
-
- def evaluate_comparison(self, node):
- val1 = self.evaluate_statement(node.left)
- if is_disabler(val1):
- return val1
- val2 = self.evaluate_statement(node.right)
- if is_disabler(val2):
- return val2
- if node.ctype == 'in':
- return self.evaluate_in(val1, val2)
- elif node.ctype == 'notin':
- return not self.evaluate_in(val1, val2)
- valid = self.validate_comparison_types(val1, val2)
- # Ordering comparisons of different types isn't allowed since PR #1810
- # (0.41.0). Since PR #2884 we also warn about equality comparisons of
- # different types, which will one day become an error.
- if not valid and (node.ctype == '==' or node.ctype == '!='):
- mlog.warning('''Trying to compare values of different types ({}, {}) using {}.
-The result of this is undefined and will become a hard error in a future Meson release.'''
- .format(type(val1).__name__, type(val2).__name__, node.ctype), location=node)
- if node.ctype == '==':
- return val1 == val2
- elif node.ctype == '!=':
- return val1 != val2
- elif not valid:
- raise InterpreterException(
- 'Values of different types ({}, {}) cannot be compared using {}.'.format(type(val1).__name__,
- type(val2).__name__,
- node.ctype))
- elif not self.is_elementary_type(val1):
- raise InterpreterException('{} can only be compared for equality.'.format(node.left.value))
- elif not self.is_elementary_type(val2):
- raise InterpreterException('{} can only be compared for equality.'.format(node.right.value))
- elif node.ctype == '<':
- return val1 < val2
- elif node.ctype == '<=':
- return val1 <= val2
- elif node.ctype == '>':
- return val1 > val2
- elif node.ctype == '>=':
- return val1 >= val2
- else:
- raise InvalidCode('You broke my compare eval.')
-
- def evaluate_andstatement(self, cur):
- l = self.evaluate_statement(cur.left)
- if is_disabler(l):
- return l
- if not isinstance(l, bool):
- raise InterpreterException('First argument to "and" is not a boolean.')
- if not l:
- return False
- r = self.evaluate_statement(cur.right)
- if is_disabler(r):
- return r
- if not isinstance(r, bool):
- raise InterpreterException('Second argument to "and" is not a boolean.')
- return r
-
- def evaluate_orstatement(self, cur):
- l = self.evaluate_statement(cur.left)
- if is_disabler(l):
- return l
- if not isinstance(l, bool):
- raise InterpreterException('First argument to "or" is not a boolean.')
- if l:
- return True
- r = self.evaluate_statement(cur.right)
- if is_disabler(r):
- return r
- if not isinstance(r, bool):
- raise InterpreterException('Second argument to "or" is not a boolean.')
- return r
-
- def evaluate_uminusstatement(self, cur):
- v = self.evaluate_statement(cur.value)
- if is_disabler(v):
- return v
- if not isinstance(v, int):
- raise InterpreterException('Argument to negation is not an integer.')
- return -v
-
- @FeatureNew('/ with string arguments', '0.49.0')
- def evaluate_path_join(self, l, r):
- if not isinstance(l, str):
- raise InvalidCode('The division operator can only append to a string.')
- if not isinstance(r, str):
- raise InvalidCode('The division operator can only append a string.')
- return self.join_path_strings((l, r))
-
- def evaluate_division(self, l, r):
- if isinstance(l, str) or isinstance(r, str):
- return self.evaluate_path_join(l, r)
- if isinstance(l, int) and isinstance(r, int):
- if r == 0:
- raise InvalidCode('Division by zero.')
- return l // r
- raise InvalidCode('Division works only with strings or integers.')
-
- def evaluate_arithmeticstatement(self, cur):
- l = self.evaluate_statement(cur.left)
- if is_disabler(l):
- return l
- r = self.evaluate_statement(cur.right)
- if is_disabler(r):
- return r
-
- if cur.operation == 'add':
- if isinstance(l, dict) and isinstance(r, dict):
- return {**l, **r}
- try:
- return l + r
- except Exception as e:
- raise InvalidCode('Invalid use of addition: ' + str(e))
- elif cur.operation == 'sub':
- if not isinstance(l, int) or not isinstance(r, int):
- raise InvalidCode('Subtraction works only with integers.')
- return l - r
- elif cur.operation == 'mul':
- if not isinstance(l, int) or not isinstance(r, int):
- raise InvalidCode('Multiplication works only with integers.')
- return l * r
- elif cur.operation == 'div':
- return self.evaluate_division(l, r)
- elif cur.operation == 'mod':
- if not isinstance(l, int) or not isinstance(r, int):
- raise InvalidCode('Modulo works only with integers.')
- return l % r
- else:
- raise InvalidCode('You broke me.')
-
- def evaluate_ternary(self, node):
- assert(isinstance(node, mparser.TernaryNode))
- result = self.evaluate_statement(node.condition)
- if is_disabler(result):
- return result
- if not isinstance(result, bool):
- raise InterpreterException('Ternary condition is not boolean.')
- if result:
- return self.evaluate_statement(node.trueblock)
- else:
- return self.evaluate_statement(node.falseblock)
-
- def evaluate_foreach(self, node):
- assert(isinstance(node, mparser.ForeachClauseNode))
- items = self.evaluate_statement(node.items)
-
- if isinstance(items, list):
- if len(node.varnames) != 1:
- raise InvalidArguments('Foreach on array does not unpack')
- varname = node.varnames[0].value
- for item in items:
- self.set_variable(varname, item)
- try:
- self.evaluate_codeblock(node.block)
- except ContinueRequest:
- continue
- except BreakRequest:
- break
- elif isinstance(items, dict):
- if len(node.varnames) != 2:
- raise InvalidArguments('Foreach on dict unpacks key and value')
- for key, value in items.items():
- self.set_variable(node.varnames[0].value, key)
- self.set_variable(node.varnames[1].value, value)
- try:
- self.evaluate_codeblock(node.block)
- except ContinueRequest:
- continue
- except BreakRequest:
- break
- else:
- raise InvalidArguments('Items of foreach loop must be an array or a dict')
-
- def evaluate_plusassign(self, node):
- assert(isinstance(node, mparser.PlusAssignmentNode))
- varname = node.var_name
- addition = self.evaluate_statement(node.value)
- if is_disabler(addition):
- self.set_variable(varname, addition)
- return
- # Remember that all variables are immutable. We must always create a
- # full new variable and then assign it.
- old_variable = self.get_variable(varname)
- if isinstance(old_variable, str):
- if not isinstance(addition, str):
- raise InvalidArguments('The += operator requires a string on the right hand side if the variable on the left is a string')
- new_value = old_variable + addition
- elif isinstance(old_variable, int):
- if not isinstance(addition, int):
- raise InvalidArguments('The += operator requires an int on the right hand side if the variable on the left is an int')
- new_value = old_variable + addition
- elif isinstance(old_variable, list):
- if isinstance(addition, list):
- new_value = old_variable + addition
- else:
- new_value = old_variable + [addition]
- elif isinstance(old_variable, dict):
- if not isinstance(addition, dict):
- raise InvalidArguments('The += operator requires a dict on the right hand side if the variable on the left is a dict')
- new_value = {**old_variable, **addition}
- # Add other data types here.
- else:
- raise InvalidArguments('The += operator currently only works with arrays, dicts, strings or ints ')
- self.set_variable(varname, new_value)
-
- def evaluate_indexing(self, node):
- assert(isinstance(node, mparser.IndexNode))
- iobject = self.evaluate_statement(node.iobject)
- if is_disabler(iobject):
- return iobject
- if not hasattr(iobject, '__getitem__'):
- raise InterpreterException(
- 'Tried to index an object that doesn\'t support indexing.')
- index = self.evaluate_statement(node.index)
-
- if isinstance(iobject, dict):
- if not isinstance(index, str):
- raise InterpreterException('Key is not a string')
- try:
- return iobject[index]
- except KeyError:
- raise InterpreterException('Key %s is not in dict' % index)
- else:
- if not isinstance(index, int):
- raise InterpreterException('Index value is not an integer.')
- try:
- return iobject[index]
- except IndexError:
- raise InterpreterException('Index %d out of bounds of array of size %d.' % (index, len(iobject)))
-
- def function_call(self, node):
- func_name = node.func_name
- (posargs, kwargs) = self.reduce_arguments(node.args)
- if is_disabled(posargs, kwargs) and func_name != 'set_variable' and func_name != 'is_disabler':
- return Disabler()
- if func_name in self.funcs:
- func = self.funcs[func_name]
- if not getattr(func, 'no-args-flattening', False):
- posargs = flatten(posargs)
-
- self.current_node = node
- return func(node, posargs, kwargs)
- else:
- self.unknown_function_called(func_name)
-
- def method_call(self, node):
- invokable = node.source_object
- if isinstance(invokable, mparser.IdNode):
- object_name = invokable.value
- obj = self.get_variable(object_name)
- else:
- obj = self.evaluate_statement(invokable)
- method_name = node.name
- args = node.args
- if isinstance(obj, str):
- return self.string_method_call(obj, method_name, args)
- if isinstance(obj, bool):
- return self.bool_method_call(obj, method_name, args)
- if isinstance(obj, int):
- return self.int_method_call(obj, method_name, args)
- if isinstance(obj, list):
- return self.array_method_call(obj, method_name, args)
- if isinstance(obj, dict):
- return self.dict_method_call(obj, method_name, args)
- if isinstance(obj, mesonlib.File):
- raise InvalidArguments('File object "%s" is not callable.' % obj)
- if not isinstance(obj, InterpreterObject):
- raise InvalidArguments('Variable "%s" is not callable.' % object_name)
- (args, kwargs) = self.reduce_arguments(args)
- # Special case. This is the only thing you can do with a disabler
- # object. Every other use immediately returns the disabler object.
- if isinstance(obj, Disabler):
- if method_name == 'found':
- return False
- else:
- return Disabler()
- if is_disabled(args, kwargs):
- return Disabler()
- if method_name == 'extract_objects':
- self.validate_extraction(obj.held_object)
- obj.current_node = node
- return obj.method_call(method_name, args, kwargs)
-
- def bool_method_call(self, obj, method_name, args):
- (posargs, kwargs) = self.reduce_arguments(args)
- if is_disabled(posargs, kwargs):
- return Disabler()
- if method_name == 'to_string':
- if not posargs:
- if obj:
- return 'true'
- else:
- return 'false'
- elif len(posargs) == 2 and isinstance(posargs[0], str) and isinstance(posargs[1], str):
- if obj:
- return posargs[0]
- else:
- return posargs[1]
- else:
- raise InterpreterException('bool.to_string() must have either no arguments or exactly two string arguments that signify what values to return for true and false.')
- elif method_name == 'to_int':
- if obj:
- return 1
- else:
- return 0
- else:
- raise InterpreterException('Unknown method "%s" for a boolean.' % method_name)
-
- def int_method_call(self, obj, method_name, args):
- (posargs, kwargs) = self.reduce_arguments(args)
- if is_disabled(posargs, kwargs):
- return Disabler()
- if method_name == 'is_even':
- if not posargs:
- return obj % 2 == 0
- else:
- raise InterpreterException('int.is_even() must have no arguments.')
- elif method_name == 'is_odd':
- if not posargs:
- return obj % 2 != 0
- else:
- raise InterpreterException('int.is_odd() must have no arguments.')
- elif method_name == 'to_string':
- if not posargs:
- return str(obj)
- else:
- raise InterpreterException('int.to_string() must have no arguments.')
- else:
- raise InterpreterException('Unknown method "%s" for an integer.' % method_name)
-
- @staticmethod
- def _get_one_string_posarg(posargs, method_name):
- if len(posargs) > 1:
- m = '{}() must have zero or one arguments'
- raise InterpreterException(m.format(method_name))
- elif len(posargs) == 1:
- s = posargs[0]
- if not isinstance(s, str):
- m = '{}() argument must be a string'
- raise InterpreterException(m.format(method_name))
- return s
- return None
-
- def string_method_call(self, obj, method_name, args):
- (posargs, kwargs) = self.reduce_arguments(args)
- if is_disabled(posargs, kwargs):
- return Disabler()
- if method_name == 'strip':
- s = self._get_one_string_posarg(posargs, 'strip')
- if s is not None:
- return obj.strip(s)
- return obj.strip()
- elif method_name == 'format':
- return self.format_string(obj, args)
- elif method_name == 'to_upper':
- return obj.upper()
- elif method_name == 'to_lower':
- return obj.lower()
- elif method_name == 'underscorify':
- return re.sub(r'[^a-zA-Z0-9]', '_', obj)
- elif method_name == 'split':
- s = self._get_one_string_posarg(posargs, 'split')
- if s is not None:
- return obj.split(s)
- return obj.split()
- elif method_name == 'startswith' or method_name == 'contains' or method_name == 'endswith':
- s = posargs[0]
- if not isinstance(s, str):
- raise InterpreterException('Argument must be a string.')
- if method_name == 'startswith':
- return obj.startswith(s)
- elif method_name == 'contains':
- return obj.find(s) >= 0
- return obj.endswith(s)
- elif method_name == 'to_int':
- try:
- return int(obj)
- except Exception:
- raise InterpreterException('String {!r} cannot be converted to int'.format(obj))
- elif method_name == 'join':
- if len(posargs) != 1:
- raise InterpreterException('Join() takes exactly one argument.')
- strlist = posargs[0]
- check_stringlist(strlist)
- return obj.join(strlist)
- elif method_name == 'version_compare':
- if len(posargs) != 1:
- raise InterpreterException('Version_compare() takes exactly one argument.')
- cmpr = posargs[0]
- if not isinstance(cmpr, str):
- raise InterpreterException('Version_compare() argument must be a string.')
- return mesonlib.version_compare(obj, cmpr)
- raise InterpreterException('Unknown method "%s" for a string.' % method_name)
-
- def format_string(self, templ, args):
- if isinstance(args, mparser.ArgumentNode):
- args = args.arguments
- arg_strings = []
- for arg in args:
- arg = self.evaluate_statement(arg)
- if isinstance(arg, bool): # Python boolean is upper case.
- arg = str(arg).lower()
- arg_strings.append(str(arg))
-
- def arg_replace(match):
- idx = int(match.group(1))
- if idx >= len(arg_strings):
- raise InterpreterException('Format placeholder @{}@ out of range.'.format(idx))
- return arg_strings[idx]
-
- return re.sub(r'@(\d+)@', arg_replace, templ)
-
- def unknown_function_called(self, func_name):
- raise InvalidCode('Unknown function "%s".' % func_name)
-
- def array_method_call(self, obj, method_name, args):
- (posargs, kwargs) = self.reduce_arguments(args)
- if is_disabled(posargs, kwargs):
- return Disabler()
- if method_name == 'contains':
- return self.check_contains(obj, posargs)
- elif method_name == 'length':
- return len(obj)
- elif method_name == 'get':
- index = posargs[0]
- fallback = None
- if len(posargs) == 2:
- fallback = posargs[1]
- elif len(posargs) > 2:
- m = 'Array method \'get()\' only takes two arguments: the ' \
- 'index and an optional fallback value if the index is ' \
- 'out of range.'
- raise InvalidArguments(m)
- if not isinstance(index, int):
- raise InvalidArguments('Array index must be a number.')
- if index < -len(obj) or index >= len(obj):
- if fallback is None:
- m = 'Array index {!r} is out of bounds for array of size {!r}.'
- raise InvalidArguments(m.format(index, len(obj)))
- return fallback
- return obj[index]
- m = 'Arrays do not have a method called {!r}.'
- raise InterpreterException(m.format(method_name))
-
- def dict_method_call(self, obj, method_name, args):
- (posargs, kwargs) = self.reduce_arguments(args)
- if is_disabled(posargs, kwargs):
- return Disabler()
-
- if method_name in ('has_key', 'get'):
- if method_name == 'has_key':
- if len(posargs) != 1:
- raise InterpreterException('has_key() takes exactly one argument.')
- else:
- if len(posargs) not in (1, 2):
- raise InterpreterException('get() takes one or two arguments.')
-
- key = posargs[0]
- if not isinstance(key, (str)):
- raise InvalidArguments('Dictionary key must be a string.')
-
- has_key = key in obj
-
- if method_name == 'has_key':
- return has_key
-
- if has_key:
- return obj[key]
-
- if len(posargs) == 2:
- return posargs[1]
-
- raise InterpreterException('Key {!r} is not in the dictionary.'.format(key))
-
- if method_name == 'keys':
- if len(posargs) != 0:
- raise InterpreterException('keys() takes no arguments.')
- return list(obj.keys())
-
- raise InterpreterException('Dictionaries do not have a method called "%s".' % method_name)
-
- def reduce_arguments(self, args):
- assert(isinstance(args, mparser.ArgumentNode))
- if args.incorrect_order():
- raise InvalidArguments('All keyword arguments must be after positional arguments.')
- self.argument_depth += 1
- reduced_pos = [self.evaluate_statement(arg) for arg in args.arguments]
- reduced_kw = {}
- for key in args.kwargs.keys():
- a = args.kwargs[key]
- reduced_kw[key] = self.evaluate_statement(a)
- self.argument_depth -= 1
- final_kw = self.expand_default_kwargs(reduced_kw)
- return reduced_pos, final_kw
-
- def expand_default_kwargs(self, kwargs):
- if 'kwargs' not in kwargs:
- return kwargs
- to_expand = kwargs.pop('kwargs')
- if not isinstance(to_expand, dict):
- raise InterpreterException('Value of "kwargs" must be dictionary.')
- if 'kwargs' in to_expand:
- raise InterpreterException('Kwargs argument must not contain a "kwargs" entry. Points for thinking meta, though. :P')
- for k, v in to_expand.items():
- if k in kwargs:
- raise InterpreterException('Entry "{}" defined both as a keyword argument and in a "kwarg" entry.'.format(k))
- kwargs[k] = v
- return kwargs
-
- def assignment(self, node):
- assert(isinstance(node, mparser.AssignmentNode))
- if self.argument_depth != 0:
- raise InvalidArguments('''Tried to assign values inside an argument list.
-To specify a keyword argument, use : instead of =.''')
- var_name = node.var_name
- if not isinstance(var_name, str):
- raise InvalidArguments('Tried to assign value to a non-variable.')
- value = self.evaluate_statement(node.value)
- if not self.is_assignable(value):
- raise InvalidCode('Tried to assign an invalid value to variable.')
- # For mutable objects we need to make a copy on assignment
- if isinstance(value, MutableInterpreterObject):
- value = copy.deepcopy(value)
- self.set_variable(var_name, value)
- return None
-
- def set_variable(self, varname, variable):
- if variable is None:
- raise InvalidCode('Can not assign None to variable.')
- if not isinstance(varname, str):
- raise InvalidCode('First argument to set_variable must be a string.')
- if not self.is_assignable(variable):
- raise InvalidCode('Assigned value not of assignable type.')
- if re.match('[_a-zA-Z][_0-9a-zA-Z]*$', varname) is None:
- raise InvalidCode('Invalid variable name: ' + varname)
- if varname in self.builtin:
- raise InvalidCode('Tried to overwrite internal variable "%s"' % varname)
- self.variables[varname] = variable
-
- def get_variable(self, varname):
- if varname in self.builtin:
- return self.builtin[varname]
- if varname in self.variables:
- return self.variables[varname]
- raise InvalidCode('Unknown variable "%s".' % varname)
-
- def is_assignable(self, value):
- return isinstance(value, (InterpreterObject, dependencies.Dependency,
- str, int, list, dict, mesonlib.File))
-
- def is_elementary_type(self, v):
- return isinstance(v, (int, float, str, bool, list))
diff -Nru meson-0.53.2/mesonbuild/interpreter.py meson-0.61.2/mesonbuild/interpreter.py
--- meson-0.53.2/mesonbuild/interpreter.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/interpreter.py 1970-01-01 00:00:00.000000000 +0000
@@ -1,4486 +0,0 @@
-# Copyright 2012-2018 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 . import mparser
-from . import environment
-from . import coredata
-from . import dependencies
-from . import mlog
-from . import build
-from . import optinterpreter
-from . import compilers
-from .wrap import wrap, WrapMode
-from . import mesonlib
-from .mesonlib import FileMode, MachineChoice, Popen_safe, listify, extract_as_list, has_path_sep
-from .dependencies import ExternalProgram
-from .dependencies import InternalDependency, Dependency, NotFoundDependency, DependencyException
-from .depfile import DepFile
-from .interpreterbase import InterpreterBase
-from .interpreterbase import check_stringlist, flatten, noPosargs, noKwargs, stringArgs, permittedKwargs, noArgsFlattening
-from .interpreterbase import InterpreterException, InvalidArguments, InvalidCode, SubdirDoneRequest
-from .interpreterbase import InterpreterObject, MutableInterpreterObject, Disabler, disablerIfNotFound
-from .interpreterbase import FeatureNew, FeatureDeprecated, FeatureNewKwargs
-from .interpreterbase import ObjectHolder
-from .modules import ModuleReturnValue
-from .cmake import CMakeInterpreter
-
-from pathlib import Path, PurePath
-import os, shutil, uuid
-import re, shlex
-import subprocess
-import collections
-from itertools import chain
-import functools
-import typing as T
-
-import importlib
-
-permitted_method_kwargs = {
- 'partial_dependency': {'compile_args', 'link_args', 'links', 'includes',
- 'sources'},
-}
-
-def stringifyUserArguments(args):
- if isinstance(args, list):
- return '[%s]' % ', '.join([stringifyUserArguments(x) for x in args])
- elif isinstance(args, dict):
- return '{%s}' % ', '.join(['%s : %s' % (stringifyUserArguments(k), stringifyUserArguments(v)) for k, v in args.items()])
- elif isinstance(args, int):
- return str(args)
- elif isinstance(args, str):
- return "'%s'" % args
- raise InvalidArguments('Function accepts only strings, integers, lists and lists thereof.')
-
-
-class OverrideProgram(dependencies.ExternalProgram):
- pass
-
-
-class FeatureOptionHolder(InterpreterObject, ObjectHolder):
- def __init__(self, env, name, option):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, option)
- if option.is_auto():
- self.held_object = env.coredata.builtins['auto_features']
- self.name = name
- self.methods.update({'enabled': self.enabled_method,
- 'disabled': self.disabled_method,
- 'auto': self.auto_method,
- })
-
- @noPosargs
- @permittedKwargs({})
- def enabled_method(self, args, kwargs):
- return self.held_object.is_enabled()
-
- @noPosargs
- @permittedKwargs({})
- def disabled_method(self, args, kwargs):
- return self.held_object.is_disabled()
-
- @noPosargs
- @permittedKwargs({})
- def auto_method(self, args, kwargs):
- return self.held_object.is_auto()
-
-def extract_required_kwarg(kwargs, subproject, feature_check=None, default=True):
- val = kwargs.get('required', default)
- disabled = False
- required = False
- feature = None
- if isinstance(val, FeatureOptionHolder):
- if not feature_check:
- feature_check = FeatureNew('User option "feature"', '0.47.0')
- feature_check.use(subproject)
- option = val.held_object
- feature = val.name
- if option.is_disabled():
- disabled = True
- elif option.is_enabled():
- required = True
- elif isinstance(val, bool):
- required = val
- else:
- raise InterpreterException('required keyword argument must be boolean or a feature option')
-
- # Keep boolean value in kwargs to simplify other places where this kwarg is
- # checked.
- kwargs['required'] = required
-
- return disabled, required, feature
-
-def extract_search_dirs(kwargs):
- search_dirs = mesonlib.stringlistify(kwargs.get('dirs', []))
- search_dirs = [Path(d).expanduser() for d in search_dirs]
- for d in search_dirs:
- if mesonlib.is_windows() and d.root.startswith('\\'):
- # a Unix-path starting with `/` that is not absolute on Windows.
- # discard without failing for end-user ease of cross-platform directory arrays
- continue
- if not d.is_absolute():
- raise InvalidCode('Search directory {} is not an absolute path.'.format(d))
- return list(map(str, search_dirs))
-
-class TryRunResultHolder(InterpreterObject):
- def __init__(self, res):
- super().__init__()
- self.res = res
- self.methods.update({'returncode': self.returncode_method,
- 'compiled': self.compiled_method,
- 'stdout': self.stdout_method,
- 'stderr': self.stderr_method,
- })
-
- @noPosargs
- @permittedKwargs({})
- def returncode_method(self, args, kwargs):
- return self.res.returncode
-
- @noPosargs
- @permittedKwargs({})
- def compiled_method(self, args, kwargs):
- return self.res.compiled
-
- @noPosargs
- @permittedKwargs({})
- def stdout_method(self, args, kwargs):
- return self.res.stdout
-
- @noPosargs
- @permittedKwargs({})
- def stderr_method(self, args, kwargs):
- return self.res.stderr
-
-class RunProcess(InterpreterObject):
-
- def __init__(self, cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir=False, check=False, capture=True):
- super().__init__()
- if not isinstance(cmd, ExternalProgram):
- raise AssertionError('BUG: RunProcess must be passed an ExternalProgram')
- self.capture = capture
- pc, self.stdout, self.stderr = self.run_command(cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check)
- self.returncode = pc.returncode
- self.methods.update({'returncode': self.returncode_method,
- 'stdout': self.stdout_method,
- 'stderr': self.stderr_method,
- })
-
- def run_command(self, cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check=False):
- command_array = cmd.get_command() + args
- menv = {'MESON_SOURCE_ROOT': source_dir,
- 'MESON_BUILD_ROOT': build_dir,
- 'MESON_SUBDIR': subdir,
- 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in mesonintrospect]),
- }
- if in_builddir:
- cwd = os.path.join(build_dir, subdir)
- else:
- cwd = os.path.join(source_dir, subdir)
- child_env = os.environ.copy()
- child_env.update(menv)
- child_env = env.get_env(child_env)
- stdout = subprocess.PIPE if self.capture else subprocess.DEVNULL
- mlog.debug('Running command:', ' '.join(command_array))
- try:
- p, o, e = Popen_safe(command_array, stdout=stdout, env=child_env, cwd=cwd)
- if self.capture:
- mlog.debug('--- stdout ---')
- mlog.debug(o)
- else:
- o = ''
- mlog.debug('--- stdout disabled ---')
- mlog.debug('--- stderr ---')
- mlog.debug(e)
- mlog.debug('')
-
- if check and p.returncode != 0:
- raise InterpreterException('Command "{}" failed with status {}.'.format(' '.join(command_array), p.returncode))
-
- return p, o, e
- except FileNotFoundError:
- raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array))
-
- @noPosargs
- @permittedKwargs({})
- def returncode_method(self, args, kwargs):
- return self.returncode
-
- @noPosargs
- @permittedKwargs({})
- def stdout_method(self, args, kwargs):
- return self.stdout
-
- @noPosargs
- @permittedKwargs({})
- def stderr_method(self, args, kwargs):
- return self.stderr
-
-class ConfigureFileHolder(InterpreterObject, ObjectHolder):
-
- def __init__(self, subdir, sourcename, targetname, configuration_data):
- InterpreterObject.__init__(self)
- obj = build.ConfigureFile(subdir, sourcename, targetname, configuration_data)
- ObjectHolder.__init__(self, obj)
-
-
-class EnvironmentVariablesHolder(MutableInterpreterObject, ObjectHolder):
- def __init__(self, initial_values=None):
- MutableInterpreterObject.__init__(self)
- ObjectHolder.__init__(self, build.EnvironmentVariables())
- self.methods.update({'set': self.set_method,
- 'append': self.append_method,
- 'prepend': self.prepend_method,
- })
- if isinstance(initial_values, dict):
- for k, v in initial_values.items():
- self.set_method([k, v], {})
- elif isinstance(initial_values, list):
- for e in initial_values:
- if '=' not in e:
- raise InterpreterException('Env var definition must be of type key=val.')
- (k, val) = e.split('=', 1)
- k = k.strip()
- val = val.strip()
- if ' ' in k:
- raise InterpreterException('Env var key must not have spaces in it.')
- self.set_method([k, val], {})
- elif initial_values:
- raise AssertionError('Unsupported EnvironmentVariablesHolder initial_values')
-
- def __repr__(self):
- repr_str = "<{0}: {1}>"
- return repr_str.format(self.__class__.__name__, self.held_object.envvars)
-
- def add_var(self, method, args, kwargs):
- if not isinstance(kwargs.get("separator", ""), str):
- raise InterpreterException("EnvironmentVariablesHolder methods 'separator'"
- " argument needs to be a string.")
- if len(args) < 2:
- raise InterpreterException("EnvironmentVariablesHolder methods require at least"
- "2 arguments, first is the name of the variable and"
- " following one are values")
- # Warn when someone tries to use append() or prepend() on an env var
- # which already has an operation set on it. People seem to think that
- # multiple append/prepend operations stack, but they don't.
- if method != self.held_object.set and self.held_object.has_name(args[0]):
- mlog.warning('Overriding previous value of environment variable {!r} with a new one'
- .format(args[0]), location=self.current_node)
- self.held_object.add_var(method, args[0], args[1:], kwargs)
-
- @stringArgs
- @permittedKwargs({'separator'})
- def set_method(self, args, kwargs):
- self.add_var(self.held_object.set, args, kwargs)
-
- @stringArgs
- @permittedKwargs({'separator'})
- def append_method(self, args, kwargs):
- self.add_var(self.held_object.append, args, kwargs)
-
- @stringArgs
- @permittedKwargs({'separator'})
- def prepend_method(self, args, kwargs):
- self.add_var(self.held_object.prepend, args, kwargs)
-
-
-class ConfigurationDataHolder(MutableInterpreterObject, ObjectHolder):
- def __init__(self, pv, initial_values=None):
- MutableInterpreterObject.__init__(self)
- self.used = False # These objects become immutable after use in configure_file.
- ObjectHolder.__init__(self, build.ConfigurationData(), pv)
- self.methods.update({'set': self.set_method,
- 'set10': self.set10_method,
- 'set_quoted': self.set_quoted_method,
- 'has': self.has_method,
- 'get': self.get_method,
- 'get_unquoted': self.get_unquoted_method,
- 'merge_from': self.merge_from_method,
- })
- if isinstance(initial_values, dict):
- for k, v in initial_values.items():
- self.set_method([k, v], {})
- elif initial_values:
- raise AssertionError('Unsupported ConfigurationDataHolder initial_values')
-
- def is_used(self):
- return self.used
-
- def mark_used(self):
- self.used = True
-
- def validate_args(self, args, kwargs):
- if len(args) == 1 and isinstance(args[0], list) and len(args[0]) == 2:
- mlog.deprecation('Passing a list as the single argument to '
- 'configuration_data.set is deprecated. This will '
- 'become a hard error in the future.',
- location=self.current_node)
- args = args[0]
-
- if len(args) != 2:
- raise InterpreterException("Configuration set requires 2 arguments.")
- if self.used:
- raise InterpreterException("Can not set values on configuration object that has been used.")
- name, val = args
- if not isinstance(val, (int, str)):
- msg = 'Setting a configuration data value to {!r} is invalid, ' \
- 'and will fail at configure_file(). If you are using it ' \
- 'just to store some values, please use a dict instead.'
- mlog.deprecation(msg.format(val), location=self.current_node)
- desc = kwargs.get('description', None)
- if not isinstance(name, str):
- raise InterpreterException("First argument to set must be a string.")
- if desc is not None and not isinstance(desc, str):
- raise InterpreterException('Description must be a string.')
-
- return name, val, desc
-
- @noArgsFlattening
- def set_method(self, args, kwargs):
- (name, val, desc) = self.validate_args(args, kwargs)
- self.held_object.values[name] = (val, desc)
-
- def set_quoted_method(self, args, kwargs):
- (name, val, desc) = self.validate_args(args, kwargs)
- if not isinstance(val, str):
- raise InterpreterException("Second argument to set_quoted must be a string.")
- escaped_val = '\\"'.join(val.split('"'))
- self.held_object.values[name] = ('"' + escaped_val + '"', desc)
-
- def set10_method(self, args, kwargs):
- (name, val, desc) = self.validate_args(args, kwargs)
- if val:
- self.held_object.values[name] = (1, desc)
- else:
- self.held_object.values[name] = (0, desc)
-
- def has_method(self, args, kwargs):
- return args[0] in self.held_object.values
-
- @FeatureNew('configuration_data.get()', '0.38.0')
- @noArgsFlattening
- def get_method(self, args, kwargs):
- if len(args) < 1 or len(args) > 2:
- raise InterpreterException('Get method takes one or two arguments.')
- name = args[0]
- if name in self.held_object:
- return self.held_object.get(name)[0]
- if len(args) > 1:
- return args[1]
- raise InterpreterException('Entry %s not in configuration data.' % name)
-
- @FeatureNew('configuration_data.get_unquoted()', '0.44.0')
- def get_unquoted_method(self, args, kwargs):
- if len(args) < 1 or len(args) > 2:
- raise InterpreterException('Get method takes one or two arguments.')
- name = args[0]
- if name in self.held_object:
- val = self.held_object.get(name)[0]
- elif len(args) > 1:
- val = args[1]
- else:
- raise InterpreterException('Entry %s not in configuration data.' % name)
- if val[0] == '"' and val[-1] == '"':
- return val[1:-1]
- return val
-
- def get(self, name):
- return self.held_object.values[name] # (val, desc)
-
- def keys(self):
- return self.held_object.values.keys()
-
- def merge_from_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Merge_from takes one positional argument.')
- from_object = args[0]
- if not isinstance(from_object, ConfigurationDataHolder):
- raise InterpreterException('Merge_from argument must be a configuration data object.')
- from_object = from_object.held_object
- for k, v in from_object.values.items():
- self.held_object.values[k] = v
-
-# Interpreter objects can not be pickled so we must have
-# these wrappers.
-
-class DependencyHolder(InterpreterObject, ObjectHolder):
- def __init__(self, dep, pv):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, dep, pv)
- self.methods.update({'found': self.found_method,
- 'type_name': self.type_name_method,
- 'version': self.version_method,
- 'name': self.name_method,
- 'get_pkgconfig_variable': self.pkgconfig_method,
- 'get_configtool_variable': self.configtool_method,
- 'get_variable': self.variable_method,
- 'partial_dependency': self.partial_dependency_method,
- 'include_type': self.include_type_method,
- 'as_system': self.as_system_method,
- })
-
- def found(self):
- return self.found_method([], {})
-
- @noPosargs
- @permittedKwargs({})
- def type_name_method(self, args, kwargs):
- return self.held_object.type_name
-
- @noPosargs
- @permittedKwargs({})
- def found_method(self, args, kwargs):
- if self.held_object.type_name == 'internal':
- return True
- return self.held_object.found()
-
- @noPosargs
- @permittedKwargs({})
- def version_method(self, args, kwargs):
- return self.held_object.get_version()
-
- @noPosargs
- @permittedKwargs({})
- def name_method(self, args, kwargs):
- return self.held_object.get_name()
-
- @permittedKwargs({'define_variable', 'default'})
- def pkgconfig_method(self, args, kwargs):
- args = listify(args)
- if len(args) != 1:
- raise InterpreterException('get_pkgconfig_variable takes exactly one argument.')
- varname = args[0]
- if not isinstance(varname, str):
- raise InterpreterException('Variable name must be a string.')
- return self.held_object.get_pkgconfig_variable(varname, kwargs)
-
- @FeatureNew('dep.get_configtool_variable', '0.44.0')
- @permittedKwargs({})
- def configtool_method(self, args, kwargs):
- args = listify(args)
- if len(args) != 1:
- raise InterpreterException('get_configtool_variable takes exactly one argument.')
- varname = args[0]
- if not isinstance(varname, str):
- raise InterpreterException('Variable name must be a string.')
- return self.held_object.get_configtool_variable(varname)
-
- @FeatureNew('dep.partial_dependency', '0.46.0')
- @noPosargs
- @permittedKwargs(permitted_method_kwargs['partial_dependency'])
- def partial_dependency_method(self, args, kwargs):
- pdep = self.held_object.get_partial_dependency(**kwargs)
- return DependencyHolder(pdep, self.subproject)
-
- @FeatureNew('dep.get_variable', '0.51.0')
- @noPosargs
- @permittedKwargs({'cmake', 'pkgconfig', 'configtool', 'default_value', 'pkgconfig_define'})
- def variable_method(self, args, kwargs):
- return self.held_object.get_variable(**kwargs)
-
- @FeatureNew('dep.include_type', '0.52.0')
- @noPosargs
- @permittedKwargs({})
- def include_type_method(self, args, kwargs):
- return self.held_object.get_include_type()
-
- @FeatureNew('dep.as_system', '0.52.0')
- @permittedKwargs({})
- def as_system_method(self, args, kwargs):
- args = listify(args)
- new_is_system = 'system'
- if len(args) > 1:
- raise InterpreterException('as_system takes only one optional value')
- if len(args) == 1:
- new_is_system = args[0]
- new_dep = self.held_object.generate_system_dependency(new_is_system)
- return DependencyHolder(new_dep, self.subproject)
-
-class ExternalProgramHolder(InterpreterObject, ObjectHolder):
- def __init__(self, ep):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, ep)
- self.methods.update({'found': self.found_method,
- 'path': self.path_method})
- self.cached_version = None
-
- @noPosargs
- @permittedKwargs({})
- def found_method(self, args, kwargs):
- return self.found()
-
- @noPosargs
- @permittedKwargs({})
- def path_method(self, args, kwargs):
- return self.held_object.get_path()
-
- def found(self):
- return isinstance(self.held_object, build.Executable) or self.held_object.found()
-
- def get_command(self):
- return self.held_object.get_command()
-
- def get_name(self):
- return self.held_object.get_name()
-
- def get_version(self, interpreter):
- if not self.cached_version:
- raw_cmd = self.get_command() + ['--version']
- cmd = [self, '--version']
- res = interpreter.run_command_impl(interpreter.current_node, cmd, {}, True)
- if res.returncode != 0:
- m = 'Running {!r} failed'
- raise InterpreterException(m.format(raw_cmd))
- output = res.stdout.strip()
- if not output:
- output = res.stderr.strip()
- match = re.search(r'([0-9][0-9\.]+)', output)
- if not match:
- m = 'Could not find a version number in output of {!r}'
- raise InterpreterException(m.format(raw_cmd))
- self.cached_version = match.group(1)
- return self.cached_version
-
-class ExternalLibraryHolder(InterpreterObject, ObjectHolder):
- def __init__(self, el, pv):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, el, pv)
- self.methods.update({'found': self.found_method,
- 'type_name': self.type_name_method,
- 'partial_dependency': self.partial_dependency_method,
- })
-
- def found(self):
- return self.held_object.found()
-
- @noPosargs
- @permittedKwargs({})
- def type_name_method(self, args, kwargs):
- return self.held_object.type_name
-
- @noPosargs
- @permittedKwargs({})
- def found_method(self, args, kwargs):
- return self.found()
-
- def get_name(self):
- return self.held_object.name
-
- def get_compile_args(self):
- return self.held_object.get_compile_args()
-
- def get_link_args(self):
- return self.held_object.get_link_args()
-
- def get_exe_args(self):
- return self.held_object.get_exe_args()
-
- @FeatureNew('dep.partial_dependency', '0.46.0')
- @noPosargs
- @permittedKwargs(permitted_method_kwargs['partial_dependency'])
- def partial_dependency_method(self, args, kwargs):
- pdep = self.held_object.get_partial_dependency(**kwargs)
- return DependencyHolder(pdep, self.subproject)
-
-class GeneratorHolder(InterpreterObject, ObjectHolder):
- @FeatureNewKwargs('generator', '0.43.0', ['capture'])
- def __init__(self, interp, args, kwargs):
- self.interpreter = interp
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, build.Generator(args, kwargs), interp.subproject)
- self.methods.update({'process': self.process_method})
-
- @FeatureNewKwargs('generator.process', '0.45.0', ['preserve_path_from'])
- @permittedKwargs({'extra_args', 'preserve_path_from'})
- def process_method(self, args, kwargs):
- extras = mesonlib.stringlistify(kwargs.get('extra_args', []))
- if 'preserve_path_from' in kwargs:
- preserve_path_from = kwargs['preserve_path_from']
- if not isinstance(preserve_path_from, str):
- raise InvalidArguments('Preserve_path_from must be a string.')
- preserve_path_from = os.path.normpath(preserve_path_from)
- if not os.path.isabs(preserve_path_from):
- # This is a bit of a hack. Fix properly before merging.
- raise InvalidArguments('Preserve_path_from must be an absolute path for now. Sorry.')
- else:
- preserve_path_from = None
- gl = self.held_object.process_files('Generator', args, self.interpreter,
- preserve_path_from, extra_args=extras)
- return GeneratedListHolder(gl)
-
-
-class GeneratedListHolder(InterpreterObject, ObjectHolder):
- def __init__(self, arg1, extra_args=None):
- InterpreterObject.__init__(self)
- if isinstance(arg1, GeneratorHolder):
- ObjectHolder.__init__(self, build.GeneratedList(arg1.held_object, extra_args if extra_args is not None else []))
- else:
- ObjectHolder.__init__(self, arg1)
-
- def __repr__(self):
- r = '<{}: {!r}>'
- return r.format(self.__class__.__name__, self.held_object.get_outputs())
-
- def add_file(self, a):
- self.held_object.add_file(a)
-
-# A machine that's statically known from the cross file
-class MachineHolder(InterpreterObject, ObjectHolder):
- def __init__(self, machine_info):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, machine_info)
- self.methods.update({'system': self.system_method,
- 'cpu': self.cpu_method,
- 'cpu_family': self.cpu_family_method,
- 'endian': self.endian_method,
- })
-
- @noPosargs
- @permittedKwargs({})
- def cpu_family_method(self, args, kwargs):
- return self.held_object.cpu_family
-
- @noPosargs
- @permittedKwargs({})
- def cpu_method(self, args, kwargs):
- return self.held_object.cpu
-
- @noPosargs
- @permittedKwargs({})
- def system_method(self, args, kwargs):
- return self.held_object.system
-
- @noPosargs
- @permittedKwargs({})
- def endian_method(self, args, kwargs):
- return self.held_object.endian
-
-class IncludeDirsHolder(InterpreterObject, ObjectHolder):
- def __init__(self, idobj):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, idobj)
-
-class Headers(InterpreterObject):
-
- def __init__(self, sources, kwargs):
- InterpreterObject.__init__(self)
- self.sources = sources
- self.install_subdir = kwargs.get('subdir', '')
- if os.path.isabs(self.install_subdir):
- mlog.deprecation('Subdir keyword must not be an absolute path. This will be a hard error in the next release.')
- self.custom_install_dir = kwargs.get('install_dir', None)
- self.custom_install_mode = kwargs.get('install_mode', None)
- if self.custom_install_dir is not None:
- if not isinstance(self.custom_install_dir, str):
- raise InterpreterException('Custom_install_dir must be a string.')
-
- def set_install_subdir(self, subdir):
- self.install_subdir = subdir
-
- def get_install_subdir(self):
- return self.install_subdir
-
- def get_sources(self):
- return self.sources
-
- def get_custom_install_dir(self):
- return self.custom_install_dir
-
- def get_custom_install_mode(self):
- return self.custom_install_mode
-
-class DataHolder(InterpreterObject, ObjectHolder):
- def __init__(self, data):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, data)
-
- def get_source_subdir(self):
- return self.held_object.source_subdir
-
- def get_sources(self):
- return self.held_object.sources
-
- def get_install_dir(self):
- return self.held_object.install_dir
-
-class InstallDir(InterpreterObject):
- def __init__(self, src_subdir, inst_subdir, install_dir, install_mode, exclude, strip_directory):
- InterpreterObject.__init__(self)
- self.source_subdir = src_subdir
- self.installable_subdir = inst_subdir
- self.install_dir = install_dir
- self.install_mode = install_mode
- self.exclude = exclude
- self.strip_directory = strip_directory
-
-class Man(InterpreterObject):
-
- def __init__(self, sources, kwargs):
- InterpreterObject.__init__(self)
- self.sources = sources
- self.validate_sources()
- self.custom_install_dir = kwargs.get('install_dir', None)
- self.custom_install_mode = kwargs.get('install_mode', None)
- if self.custom_install_dir is not None and not isinstance(self.custom_install_dir, str):
- raise InterpreterException('Custom_install_dir must be a string.')
-
- def validate_sources(self):
- for s in self.sources:
- try:
- num = int(s.split('.')[-1])
- except (IndexError, ValueError):
- num = 0
- if num < 1 or num > 8:
- raise InvalidArguments('Man file must have a file extension of a number between 1 and 8')
-
- def get_custom_install_dir(self):
- return self.custom_install_dir
-
- def get_custom_install_mode(self):
- return self.custom_install_mode
-
- def get_sources(self):
- return self.sources
-
-class GeneratedObjectsHolder(InterpreterObject, ObjectHolder):
- def __init__(self, held_object):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, held_object)
-
-class TargetHolder(InterpreterObject, ObjectHolder):
- def __init__(self, target, interp):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, target, interp.subproject)
- self.interpreter = interp
-
-class BuildTargetHolder(TargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
- self.methods.update({'extract_objects': self.extract_objects_method,
- 'extract_all_objects': self.extract_all_objects_method,
- 'get_id': self.get_id_method,
- 'outdir': self.outdir_method,
- 'full_path': self.full_path_method,
- 'private_dir_include': self.private_dir_include_method,
- })
-
- def __repr__(self):
- r = '<{} {}: {}>'
- h = self.held_object
- return r.format(self.__class__.__name__, h.get_id(), h.filename)
-
- def is_cross(self):
- return not self.held_object.environment.machines.matches_build_machine(self.held_object.for_machine)
-
- @noPosargs
- @permittedKwargs({})
- def private_dir_include_method(self, args, kwargs):
- return IncludeDirsHolder(build.IncludeDirs('', [], False,
- [self.interpreter.backend.get_target_private_dir(self.held_object)]))
-
- @noPosargs
- @permittedKwargs({})
- def full_path_method(self, args, kwargs):
- return self.interpreter.backend.get_target_filename_abs(self.held_object)
-
- @noPosargs
- @permittedKwargs({})
- def outdir_method(self, args, kwargs):
- return self.interpreter.backend.get_target_dir(self.held_object)
-
- @permittedKwargs({})
- def extract_objects_method(self, args, kwargs):
- gobjs = self.held_object.extract_objects(args)
- return GeneratedObjectsHolder(gobjs)
-
- @FeatureNewKwargs('extract_all_objects', '0.46.0', ['recursive'])
- @noPosargs
- @permittedKwargs({'recursive'})
- def extract_all_objects_method(self, args, kwargs):
- recursive = kwargs.get('recursive', False)
- gobjs = self.held_object.extract_all_objects(recursive)
- if gobjs.objlist and 'recursive' not in kwargs:
- mlog.warning('extract_all_objects called without setting recursive '
- 'keyword argument. Meson currently defaults to '
- 'non-recursive to maintain backward compatibility but '
- 'the default will be changed in the future.',
- location=self.current_node)
- return GeneratedObjectsHolder(gobjs)
-
- @noPosargs
- @permittedKwargs({})
- def get_id_method(self, args, kwargs):
- return self.held_object.get_id()
-
-class ExecutableHolder(BuildTargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
-
-class StaticLibraryHolder(BuildTargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
-
-class SharedLibraryHolder(BuildTargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
- # Set to True only when called from self.func_shared_lib().
- target.shared_library_only = False
-
-class BothLibrariesHolder(BuildTargetHolder):
- def __init__(self, shared_holder, static_holder, interp):
- # FIXME: This build target always represents the shared library, but
- # that should be configurable.
- super().__init__(shared_holder.held_object, interp)
- self.shared_holder = shared_holder
- self.static_holder = static_holder
- self.methods.update({'get_shared_lib': self.get_shared_lib_method,
- 'get_static_lib': self.get_static_lib_method,
- })
-
- def __repr__(self):
- r = '<{} {}: {}, {}: {}>'
- h1 = self.shared_holder.held_object
- h2 = self.static_holder.held_object
- return r.format(self.__class__.__name__, h1.get_id(), h1.filename, h2.get_id(), h2.filename)
-
- @noPosargs
- @permittedKwargs({})
- def get_shared_lib_method(self, args, kwargs):
- return self.shared_holder
-
- @noPosargs
- @permittedKwargs({})
- def get_static_lib_method(self, args, kwargs):
- return self.static_holder
-
-class SharedModuleHolder(BuildTargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
-
-class JarHolder(BuildTargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
-
-class CustomTargetIndexHolder(InterpreterObject, ObjectHolder):
- def __init__(self, object_to_hold):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, object_to_hold)
-
-class CustomTargetHolder(TargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
- self.methods.update({'full_path': self.full_path_method,
- })
-
- def __repr__(self):
- r = '<{} {}: {}>'
- h = self.held_object
- return r.format(self.__class__.__name__, h.get_id(), h.command)
-
- @noPosargs
- @permittedKwargs({})
- def full_path_method(self, args, kwargs):
- return self.interpreter.backend.get_target_filename_abs(self.held_object)
-
- def __getitem__(self, index):
- return CustomTargetIndexHolder(self.held_object[index])
-
- def __setitem__(self, index, value): # lgtm[py/unexpected-raise-in-special-method]
- raise InterpreterException('Cannot set a member of a CustomTarget')
-
- def __delitem__(self, index): # lgtm[py/unexpected-raise-in-special-method]
- raise InterpreterException('Cannot delete a member of a CustomTarget')
-
- def outdir_include(self):
- return IncludeDirsHolder(build.IncludeDirs('', [], False,
- [os.path.join('@BUILD_ROOT@', self.interpreter.backend.get_target_dir(self.held_object))]))
-
-class RunTargetHolder(TargetHolder):
- def __init__(self, target, interp):
- super().__init__(target, interp)
-
- def __repr__(self):
- r = '<{} {}: {}>'
- h = self.held_object
- return r.format(self.__class__.__name__, h.get_id(), h.command)
-
-class Test(InterpreterObject):
- def __init__(self, name: str, project: str, suite: T.List[str], exe: build.Executable,
- depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]],
- is_parallel: bool, cmd_args: T.List[str], env: build.EnvironmentVariables,
- should_fail: bool, timeout: int, workdir: T.Optional[str], protocol: str,
- priority: int):
- InterpreterObject.__init__(self)
- self.name = name
- self.suite = suite
- self.project_name = project
- self.exe = exe
- self.depends = depends
- self.is_parallel = is_parallel
- self.cmd_args = cmd_args
- self.env = env
- self.should_fail = should_fail
- self.timeout = timeout
- self.workdir = workdir
- self.protocol = protocol
- self.priority = priority
-
- def get_exe(self):
- return self.exe
-
- def get_name(self):
- return self.name
-
-class SubprojectHolder(InterpreterObject, ObjectHolder):
-
- def __init__(self, subinterpreter, subproject_dir, name):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, subinterpreter)
- self.name = name
- self.subproject_dir = subproject_dir
- self.methods.update({'get_variable': self.get_variable_method,
- 'found': self.found_method,
- })
-
- @noPosargs
- @permittedKwargs({})
- def found_method(self, args, kwargs):
- return self.found()
-
- def found(self):
- return self.held_object is not None
-
- @permittedKwargs({})
- @noArgsFlattening
- def get_variable_method(self, args, kwargs):
- if len(args) < 1 or len(args) > 2:
- raise InterpreterException('Get_variable takes one or two arguments.')
- if not self.found():
- raise InterpreterException('Subproject "%s/%s" disabled can\'t get_variable on it.' % (
- self.subproject_dir, self.name))
- varname = args[0]
- if not isinstance(varname, str):
- raise InterpreterException('Get_variable first argument must be a string.')
- try:
- return self.held_object.variables[varname]
- except KeyError:
- pass
-
- if len(args) == 2:
- return args[1]
-
- raise InvalidArguments('Requested variable "{0}" not found.'.format(varname))
-
-header_permitted_kwargs = set([
- 'required',
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
-])
-
-find_library_permitted_kwargs = set([
- 'has_headers',
- 'required',
- 'dirs',
- 'static',
-])
-
-find_library_permitted_kwargs |= set(['header_' + k for k in header_permitted_kwargs])
-
-class CompilerHolder(InterpreterObject):
- def __init__(self, compiler, env, subproject):
- InterpreterObject.__init__(self)
- self.compiler = compiler
- self.environment = env
- self.subproject = subproject
- self.methods.update({'compiles': self.compiles_method,
- 'links': self.links_method,
- 'get_id': self.get_id_method,
- 'get_linker_id': self.get_linker_id_method,
- 'compute_int': self.compute_int_method,
- 'sizeof': self.sizeof_method,
- 'get_define': self.get_define_method,
- 'check_header': self.check_header_method,
- 'has_header': self.has_header_method,
- 'has_header_symbol': self.has_header_symbol_method,
- 'run': self.run_method,
- 'has_function': self.has_function_method,
- 'has_member': self.has_member_method,
- 'has_members': self.has_members_method,
- 'has_type': self.has_type_method,
- 'alignment': self.alignment_method,
- 'version': self.version_method,
- 'cmd_array': self.cmd_array_method,
- 'find_library': self.find_library_method,
- 'has_argument': self.has_argument_method,
- 'has_function_attribute': self.has_func_attribute_method,
- 'get_supported_function_attributes': self.get_supported_function_attributes_method,
- 'has_multi_arguments': self.has_multi_arguments_method,
- 'get_supported_arguments': self.get_supported_arguments_method,
- 'first_supported_argument': self.first_supported_argument_method,
- 'has_link_argument': self.has_link_argument_method,
- 'has_multi_link_arguments': self.has_multi_link_arguments_method,
- 'get_supported_link_arguments': self.get_supported_link_arguments_method,
- 'first_supported_link_argument': self.first_supported_link_argument_method,
- 'unittest_args': self.unittest_args_method,
- 'symbols_have_underscore_prefix': self.symbols_have_underscore_prefix_method,
- 'get_argument_syntax': self.get_argument_syntax_method,
- })
-
- def _dep_msg(self, deps, endl):
- msg_single = 'with dependency {}'
- msg_many = 'with dependencies {}'
- if not deps:
- return endl
- if endl is None:
- endl = ''
- tpl = msg_many if len(deps) > 1 else msg_single
- names = []
- for d in deps:
- if isinstance(d, dependencies.ExternalLibrary):
- name = '-l' + d.name
- else:
- name = d.name
- names.append(name)
- return tpl.format(', '.join(names)) + endl
-
- @noPosargs
- @permittedKwargs({})
- def version_method(self, args, kwargs):
- return self.compiler.version
-
- @noPosargs
- @permittedKwargs({})
- def cmd_array_method(self, args, kwargs):
- return self.compiler.exelist
-
- def determine_args(self, kwargs, mode='link'):
- nobuiltins = kwargs.get('no_builtin_args', False)
- if not isinstance(nobuiltins, bool):
- raise InterpreterException('Type of no_builtin_args not a boolean.')
- args = []
- incdirs = extract_as_list(kwargs, 'include_directories')
- for i in incdirs:
- if not isinstance(i, IncludeDirsHolder):
- raise InterpreterException('Include directories argument must be an include_directories object.')
- for idir in i.held_object.get_incdirs():
- idir = os.path.join(self.environment.get_source_dir(),
- i.held_object.get_curdir(), idir)
- args += self.compiler.get_include_args(idir, False)
- if not nobuiltins:
- for_machine = Interpreter.machine_from_native_kwarg(kwargs)
- opts = self.environment.coredata.compiler_options[for_machine]
- args += self.compiler.get_option_compile_args(opts)
- if mode == 'link':
- args += self.compiler.get_option_link_args(opts)
- args += mesonlib.stringlistify(kwargs.get('args', []))
- return args
-
- def determine_dependencies(self, kwargs, endl=':'):
- deps = kwargs.get('dependencies', None)
- if deps is not None:
- deps = listify(deps)
- final_deps = []
- for d in deps:
- try:
- d = d.held_object
- except Exception:
- pass
- if isinstance(d, InternalDependency) or not isinstance(d, Dependency):
- raise InterpreterException('Dependencies must be external dependencies')
- final_deps.append(d)
- deps = final_deps
- return deps, self._dep_msg(deps, endl)
-
- @permittedKwargs({
- 'prefix',
- 'args',
- 'dependencies',
- })
- def alignment_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Alignment method takes exactly one positional argument.')
- check_stringlist(args)
- typename = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of alignment must be a string.')
- extra_args = mesonlib.stringlistify(kwargs.get('args', []))
- deps, msg = self.determine_dependencies(kwargs)
- result = self.compiler.alignment(typename, prefix, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- mlog.log('Checking for alignment of', mlog.bold(typename, True), msg, result)
- return result
-
- @permittedKwargs({
- 'name',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def run_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Run method takes exactly one positional argument.')
- code = args[0]
- if isinstance(code, mesonlib.File):
- code = mesonlib.File.from_absolute_file(
- code.rel_to_builddir(self.environment.source_dir))
- elif not isinstance(code, str):
- raise InvalidArguments('Argument must be string or file.')
- testname = kwargs.get('name', '')
- if not isinstance(testname, str):
- raise InterpreterException('Testname argument must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs, endl=None)
- result = self.compiler.run(code, self.environment, extra_args=extra_args,
- dependencies=deps)
- if len(testname) > 0:
- if not result.compiled:
- h = mlog.red('DID NOT COMPILE')
- elif result.returncode == 0:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO (%d)' % result.returncode)
- mlog.log('Checking if', mlog.bold(testname, True), msg, 'runs:', h)
- return TryRunResultHolder(result)
-
- @noPosargs
- @permittedKwargs({})
- def get_id_method(self, args, kwargs):
- return self.compiler.get_id()
-
- @noPosargs
- @permittedKwargs({})
- @FeatureNew('compiler.get_linker_id', '0.53.0')
- def get_linker_id_method(self, args, kwargs):
- return self.compiler.get_linker_id()
-
- @noPosargs
- @permittedKwargs({})
- def symbols_have_underscore_prefix_method(self, args, kwargs):
- '''
- Check if the compiler prefixes _ (underscore) to global C symbols
- See: https://en.wikipedia.org/wiki/Name_mangling#C
- '''
- return self.compiler.symbols_have_underscore_prefix(self.environment)
-
- @noPosargs
- @permittedKwargs({})
- def unittest_args_method(self, args, kwargs):
- '''
- This function is deprecated and should not be used.
- It can be removed in a future version of Meson.
- '''
- if not hasattr(self.compiler, 'get_feature_args'):
- raise InterpreterException('This {} compiler has no feature arguments.'.format(self.compiler.get_display_language()))
- build_to_src = os.path.relpath(self.environment.get_source_dir(), self.environment.get_build_dir())
- return self.compiler.get_feature_args({'unittest': 'true'}, build_to_src)
-
- @permittedKwargs({
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def has_member_method(self, args, kwargs):
- if len(args) != 2:
- raise InterpreterException('Has_member takes exactly two arguments.')
- check_stringlist(args)
- typename, membername = args
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_member must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- had, cached = self.compiler.has_members(typename, [membername], prefix,
- self.environment,
- extra_args=extra_args,
- dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if had:
- hadtxt = mlog.green('YES')
- else:
- hadtxt = mlog.red('NO')
- mlog.log('Checking whether type', mlog.bold(typename, True),
- 'has member', mlog.bold(membername, True), msg, hadtxt, cached)
- return had
-
- @permittedKwargs({
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def has_members_method(self, args, kwargs):
- if len(args) < 2:
- raise InterpreterException('Has_members needs at least two arguments.')
- check_stringlist(args)
- typename, *membernames = args
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_members must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- had, cached = self.compiler.has_members(typename, membernames, prefix,
- self.environment,
- extra_args=extra_args,
- dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if had:
- hadtxt = mlog.green('YES')
- else:
- hadtxt = mlog.red('NO')
- members = mlog.bold(', '.join(['"{}"'.format(m) for m in membernames]))
- mlog.log('Checking whether type', mlog.bold(typename, True),
- 'has members', members, msg, hadtxt, cached)
- return had
-
- @permittedKwargs({
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def has_function_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Has_function takes exactly one argument.')
- check_stringlist(args)
- funcname = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_function must be a string.')
- extra_args = self.determine_args(kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- had, cached = self.compiler.has_function(funcname, prefix, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if had:
- hadtxt = mlog.green('YES')
- else:
- hadtxt = mlog.red('NO')
- mlog.log('Checking for function', mlog.bold(funcname, True), msg, hadtxt, cached)
- return had
-
- @permittedKwargs({
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def has_type_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Has_type takes exactly one argument.')
- check_stringlist(args)
- typename = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_type must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- had, cached = self.compiler.has_type(typename, prefix, self.environment,
- extra_args=extra_args, dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if had:
- hadtxt = mlog.green('YES')
- else:
- hadtxt = mlog.red('NO')
- mlog.log('Checking for type', mlog.bold(typename, True), msg, hadtxt, cached)
- return had
-
- @FeatureNew('compiler.compute_int', '0.40.0')
- @permittedKwargs({
- 'prefix',
- 'low',
- 'high',
- 'guess',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def compute_int_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Compute_int takes exactly one argument.')
- check_stringlist(args)
- expression = args[0]
- prefix = kwargs.get('prefix', '')
- low = kwargs.get('low', None)
- high = kwargs.get('high', None)
- guess = kwargs.get('guess', None)
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of compute_int must be a string.')
- if low is not None and not isinstance(low, int):
- raise InterpreterException('Low argument of compute_int must be an int.')
- if high is not None and not isinstance(high, int):
- raise InterpreterException('High argument of compute_int must be an int.')
- if guess is not None and not isinstance(guess, int):
- raise InterpreterException('Guess argument of compute_int must be an int.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- res = self.compiler.compute_int(expression, low, high, guess, prefix,
- self.environment, extra_args=extra_args,
- dependencies=deps)
- mlog.log('Computing int of', mlog.bold(expression, True), msg, res)
- return res
-
- @permittedKwargs({
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def sizeof_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Sizeof takes exactly one argument.')
- check_stringlist(args)
- element = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of sizeof must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- esize = self.compiler.sizeof(element, prefix, self.environment,
- extra_args=extra_args, dependencies=deps)
- mlog.log('Checking for size of', mlog.bold(element, True), msg, esize)
- return esize
-
- @FeatureNew('compiler.get_define', '0.40.0')
- @permittedKwargs({
- 'prefix',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def get_define_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('get_define() takes exactly one argument.')
- check_stringlist(args)
- element = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of get_define() must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- value, cached = self.compiler.get_define(element, prefix, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- mlog.log('Fetching value of define', mlog.bold(element, True), msg, value, cached)
- return value
-
- @permittedKwargs({
- 'name',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def compiles_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('compiles method takes exactly one argument.')
- code = args[0]
- if isinstance(code, mesonlib.File):
- code = mesonlib.File.from_absolute_file(
- code.rel_to_builddir(self.environment.source_dir))
- elif not isinstance(code, str):
- raise InvalidArguments('Argument must be string or file.')
- testname = kwargs.get('name', '')
- if not isinstance(testname, str):
- raise InterpreterException('Testname argument must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs, endl=None)
- result, cached = self.compiler.compiles(code, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- if len(testname) > 0:
- if result:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- cached = mlog.blue('(cached)') if cached else ''
- mlog.log('Checking if', mlog.bold(testname, True), msg, 'compiles:', h, cached)
- return result
-
- @permittedKwargs({
- 'name',
- 'no_builtin_args',
- 'include_directories',
- 'args',
- 'dependencies',
- })
- def links_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('links method takes exactly one argument.')
- code = args[0]
- if isinstance(code, mesonlib.File):
- code = mesonlib.File.from_absolute_file(
- code.rel_to_builddir(self.environment.source_dir))
- elif not isinstance(code, str):
- raise InvalidArguments('Argument must be string or file.')
- testname = kwargs.get('name', '')
- if not isinstance(testname, str):
- raise InterpreterException('Testname argument must be a string.')
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs, endl=None)
- result, cached = self.compiler.links(code, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if len(testname) > 0:
- if result:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- mlog.log('Checking if', mlog.bold(testname, True), msg, 'links:', h, cached)
- return result
-
- @FeatureNew('compiler.check_header', '0.47.0')
- @FeatureNewKwargs('compiler.check_header', '0.50.0', ['required'])
- @permittedKwargs(header_permitted_kwargs)
- def check_header_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('check_header method takes exactly one argument.')
- check_stringlist(args)
- hname = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_header must be a string.')
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
- if disabled:
- mlog.log('Check usable header', mlog.bold(hname, True), 'skipped: feature', mlog.bold(feature), 'disabled')
- return False
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- haz, cached = self.compiler.check_header(hname, prefix, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if required and not haz:
- raise InterpreterException('{} header {!r} not usable'.format(self.compiler.get_display_language(), hname))
- elif haz:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- mlog.log('Check usable header', mlog.bold(hname, True), msg, h, cached)
- return haz
-
- @FeatureNewKwargs('compiler.has_header', '0.50.0', ['required'])
- @permittedKwargs(header_permitted_kwargs)
- def has_header_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('has_header method takes exactly one argument.')
- check_stringlist(args)
- hname = args[0]
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_header must be a string.')
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
- if disabled:
- mlog.log('Has header', mlog.bold(hname, True), 'skipped: feature', mlog.bold(feature), 'disabled')
- return False
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- haz, cached = self.compiler.has_header(hname, prefix, self.environment,
- extra_args=extra_args, dependencies=deps)
- cached = mlog.blue('(cached)') if cached else ''
- if required and not haz:
- raise InterpreterException('{} header {!r} not found'.format(self.compiler.get_display_language(), hname))
- elif haz:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- mlog.log('Has header', mlog.bold(hname, True), msg, h, cached)
- return haz
-
- @FeatureNewKwargs('compiler.has_header_symbol', '0.50.0', ['required'])
- @permittedKwargs(header_permitted_kwargs)
- def has_header_symbol_method(self, args, kwargs):
- if len(args) != 2:
- raise InterpreterException('has_header_symbol method takes exactly two arguments.')
- check_stringlist(args)
- hname, symbol = args
- prefix = kwargs.get('prefix', '')
- if not isinstance(prefix, str):
- raise InterpreterException('Prefix argument of has_header_symbol must be a string.')
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject, default=False)
- if disabled:
- mlog.log('Header <{0}> has symbol'.format(hname), mlog.bold(symbol, True), 'skipped: feature', mlog.bold(feature), 'disabled')
- return False
- extra_args = functools.partial(self.determine_args, kwargs)
- deps, msg = self.determine_dependencies(kwargs)
- haz, cached = self.compiler.has_header_symbol(hname, symbol, prefix, self.environment,
- extra_args=extra_args,
- dependencies=deps)
- if required and not haz:
- raise InterpreterException('{} symbol {} not found in header {}'.format(self.compiler.get_display_language(), symbol, hname))
- elif haz:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- cached = mlog.blue('(cached)') if cached else ''
- mlog.log('Header <{0}> has symbol'.format(hname), mlog.bold(symbol, True), msg, h, cached)
- return haz
-
- def notfound_library(self, libname):
- lib = dependencies.ExternalLibrary(libname, None,
- self.environment,
- self.compiler.language,
- silent=True)
- return ExternalLibraryHolder(lib, self.subproject)
-
- @FeatureNewKwargs('compiler.find_library', '0.51.0', ['static'])
- @FeatureNewKwargs('compiler.find_library', '0.50.0', ['has_headers'])
- @FeatureNewKwargs('compiler.find_library', '0.49.0', ['disabler'])
- @disablerIfNotFound
- @permittedKwargs(find_library_permitted_kwargs)
- def find_library_method(self, args, kwargs):
- # TODO add dependencies support?
- if len(args) != 1:
- raise InterpreterException('find_library method takes one argument.')
- libname = args[0]
- if not isinstance(libname, str):
- raise InterpreterException('Library name not a string.')
-
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
- if disabled:
- mlog.log('Library', mlog.bold(libname), 'skipped: feature', mlog.bold(feature), 'disabled')
- return self.notfound_library(libname)
-
- has_header_kwargs = {k[7:]: v for k, v in kwargs.items() if k.startswith('header_')}
- has_header_kwargs['required'] = required
- headers = mesonlib.stringlistify(kwargs.get('has_headers', []))
- for h in headers:
- if not self.has_header_method([h], has_header_kwargs):
- return self.notfound_library(libname)
-
- search_dirs = extract_search_dirs(kwargs)
-
- libtype = mesonlib.LibType.PREFER_SHARED
- if 'static' in kwargs:
- if not isinstance(kwargs['static'], bool):
- raise InterpreterException('static must be a boolean')
- libtype = mesonlib.LibType.STATIC if kwargs['static'] else mesonlib.LibType.SHARED
- linkargs = self.compiler.find_library(libname, self.environment, search_dirs, libtype)
- if required and not linkargs:
- raise InterpreterException(
- '{} library {!r} not found'.format(self.compiler.get_display_language(), libname))
- lib = dependencies.ExternalLibrary(libname, linkargs, self.environment,
- self.compiler.language)
- return ExternalLibraryHolder(lib, self.subproject)
-
- @permittedKwargs({})
- def has_argument_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- if len(args) != 1:
- raise InterpreterException('has_argument takes exactly one argument.')
- return self.has_multi_arguments_method(args, kwargs)
-
- @permittedKwargs({})
- def has_multi_arguments_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- result, cached = self.compiler.has_multi_arguments(args, self.environment)
- if result:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- cached = mlog.blue('(cached)') if cached else ''
- mlog.log(
- 'Compiler for {} supports arguments {}:'.format(
- self.compiler.get_display_language(), ' '.join(args)),
- h, cached)
- return result
-
- @FeatureNew('compiler.get_supported_arguments', '0.43.0')
- @permittedKwargs({})
- def get_supported_arguments_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- supported_args = []
- for arg in args:
- if self.has_argument_method(arg, kwargs):
- supported_args.append(arg)
- return supported_args
-
- @permittedKwargs({})
- def first_supported_argument_method(self, args, kwargs):
- for i in mesonlib.stringlistify(args):
- if self.has_argument_method(i, kwargs):
- mlog.log('First supported argument:', mlog.bold(i))
- return [i]
- mlog.log('First supported argument:', mlog.red('None'))
- return []
-
- @FeatureNew('compiler.has_link_argument', '0.46.0')
- @permittedKwargs({})
- def has_link_argument_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- if len(args) != 1:
- raise InterpreterException('has_link_argument takes exactly one argument.')
- return self.has_multi_link_arguments_method(args, kwargs)
-
- @FeatureNew('compiler.has_multi_link_argument', '0.46.0')
- @permittedKwargs({})
- def has_multi_link_arguments_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- result, cached = self.compiler.has_multi_link_arguments(args, self.environment)
- cached = mlog.blue('(cached)') if cached else ''
- if result:
- h = mlog.green('YES')
- else:
- h = mlog.red('NO')
- mlog.log(
- 'Compiler for {} supports link arguments {}:'.format(
- self.compiler.get_display_language(), ' '.join(args)),
- h, cached)
- return result
-
- @FeatureNew('compiler.get_supported_link_arguments_method', '0.46.0')
- @permittedKwargs({})
- def get_supported_link_arguments_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- supported_args = []
- for arg in args:
- if self.has_link_argument_method(arg, kwargs):
- supported_args.append(arg)
- return supported_args
-
- @FeatureNew('compiler.first_supported_link_argument_method', '0.46.0')
- @permittedKwargs({})
- def first_supported_link_argument_method(self, args, kwargs):
- for i in mesonlib.stringlistify(args):
- if self.has_link_argument_method(i, kwargs):
- mlog.log('First supported link argument:', mlog.bold(i))
- return [i]
- mlog.log('First supported link argument:', mlog.red('None'))
- return []
-
- @FeatureNew('compiler.has_function_attribute', '0.48.0')
- @permittedKwargs({})
- def has_func_attribute_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- if len(args) != 1:
- raise InterpreterException('has_func_attribute takes exactly one argument.')
- result, cached = self.compiler.has_func_attribute(args[0], self.environment)
- cached = mlog.blue('(cached)') if cached else ''
- h = mlog.green('YES') if result else mlog.red('NO')
- mlog.log('Compiler for {} supports function attribute {}:'.format(self.compiler.get_display_language(), args[0]), h, cached)
- return result
-
- @FeatureNew('compiler.get_supported_function_attributes', '0.48.0')
- @permittedKwargs({})
- def get_supported_function_attributes_method(self, args, kwargs):
- args = mesonlib.stringlistify(args)
- return [a for a in args if self.has_func_attribute_method(a, kwargs)]
-
- @FeatureNew('compiler.get_argument_syntax_method', '0.49.0')
- @noPosargs
- @noKwargs
- def get_argument_syntax_method(self, args, kwargs):
- return self.compiler.get_argument_syntax()
-
-
-ModuleState = collections.namedtuple('ModuleState', [
- 'source_root', 'build_to_src', 'subproject', 'subdir', 'current_lineno', 'environment',
- 'project_name', 'project_version', 'backend', 'targets',
- 'data', 'headers', 'man', 'global_args', 'project_args', 'build_machine',
- 'host_machine', 'target_machine', 'current_node'])
-
-class ModuleHolder(InterpreterObject, ObjectHolder):
- def __init__(self, modname, module, interpreter):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, module)
- self.modname = modname
- self.interpreter = interpreter
-
- def method_call(self, method_name, args, kwargs):
- try:
- fn = getattr(self.held_object, method_name)
- except AttributeError:
- raise InvalidArguments('Module %s does not have method %s.' % (self.modname, method_name))
- if method_name.startswith('_'):
- raise InvalidArguments('Function {!r} in module {!r} is private.'.format(method_name, self.modname))
- if not getattr(fn, 'no-args-flattening', False):
- args = flatten(args)
- # This is not 100% reliable but we can't use hash()
- # because the Build object contains dicts and lists.
- num_targets = len(self.interpreter.build.targets)
- state = ModuleState(
- source_root = self.interpreter.environment.get_source_dir(),
- build_to_src=mesonlib.relpath(self.interpreter.environment.get_source_dir(),
- self.interpreter.environment.get_build_dir()),
- subproject=self.interpreter.subproject,
- subdir=self.interpreter.subdir,
- current_lineno=self.interpreter.current_lineno,
- environment=self.interpreter.environment,
- project_name=self.interpreter.build.project_name,
- project_version=self.interpreter.build.dep_manifest[self.interpreter.active_projectname],
- # The backend object is under-used right now, but we will need it:
- # https://github.com/mesonbuild/meson/issues/1419
- backend=self.interpreter.backend,
- targets=self.interpreter.build.targets,
- data=self.interpreter.build.data,
- headers=self.interpreter.build.get_headers(),
- man=self.interpreter.build.get_man(),
- #global_args_for_build = self.interpreter.build.global_args.build,
- global_args = self.interpreter.build.global_args.host,
- #project_args_for_build = self.interpreter.build.projects_args.build.get(self.interpreter.subproject, {}),
- project_args = self.interpreter.build.projects_args.host.get(self.interpreter.subproject, {}),
- build_machine=self.interpreter.builtin['build_machine'].held_object,
- host_machine=self.interpreter.builtin['host_machine'].held_object,
- target_machine=self.interpreter.builtin['target_machine'].held_object,
- current_node=self.current_node
- )
- if self.held_object.is_snippet(method_name):
- value = fn(self.interpreter, state, args, kwargs)
- return self.interpreter.holderify(value)
- else:
- value = fn(state, args, kwargs)
- if num_targets != len(self.interpreter.build.targets):
- raise InterpreterException('Extension module altered internal state illegally.')
- return self.interpreter.module_method_callback(value)
-
-
-class Summary:
- def __init__(self, project_name, project_version):
- self.project_name = project_name
- self.project_version = project_version
- self.sections = collections.defaultdict(dict)
- self.max_key_len = 0
-
- def add_section(self, section, values, kwargs):
- bool_yn = kwargs.get('bool_yn', False)
- if not isinstance(bool_yn, bool):
- raise InterpreterException('bool_yn keyword argument must be boolean')
- for k, v in values.items():
- if k in self.sections[section]:
- raise InterpreterException('Summary section {!r} already have key {!r}'.format(section, k))
- formatted_values = []
- for i in listify(v):
- if not isinstance(i, (str, int)):
- m = 'Summary value in section {!r}, key {!r}, must be string, integer or boolean'
- raise InterpreterException(m.format(section, k))
- if bool_yn and isinstance(i, bool):
- formatted_values.append(mlog.green('YES') if i else mlog.red('NO'))
- else:
- formatted_values.append(i)
- if not formatted_values:
- formatted_values = ['']
- self.sections[section][k] = formatted_values
- self.max_key_len = max(self.max_key_len, len(k))
-
- def dump(self):
- mlog.log(self.project_name, mlog.normal_cyan(self.project_version))
- for section, values in self.sections.items():
- mlog.log('') # newline
- if section:
- mlog.log(' ', mlog.bold(section))
- for k, v in values.items():
- indent = self.max_key_len - len(k) + 3
- mlog.log(' ' * indent, k + ':', v[0])
- indent = self.max_key_len + 5
- for i in v[1:]:
- mlog.log(' ' * indent, i)
- mlog.log('') # newline
-
-
-class MesonMain(InterpreterObject):
- def __init__(self, build, interpreter):
- InterpreterObject.__init__(self)
- self.build = build
- self.interpreter = interpreter
- self._found_source_scripts = {}
- self.methods.update({'get_compiler': self.get_compiler_method,
- 'is_cross_build': self.is_cross_build_method,
- 'has_exe_wrapper': self.has_exe_wrapper_method,
- 'is_unity': self.is_unity_method,
- 'is_subproject': self.is_subproject_method,
- 'current_source_dir': self.current_source_dir_method,
- 'current_build_dir': self.current_build_dir_method,
- 'source_root': self.source_root_method,
- 'build_root': self.build_root_method,
- 'add_install_script': self.add_install_script_method,
- 'add_postconf_script': self.add_postconf_script_method,
- 'add_dist_script': self.add_dist_script_method,
- 'install_dependency_manifest': self.install_dependency_manifest_method,
- 'override_find_program': self.override_find_program_method,
- 'project_version': self.project_version_method,
- 'project_license': self.project_license_method,
- 'version': self.version_method,
- 'project_name': self.project_name_method,
- 'get_cross_property': self.get_cross_property_method,
- 'backend': self.backend_method,
- })
-
- def _find_source_script(self, name, args):
- # Prefer scripts in the current source directory
- search_dir = os.path.join(self.interpreter.environment.source_dir,
- self.interpreter.subdir)
- key = (name, search_dir)
- if key in self._found_source_scripts:
- found = self._found_source_scripts[key]
- else:
- found = dependencies.ExternalProgram(name, search_dir=search_dir)
- if found.found():
- self._found_source_scripts[key] = found
- else:
- m = 'Script or command {!r} not found or not executable'
- raise InterpreterException(m.format(name))
- return build.RunScript(found.get_command(), args)
-
- @permittedKwargs({})
- def add_install_script_method(self, args, kwargs):
- if len(args) < 1:
- raise InterpreterException('add_install_script takes one or more arguments')
- check_stringlist(args, 'add_install_script args must be strings')
- script = self._find_source_script(args[0], args[1:])
- self.build.install_scripts.append(script)
-
- @permittedKwargs({})
- def add_postconf_script_method(self, args, kwargs):
- if len(args) < 1:
- raise InterpreterException('add_postconf_script takes one or more arguments')
- check_stringlist(args, 'add_postconf_script arguments must be strings')
- script = self._find_source_script(args[0], args[1:])
- self.build.postconf_scripts.append(script)
-
- @permittedKwargs({})
- def add_dist_script_method(self, args, kwargs):
- if len(args) < 1:
- raise InterpreterException('add_dist_script takes one or more arguments')
- if len(args) > 1:
- FeatureNew('Calling "add_dist_script" with multiple arguments', '0.49.0').use(self.interpreter.subproject)
- check_stringlist(args, 'add_dist_script argument must be a string')
- if self.interpreter.subproject != '':
- raise InterpreterException('add_dist_script may not be used in a subproject.')
- script = self._find_source_script(args[0], args[1:])
- self.build.dist_scripts.append(script)
-
- @noPosargs
- @permittedKwargs({})
- def current_source_dir_method(self, args, kwargs):
- src = self.interpreter.environment.source_dir
- sub = self.interpreter.subdir
- if sub == '':
- return src
- return os.path.join(src, sub)
-
- @noPosargs
- @permittedKwargs({})
- def current_build_dir_method(self, args, kwargs):
- src = self.interpreter.environment.build_dir
- sub = self.interpreter.subdir
- if sub == '':
- return src
- return os.path.join(src, sub)
-
- @noPosargs
- @permittedKwargs({})
- def backend_method(self, args, kwargs):
- return self.interpreter.backend.name
-
- @noPosargs
- @permittedKwargs({})
- def source_root_method(self, args, kwargs):
- return self.interpreter.environment.source_dir
-
- @noPosargs
- @permittedKwargs({})
- def build_root_method(self, args, kwargs):
- return self.interpreter.environment.build_dir
-
- @noPosargs
- @permittedKwargs({})
- def has_exe_wrapper_method(self, args, kwargs):
- if self.is_cross_build_method(None, None) and \
- self.build.environment.need_exe_wrapper():
- if self.build.environment.exe_wrapper is None:
- return False
- # We return True when exe_wrap is defined, when it's not needed, and
- # when we're compiling natively. The last two are semantically confusing.
- # Need to revisit this.
- return True
-
- @noPosargs
- @permittedKwargs({})
- def is_cross_build_method(self, args, kwargs):
- return self.build.environment.is_cross_build()
-
- @permittedKwargs({'native'})
- def get_compiler_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('get_compiler_method must have one and only one argument.')
- cname = args[0]
- for_machine = Interpreter.machine_from_native_kwarg(kwargs)
- clist = self.interpreter.coredata.compilers[for_machine]
- if cname in clist:
- return CompilerHolder(clist[cname], self.build.environment, self.interpreter.subproject)
- raise InterpreterException('Tried to access compiler for unspecified language "%s".' % cname)
-
- @noPosargs
- @permittedKwargs({})
- def is_unity_method(self, args, kwargs):
- optval = self.interpreter.environment.coredata.get_builtin_option('unity')
- if optval == 'on' or (optval == 'subprojects' and self.interpreter.is_subproject()):
- return True
- return False
-
- @noPosargs
- @permittedKwargs({})
- def is_subproject_method(self, args, kwargs):
- return self.interpreter.is_subproject()
-
- @permittedKwargs({})
- def install_dependency_manifest_method(self, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Must specify manifest install file name')
- if not isinstance(args[0], str):
- raise InterpreterException('Argument must be a string.')
- self.build.dep_manifest_name = args[0]
-
- @FeatureNew('meson.override_find_program', '0.46.0')
- @permittedKwargs({})
- def override_find_program_method(self, args, kwargs):
- if len(args) != 2:
- raise InterpreterException('Override needs two arguments')
- name, exe = args
- if not isinstance(name, str):
- raise InterpreterException('First argument must be a string')
- if hasattr(exe, 'held_object'):
- exe = exe.held_object
- if isinstance(exe, mesonlib.File):
- abspath = exe.absolute_path(self.interpreter.environment.source_dir,
- self.interpreter.environment.build_dir)
- if not os.path.exists(abspath):
- raise InterpreterException('Tried to override %s with a file that does not exist.' % name)
- exe = OverrideProgram(abspath)
- if not isinstance(exe, (dependencies.ExternalProgram, build.Executable)):
- raise InterpreterException('Second argument must be an external program or executable.')
- self.interpreter.add_find_program_override(name, exe)
-
- @noPosargs
- @permittedKwargs({})
- def project_version_method(self, args, kwargs):
- return self.build.dep_manifest[self.interpreter.active_projectname]['version']
-
- @FeatureNew('meson.project_license()', '0.45.0')
- @noPosargs
- @permittedKwargs({})
- def project_license_method(self, args, kwargs):
- return self.build.dep_manifest[self.interpreter.active_projectname]['license']
-
- @noPosargs
- @permittedKwargs({})
- def version_method(self, args, kwargs):
- return coredata.version
-
- @noPosargs
- @permittedKwargs({})
- def project_name_method(self, args, kwargs):
- return self.interpreter.active_projectname
-
- @noArgsFlattening
- @permittedKwargs({})
- def get_cross_property_method(self, args, kwargs):
- if len(args) < 1 or len(args) > 2:
- raise InterpreterException('Must have one or two arguments.')
- propname = args[0]
- if not isinstance(propname, str):
- raise InterpreterException('Property name must be string.')
- try:
- props = self.interpreter.environment.properties.host
- return props[propname]
- except Exception:
- if len(args) == 2:
- return args[1]
- raise InterpreterException('Unknown cross property: %s.' % propname)
-
-
-known_library_kwargs = (
- build.known_shlib_kwargs |
- build.known_stlib_kwargs
-)
-
-known_build_target_kwargs = (
- known_library_kwargs |
- build.known_exe_kwargs |
- build.known_jar_kwargs |
- {'target_type'}
-)
-
-_base_test_args = {'args', 'depends', 'env', 'should_fail', 'timeout', 'workdir', 'suite', 'priority', 'protocol'}
-
-permitted_kwargs = {'add_global_arguments': {'language', 'native'},
- 'add_global_link_arguments': {'language', 'native'},
- 'add_languages': {'required'},
- 'add_project_link_arguments': {'language', 'native'},
- 'add_project_arguments': {'language', 'native'},
- 'add_test_setup': {'exe_wrapper', 'gdb', 'timeout_multiplier', 'env', 'is_default'},
- 'benchmark': _base_test_args,
- 'build_target': known_build_target_kwargs,
- 'configure_file': {'input',
- 'output',
- 'configuration',
- 'command',
- 'copy',
- 'depfile',
- 'install_dir',
- 'install_mode',
- 'capture',
- 'install',
- 'format',
- 'output_format',
- 'encoding'},
- 'custom_target': {'input',
- 'output',
- 'command',
- 'install',
- 'install_dir',
- 'install_mode',
- 'build_always',
- 'capture',
- 'depends',
- 'depend_files',
- 'depfile',
- 'build_by_default',
- 'build_always_stale',
- 'console'},
- 'dependency': {'default_options',
- 'embed',
- 'fallback',
- 'language',
- 'main',
- 'method',
- 'modules',
- 'cmake_module_path',
- 'optional_modules',
- 'native',
- 'not_found_message',
- 'required',
- 'static',
- 'version',
- 'private_headers',
- 'cmake_args',
- 'include_type',
- },
- 'declare_dependency': {'include_directories',
- 'link_with',
- 'sources',
- 'dependencies',
- 'compile_args',
- 'link_args',
- 'link_whole',
- 'version',
- },
- 'executable': build.known_exe_kwargs,
- 'find_program': {'required', 'native', 'version', 'dirs'},
- 'generator': {'arguments',
- 'output',
- 'depends',
- 'depfile',
- 'capture',
- 'preserve_path_from'},
- 'include_directories': {'is_system'},
- 'install_data': {'install_dir', 'install_mode', 'rename', 'sources'},
- 'install_headers': {'install_dir', 'install_mode', 'subdir'},
- 'install_man': {'install_dir', 'install_mode'},
- 'install_subdir': {'exclude_files', 'exclude_directories', 'install_dir', 'install_mode', 'strip_directory'},
- 'jar': build.known_jar_kwargs,
- 'project': {'version', 'meson_version', 'default_options', 'license', 'subproject_dir'},
- 'run_command': {'check', 'capture', 'env'},
- 'run_target': {'command', 'depends'},
- 'shared_library': build.known_shlib_kwargs,
- 'shared_module': build.known_shmod_kwargs,
- 'static_library': build.known_stlib_kwargs,
- 'both_libraries': known_library_kwargs,
- 'library': known_library_kwargs,
- 'subdir': {'if_found'},
- 'subproject': {'version', 'default_options', 'required'},
- 'test': set.union(_base_test_args, {'is_parallel'}),
- 'vcs_tag': {'input', 'output', 'fallback', 'command', 'replace_string'},
- }
-
-
-class Interpreter(InterpreterBase):
-
- def __init__(self, build, backend=None, subproject='', subdir='', subproject_dir='subprojects',
- modules = None, default_project_options=None, mock=False, ast=None):
- super().__init__(build.environment.get_source_dir(), subdir)
- self.an_unpicklable_object = mesonlib.an_unpicklable_object
- self.build = build
- self.environment = build.environment
- self.coredata = self.environment.get_coredata()
- self.backend = backend
- self.subproject = subproject
- self.summary = {}
- if modules is None:
- self.modules = {}
- else:
- self.modules = modules
- # Subproject directory is usually the name of the subproject, but can
- # be different for dependencies provided by wrap files.
- self.subproject_directory_name = subdir.split(os.path.sep)[-1]
- self.subproject_dir = subproject_dir
- self.option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt')
- if not mock and ast is None:
- self.load_root_meson_file()
- self.sanity_check_ast()
- elif ast is not None:
- self.ast = ast
- self.sanity_check_ast()
- self.builtin.update({'meson': MesonMain(build, self)})
- self.generators = []
- self.visited_subdirs = {}
- self.project_args_frozen = False
- self.global_args_frozen = False # implies self.project_args_frozen
- self.subprojects = {}
- self.subproject_stack = []
- self.configure_file_outputs = {}
- # Passed from the outside, only used in subprojects.
- if default_project_options:
- self.default_project_options = default_project_options.copy()
- else:
- self.default_project_options = {}
- self.project_default_options = {}
- self.build_func_dict()
- # build_def_files needs to be defined before parse_project is called
- self.build_def_files = [os.path.join(self.subdir, environment.build_filename)]
- if not mock:
- self.parse_project()
-
- # Re-initialize machine descriptions. We can do a better job now because we
- # have the compilers needed to gain more knowledge, so wipe out old
- # inference and start over.
- machines = self.build.environment.machines.miss_defaulting()
- machines.build = environment.detect_machine_info(self.coredata.compilers.build)
- self.build.environment.machines = machines.default_missing()
- assert self.build.environment.machines.build.cpu is not None
- assert self.build.environment.machines.host.cpu is not None
- assert self.build.environment.machines.target.cpu is not None
-
- self.builtin['build_machine'] = \
- MachineHolder(self.build.environment.machines.build)
- self.builtin['host_machine'] = \
- MachineHolder(self.build.environment.machines.host)
- self.builtin['target_machine'] = \
- MachineHolder(self.build.environment.machines.target)
-
- def get_non_matching_default_options(self):
- env = self.environment
- for def_opt_name, def_opt_value in self.project_default_options.items():
- for opts in env.coredata.get_all_options():
- cur_opt_value = opts.get(def_opt_name)
- if cur_opt_value is not None:
- def_opt_value = env.coredata.validate_option_value(def_opt_name, def_opt_value)
- if def_opt_value != cur_opt_value.value:
- yield (def_opt_name, def_opt_value, cur_opt_value)
-
- def build_func_dict(self):
- self.funcs.update({'add_global_arguments': self.func_add_global_arguments,
- 'add_project_arguments': self.func_add_project_arguments,
- 'add_global_link_arguments': self.func_add_global_link_arguments,
- 'add_project_link_arguments': self.func_add_project_link_arguments,
- 'add_test_setup': self.func_add_test_setup,
- 'add_languages': self.func_add_languages,
- 'alias_target': self.func_alias_target,
- 'assert': self.func_assert,
- 'benchmark': self.func_benchmark,
- 'build_target': self.func_build_target,
- 'configuration_data': self.func_configuration_data,
- 'configure_file': self.func_configure_file,
- 'custom_target': self.func_custom_target,
- 'declare_dependency': self.func_declare_dependency,
- 'dependency': self.func_dependency,
- 'disabler': self.func_disabler,
- 'environment': self.func_environment,
- 'error': self.func_error,
- 'executable': self.func_executable,
- 'generator': self.func_generator,
- 'gettext': self.func_gettext,
- 'get_option': self.func_get_option,
- 'get_variable': self.func_get_variable,
- 'files': self.func_files,
- 'find_library': self.func_find_library,
- 'find_program': self.func_find_program,
- 'include_directories': self.func_include_directories,
- 'import': self.func_import,
- 'install_data': self.func_install_data,
- 'install_headers': self.func_install_headers,
- 'install_man': self.func_install_man,
- 'install_subdir': self.func_install_subdir,
- 'is_disabler': self.func_is_disabler,
- 'is_variable': self.func_is_variable,
- 'jar': self.func_jar,
- 'join_paths': self.func_join_paths,
- 'library': self.func_library,
- 'message': self.func_message,
- 'warning': self.func_warning,
- 'option': self.func_option,
- 'project': self.func_project,
- 'run_target': self.func_run_target,
- 'run_command': self.func_run_command,
- 'set_variable': self.func_set_variable,
- 'subdir': self.func_subdir,
- 'subdir_done': self.func_subdir_done,
- 'subproject': self.func_subproject,
- 'summary': self.func_summary,
- 'shared_library': self.func_shared_lib,
- 'shared_module': self.func_shared_module,
- 'static_library': self.func_static_lib,
- 'both_libraries': self.func_both_lib,
- 'test': self.func_test,
- 'vcs_tag': self.func_vcs_tag
- })
- if 'MESON_UNIT_TEST' in os.environ:
- self.funcs.update({'exception': self.func_exception})
-
- def holderify(self, item):
- if isinstance(item, list):
- return [self.holderify(x) for x in item]
- if isinstance(item, dict):
- return {k: self.holderify(v) for k, v in item.items()}
-
- if isinstance(item, build.CustomTarget):
- return CustomTargetHolder(item, self)
- elif isinstance(item, (int, str, bool)) or item is None:
- return item
- elif isinstance(item, build.Executable):
- return ExecutableHolder(item, self)
- elif isinstance(item, build.GeneratedList):
- return GeneratedListHolder(item)
- elif isinstance(item, build.RunTarget):
- raise RuntimeError('This is not a pipe.')
- elif isinstance(item, build.RunScript):
- raise RuntimeError('Do not do this.')
- elif isinstance(item, build.Data):
- return DataHolder(item)
- elif isinstance(item, dependencies.Dependency):
- return DependencyHolder(item, self.subproject)
- elif isinstance(item, dependencies.ExternalProgram):
- return ExternalProgramHolder(item)
- elif hasattr(item, 'held_object'):
- return item
- else:
- raise InterpreterException('Module returned a value of unknown type.')
-
- def process_new_values(self, invalues):
- invalues = listify(invalues)
- for v in invalues:
- if isinstance(v, (RunTargetHolder, CustomTargetHolder, BuildTargetHolder)):
- v = v.held_object
-
- if isinstance(v, (build.BuildTarget, build.CustomTarget, build.RunTarget)):
- self.add_target(v.name, v)
- elif isinstance(v, list):
- self.module_method_callback(v)
- elif isinstance(v, build.GeneratedList):
- pass
- elif isinstance(v, build.RunScript):
- self.build.install_scripts.append(v)
- elif isinstance(v, build.Data):
- self.build.data.append(v)
- elif isinstance(v, dependencies.ExternalProgram):
- return ExternalProgramHolder(v)
- elif isinstance(v, dependencies.InternalDependency):
- # FIXME: This is special cased and not ideal:
- # The first source is our new VapiTarget, the rest are deps
- self.process_new_values(v.sources[0])
- elif hasattr(v, 'held_object'):
- pass
- elif isinstance(v, (int, str, bool)):
- pass
- else:
- raise InterpreterException('Module returned a value of unknown type.')
-
- def module_method_callback(self, return_object):
- if not isinstance(return_object, ModuleReturnValue):
- raise InterpreterException('Bug in module, it returned an invalid object')
- invalues = return_object.new_objects
- self.process_new_values(invalues)
- return self.holderify(return_object.return_value)
-
- def get_build_def_files(self):
- return self.build_def_files
-
- def add_build_def_file(self, f):
- # Use relative path for files within source directory, and absolute path
- # for system files. Skip files within build directory. Also skip not regular
- # files (e.g. /dev/stdout) Normalize the path to avoid duplicates, this
- # is especially important to convert '/' to '\' on Windows.
- if isinstance(f, mesonlib.File):
- if f.is_built:
- return
- f = os.path.normpath(f.relative_name())
- elif os.path.isfile(f) and not f.startswith('/dev'):
- srcdir = self.environment.get_source_dir()
- builddir = self.environment.get_build_dir()
- f = os.path.normpath(f)
- rel_path = mesonlib.relpath(f, start=srcdir)
- if not rel_path.startswith('..'):
- f = rel_path
- elif not mesonlib.relpath(f, start=builddir).startswith('..'):
- return
- else:
- return
- if f not in self.build_def_files:
- self.build_def_files.append(f)
-
- def get_variables(self):
- return self.variables
-
- def check_stdlibs(self):
- for for_machine in MachineChoice:
- props = self.build.environment.properties[for_machine]
- for l in self.coredata.compilers[for_machine].keys():
- try:
- di = mesonlib.stringlistify(props.get_stdlib(l))
- if len(di) != 2:
- raise InterpreterException('Stdlib definition for %s should have exactly two elements.'
- % l)
- projname, depname = di
- subproj = self.do_subproject(projname, 'meson', {})
- self.build.stdlibs.host[l] = subproj.get_variable_method([depname], {})
- except KeyError:
- pass
- except InvalidArguments:
- pass
-
- @stringArgs
- @noKwargs
- def func_import(self, node, args, kwargs):
- if len(args) != 1:
- raise InvalidCode('Import takes one argument.')
- modname = args[0]
- if modname.startswith('unstable-'):
- plainname = modname.split('-', 1)[1]
- mlog.warning('Module %s has no backwards or forwards compatibility and might not exist in future releases.' % modname, location=node)
- modname = 'unstable_' + plainname
- if modname not in self.modules:
- try:
- module = importlib.import_module('mesonbuild.modules.' + modname)
- except ImportError:
- raise InvalidArguments('Module "%s" does not exist' % (modname, ))
- self.modules[modname] = module.initialize(self)
- return ModuleHolder(modname, self.modules[modname], self)
-
- @stringArgs
- @noKwargs
- def func_files(self, node, args, kwargs):
- return [mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, fname) for fname in args]
-
- @FeatureNewKwargs('declare_dependency', '0.46.0', ['link_whole'])
- @permittedKwargs(permitted_kwargs['declare_dependency'])
- @noPosargs
- def func_declare_dependency(self, node, args, kwargs):
- version = kwargs.get('version', self.project_version)
- if not isinstance(version, str):
- raise InterpreterException('Version must be a string.')
- incs = self.extract_incdirs(kwargs)
- libs = extract_as_list(kwargs, 'link_with', unholder=True)
- libs_whole = extract_as_list(kwargs, 'link_whole', unholder=True)
- sources = extract_as_list(kwargs, 'sources')
- sources = listify(self.source_strings_to_files(sources), unholder=True)
- deps = extract_as_list(kwargs, 'dependencies', unholder=True)
- compile_args = mesonlib.stringlistify(kwargs.get('compile_args', []))
- link_args = mesonlib.stringlistify(kwargs.get('link_args', []))
- final_deps = []
- for d in deps:
- try:
- d = d.held_object
- except Exception:
- pass
- if not isinstance(d, (dependencies.Dependency, dependencies.ExternalLibrary, dependencies.InternalDependency)):
- raise InterpreterException('Dependencies must be external deps')
- final_deps.append(d)
- for l in libs:
- if isinstance(l, dependencies.Dependency):
- raise InterpreterException('''Entries in "link_with" may only be self-built targets,
-external dependencies (including libraries) must go to "dependencies".''')
- dep = dependencies.InternalDependency(version, incs, compile_args,
- link_args, libs, libs_whole, sources, final_deps)
- return DependencyHolder(dep, self.subproject)
-
- @noKwargs
- def func_assert(self, node, args, kwargs):
- if len(args) == 1:
- FeatureNew('assert function without message argument', '0.53.0').use(self.subproject)
- value = args[0]
- message = None
- elif len(args) == 2:
- value, message = args
- if not isinstance(message, str):
- raise InterpreterException('Assert message not a string.')
- else:
- raise InterpreterException('Assert takes between one and two arguments')
- if not isinstance(value, bool):
- raise InterpreterException('Assert value not bool.')
- if not value:
- if message is None:
- from .ast import AstPrinter
- printer = AstPrinter()
- node.args.arguments[0].accept(printer)
- message = printer.result
- raise InterpreterException('Assert failed: ' + message)
-
- def validate_arguments(self, args, argcount, arg_types):
- if argcount is not None:
- if argcount != len(args):
- raise InvalidArguments('Expected %d arguments, got %d.' %
- (argcount, len(args)))
- for actual, wanted in zip(args, arg_types):
- if wanted is not None:
- if not isinstance(actual, wanted):
- raise InvalidArguments('Incorrect argument type.')
-
- @FeatureNewKwargs('run_command', '0.50.0', ['env'])
- @FeatureNewKwargs('run_command', '0.47.0', ['check', 'capture'])
- @permittedKwargs(permitted_kwargs['run_command'])
- def func_run_command(self, node, args, kwargs):
- return self.run_command_impl(node, args, kwargs)
-
- def run_command_impl(self, node, args, kwargs, in_builddir=False):
- if len(args) < 1:
- raise InterpreterException('Not enough arguments')
- cmd, *cargs = args
- capture = kwargs.get('capture', True)
- srcdir = self.environment.get_source_dir()
- builddir = self.environment.get_build_dir()
-
- check = kwargs.get('check', False)
- if not isinstance(check, bool):
- raise InterpreterException('Check must be boolean.')
-
- env = self.unpack_env_kwarg(kwargs)
-
- m = 'must be a string, or the output of find_program(), files() '\
- 'or configure_file(), or a compiler object; not {!r}'
- expanded_args = []
- if isinstance(cmd, ExternalProgramHolder):
- cmd = cmd.held_object
- if isinstance(cmd, build.Executable):
- progname = node.args.arguments[0].value
- msg = 'Program {!r} was overridden with the compiled executable {!r}'\
- ' and therefore cannot be used during configuration'
- raise InterpreterException(msg.format(progname, cmd.description()))
- if not cmd.found():
- raise InterpreterException('command {!r} not found or not executable'.format(cmd))
- elif isinstance(cmd, CompilerHolder):
- exelist = cmd.compiler.get_exelist()
- cmd = exelist[0]
- prog = ExternalProgram(cmd, silent=True)
- if not prog.found():
- raise InterpreterException('Program {!r} not found '
- 'or not executable'.format(cmd))
- cmd = prog
- expanded_args = exelist[1:]
- else:
- if isinstance(cmd, mesonlib.File):
- cmd = cmd.absolute_path(srcdir, builddir)
- elif not isinstance(cmd, str):
- raise InterpreterException('First argument ' + m.format(cmd))
- # Prefer scripts in the current source directory
- search_dir = os.path.join(srcdir, self.subdir)
- prog = ExternalProgram(cmd, silent=True, search_dir=search_dir)
- if not prog.found():
- raise InterpreterException('Program or command {!r} not found '
- 'or not executable'.format(cmd))
- cmd = prog
- for a in listify(cargs):
- if isinstance(a, str):
- expanded_args.append(a)
- elif isinstance(a, mesonlib.File):
- expanded_args.append(a.absolute_path(srcdir, builddir))
- elif isinstance(a, ExternalProgramHolder):
- expanded_args.append(a.held_object.get_path())
- else:
- raise InterpreterException('Arguments ' + m.format(a))
- # If any file that was used as an argument to the command
- # changes, we must re-run the configuration step.
- self.add_build_def_file(cmd.get_path())
- for a in expanded_args:
- if not os.path.isabs(a):
- a = os.path.join(builddir if in_builddir else srcdir, self.subdir, a)
- self.add_build_def_file(a)
- return RunProcess(cmd, expanded_args, env, srcdir, builddir, self.subdir,
- self.environment.get_build_command() + ['introspect'],
- in_builddir=in_builddir, check=check, capture=capture)
-
- @stringArgs
- def func_gettext(self, nodes, args, kwargs):
- raise InterpreterException('Gettext() function has been moved to module i18n. Import it and use i18n.gettext() instead')
-
- def func_option(self, nodes, args, kwargs):
- raise InterpreterException('Tried to call option() in build description file. All options must be in the option file.')
-
- @FeatureNewKwargs('subproject', '0.38.0', ['default_options'])
- @permittedKwargs(permitted_kwargs['subproject'])
- @stringArgs
- def func_subproject(self, nodes, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Subproject takes exactly one argument')
- dirname = args[0]
- return self.do_subproject(dirname, 'meson', kwargs)
-
- def disabled_subproject(self, dirname, feature=None):
- sub = SubprojectHolder(None, self.subproject_dir, dirname)
- if feature:
- sub.disabled_feature = feature
- self.subprojects[dirname] = sub
- return sub
-
- def do_subproject(self, dirname: str, method: str, kwargs):
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
- if disabled:
- mlog.log('Subproject', mlog.bold(dirname), ':', 'skipped: feature', mlog.bold(feature), 'disabled')
- return self.disabled_subproject(dirname, feature)
-
- default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
- default_options = coredata.create_options_dict(default_options)
- if dirname == '':
- raise InterpreterException('Subproject dir name must not be empty.')
- if dirname[0] == '.':
- raise InterpreterException('Subproject dir name must not start with a period.')
- if '..' in dirname:
- raise InterpreterException('Subproject name must not contain a ".." path segment.')
- if os.path.isabs(dirname):
- raise InterpreterException('Subproject name must not be an absolute path.')
- if has_path_sep(dirname):
- mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.',
- location=self.current_node)
- if dirname in self.subproject_stack:
- fullstack = self.subproject_stack + [dirname]
- incpath = ' => '.join(fullstack)
- raise InvalidCode('Recursive include of subprojects: %s.' % incpath)
- if dirname in self.subprojects:
- subproject = self.subprojects[dirname]
- if required and not subproject.found():
- raise InterpreterException('Subproject "%s/%s" required but not found.' % (
- self.subproject_dir, dirname))
- return subproject
-
- subproject_dir_abs = os.path.join(self.environment.get_source_dir(), self.subproject_dir)
- r = wrap.Resolver(subproject_dir_abs, self.coredata.get_builtin_option('wrap_mode'))
- try:
- resolved = r.resolve(dirname, method)
- except wrap.WrapException as e:
- subprojdir = os.path.join(self.subproject_dir, r.directory)
- if isinstance(e, wrap.WrapNotFoundException):
- # if the reason subproject execution failed was because
- # the directory doesn't exist, try to give some helpful
- # advice if it's a nested subproject that needs
- # promotion...
- self.print_nested_info(dirname)
- if not required:
- mlog.log(e)
- mlog.log('Subproject ', mlog.bold(subprojdir), 'is buildable:', mlog.red('NO'), '(disabling)')
- return self.disabled_subproject(dirname)
- raise e
-
- subdir = os.path.join(self.subproject_dir, resolved)
- subdir_abs = os.path.join(subproject_dir_abs, resolved)
- os.makedirs(os.path.join(self.build.environment.get_build_dir(), subdir), exist_ok=True)
- self.global_args_frozen = True
-
- mlog.log()
- with mlog.nested():
- mlog.log('Executing subproject', mlog.bold(dirname), 'method', mlog.bold(method), '\n')
- try:
- if method == 'meson':
- return self._do_subproject_meson(dirname, subdir, default_options, kwargs)
- elif method == 'cmake':
- return self._do_subproject_cmake(dirname, subdir, subdir_abs, default_options, kwargs)
- else:
- raise InterpreterException('The method {} is invalid for the subproject {}'.format(method, dirname))
- # Invalid code is always an error
- except InvalidCode:
- raise
- except Exception as e:
- if not required:
- with mlog.nested():
- # Suppress the 'ERROR:' prefix because this exception is not
- # fatal and VS CI treat any logs with "ERROR:" as fatal.
- mlog.exception(e, prefix=mlog.yellow('Exception:'))
- mlog.log('\nSubproject', mlog.bold(dirname), 'is buildable:', mlog.red('NO'), '(disabling)')
- return self.disabled_subproject(dirname)
- raise e
-
- def _do_subproject_meson(self, dirname, subdir, default_options, kwargs, ast=None, build_def_files=None):
- with mlog.nested():
- new_build = self.build.copy()
- subi = Interpreter(new_build, self.backend, dirname, subdir, self.subproject_dir,
- self.modules, default_options, ast=ast)
- subi.subprojects = self.subprojects
-
- subi.subproject_stack = self.subproject_stack + [dirname]
- current_active = self.active_projectname
- subi.run()
- mlog.log('Subproject', mlog.bold(dirname), 'finished.')
-
- mlog.log()
-
- if 'version' in kwargs:
- pv = subi.project_version
- wanted = kwargs['version']
- if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]:
- raise InterpreterException('Subproject %s version is %s but %s required.' % (dirname, pv, wanted))
- self.active_projectname = current_active
- self.subprojects.update(subi.subprojects)
- self.subprojects[dirname] = SubprojectHolder(subi, self.subproject_dir, dirname)
- # Duplicates are possible when subproject uses files from project root
- if build_def_files:
- self.build_def_files = list(set(self.build_def_files + build_def_files))
- else:
- self.build_def_files = list(set(self.build_def_files + subi.build_def_files))
- self.build.merge(subi.build)
- self.build.subprojects[dirname] = subi.project_version
- self.summary.update(subi.summary)
- return self.subprojects[dirname]
-
- def _do_subproject_cmake(self, dirname, subdir, subdir_abs, default_options, kwargs):
- with mlog.nested():
- new_build = self.build.copy()
- prefix = self.coredata.builtins['prefix'].value
- cmake_options = mesonlib.stringlistify(kwargs.get('cmake_options', []))
- cm_int = CMakeInterpreter(new_build, subdir, subdir_abs, prefix, new_build.environment, self.backend)
- cm_int.initialise(cmake_options)
- cm_int.analyse()
-
- # Generate a meson ast and execute it with the normal do_subproject_meson
- ast = cm_int.pretend_to_be_meson()
-
- mlog.log()
- with mlog.nested():
- mlog.log('Processing generated meson AST')
-
- # Debug print the generated meson file
- from .ast import AstIndentationGenerator, AstPrinter
- printer = AstPrinter()
- ast.accept(AstIndentationGenerator())
- ast.accept(printer)
- printer.post_process()
- meson_filename = os.path.join(self.build.environment.get_build_dir(), subdir, 'meson.build')
- with open(meson_filename, "w") as f:
- f.write(printer.result)
-
- mlog.log('Build file:', meson_filename)
- mlog.cmd_ci_include(meson_filename)
- mlog.log()
-
- result = self._do_subproject_meson(dirname, subdir, default_options, kwargs, ast, cm_int.bs_files)
- result.cm_interpreter = cm_int
-
- mlog.log()
- return result
-
- def get_option_internal(self, optname):
- for opts in chain(
- [self.coredata.base_options, compilers.base_options, self.coredata.builtins],
- self.coredata.get_prefixed_options_per_machine(self.coredata.builtins_per_machine),
- self.coredata.get_prefixed_options_per_machine(self.coredata.compiler_options),
- ):
- v = opts.get(optname)
- if v is not None:
- return v
-
- raw_optname = optname
- if self.is_subproject():
- optname = self.subproject + ':' + optname
-
- try:
- opt = self.coredata.user_options[optname]
- if opt.yielding and ':' in optname and raw_optname in self.coredata.user_options:
- popt = self.coredata.user_options[raw_optname]
- if type(opt) is type(popt):
- opt = popt
- else:
- # Get class name, then option type as a string
- opt_type = opt.__class__.__name__[4:][:-6].lower()
- popt_type = popt.__class__.__name__[4:][:-6].lower()
- # This is not a hard error to avoid dependency hell, the workaround
- # when this happens is to simply set the subproject's option directly.
- mlog.warning('Option {0!r} of type {1!r} in subproject {2!r} cannot yield '
- 'to parent option of type {3!r}, ignoring parent value. '
- 'Use -D{2}:{0}=value to set the value for this option manually'
- '.'.format(raw_optname, opt_type, self.subproject, popt_type),
- location=self.current_node)
- return opt
- except KeyError:
- pass
-
- raise InterpreterException('Tried to access unknown option "%s".' % optname)
-
- @stringArgs
- @noKwargs
- def func_get_option(self, nodes, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Argument required for get_option.')
- optname = args[0]
- if ':' in optname:
- raise InterpreterException('Having a colon in option name is forbidden, '
- 'projects are not allowed to directly access '
- 'options of other subprojects.')
- opt = self.get_option_internal(optname)
- if isinstance(opt, coredata.UserFeatureOption):
- return FeatureOptionHolder(self.environment, optname, opt)
- elif isinstance(opt, coredata.UserOption):
- return opt.value
- return opt
-
- @noKwargs
- def func_configuration_data(self, node, args, kwargs):
- if len(args) > 1:
- raise InterpreterException('configuration_data takes only one optional positional arguments')
- elif len(args) == 1:
- FeatureNew('configuration_data dictionary', '0.49.0').use(self.subproject)
- initial_values = args[0]
- if not isinstance(initial_values, dict):
- raise InterpreterException('configuration_data first argument must be a dictionary')
- else:
- initial_values = {}
- return ConfigurationDataHolder(self.subproject, initial_values)
-
- def set_backend(self):
- # The backend is already set when parsing subprojects
- if self.backend is not None:
- return
- backend = self.coredata.get_builtin_option('backend')
- from .backend import backends
- self.backend = backends.get_backend_from_name(backend, self.build)
-
- if self.backend is None:
- raise InterpreterException('Unknown backend "%s".' % backend)
- if backend != self.backend.name:
- if self.backend.name.startswith('vs'):
- mlog.log('Auto detected Visual Studio backend:', mlog.bold(self.backend.name))
- self.coredata.set_builtin_option('backend', self.backend.name)
-
- # Only init backend options on first invocation otherwise it would
- # override values previously set from command line.
- if self.environment.first_invocation:
- self.coredata.init_backend_options(backend)
-
- options = {k: v for k, v in self.environment.cmd_line_options.items() if k.startswith('backend_')}
- self.coredata.set_options(options)
-
- @stringArgs
- @permittedKwargs(permitted_kwargs['project'])
- def func_project(self, node, args, kwargs):
- if len(args) < 1:
- raise InvalidArguments('Not enough arguments to project(). Needs at least the project name.')
- proj_name, *proj_langs = args
- if ':' in proj_name:
- raise InvalidArguments("Project name {!r} must not contain ':'".format(proj_name))
-
- if 'meson_version' in kwargs:
- cv = coredata.version
- pv = kwargs['meson_version']
- if not mesonlib.version_compare(cv, pv):
- raise InterpreterException('Meson version is %s but project requires %s' % (cv, pv))
-
- if os.path.exists(self.option_file):
- oi = optinterpreter.OptionInterpreter(self.subproject)
- oi.process(self.option_file)
- self.coredata.merge_user_options(oi.options)
-
- # Do not set default_options on reconfigure otherwise it would override
- # values previously set from command line. That means that changing
- # default_options in a project will trigger a reconfigure but won't
- # have any effect.
- self.project_default_options = mesonlib.stringlistify(kwargs.get('default_options', []))
- self.project_default_options = coredata.create_options_dict(self.project_default_options)
- if self.environment.first_invocation:
- default_options = self.project_default_options
- default_options.update(self.default_project_options)
- else:
- default_options = {}
- self.coredata.set_default_options(default_options, self.subproject, self.environment)
-
- if not self.is_subproject():
- self.build.project_name = proj_name
- self.active_projectname = proj_name
- self.project_version = kwargs.get('version', 'undefined')
- if self.build.project_version is None:
- self.build.project_version = self.project_version
- proj_license = mesonlib.stringlistify(kwargs.get('license', 'unknown'))
- self.build.dep_manifest[proj_name] = {'version': self.project_version,
- 'license': proj_license}
- if self.subproject in self.build.projects:
- raise InvalidCode('Second call to project().')
- if not self.is_subproject() and 'subproject_dir' in kwargs:
- spdirname = kwargs['subproject_dir']
- if not isinstance(spdirname, str):
- raise InterpreterException('Subproject_dir must be a string')
- if os.path.isabs(spdirname):
- raise InterpreterException('Subproject_dir must not be an absolute path.')
- if spdirname.startswith('.'):
- raise InterpreterException('Subproject_dir must not begin with a period.')
- if '..' in spdirname:
- raise InterpreterException('Subproject_dir must not contain a ".." segment.')
- self.subproject_dir = spdirname
-
- self.build.subproject_dir = self.subproject_dir
-
- mesonlib.project_meson_versions[self.subproject] = ''
- if 'meson_version' in kwargs:
- mesonlib.project_meson_versions[self.subproject] = kwargs['meson_version']
-
- self.build.projects[self.subproject] = proj_name
- mlog.log('Project name:', mlog.bold(proj_name))
- mlog.log('Project version:', mlog.bold(self.project_version))
- self.add_languages(proj_langs, True)
- self.set_backend()
- if not self.is_subproject():
- self.check_stdlibs()
-
- @permittedKwargs(permitted_kwargs['add_languages'])
- @stringArgs
- def func_add_languages(self, node, args, kwargs):
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
- if disabled:
- for lang in sorted(args, key=compilers.sort_clink):
- mlog.log('Compiler for language', mlog.bold(lang), 'skipped: feature', mlog.bold(feature), 'disabled')
- return False
- return self.add_languages(args, required)
-
- def get_message_string_arg(self, node):
- # reduce arguments again to avoid flattening posargs
- (posargs, _) = self.reduce_arguments(node.args)
- if len(posargs) != 1:
- raise InvalidArguments('Expected 1 argument, got %d' % len(posargs))
-
- arg = posargs[0]
- if isinstance(arg, list):
- argstr = stringifyUserArguments(arg)
- elif isinstance(arg, dict):
- argstr = stringifyUserArguments(arg)
- elif isinstance(arg, str):
- argstr = arg
- elif isinstance(arg, int):
- argstr = str(arg)
- else:
- raise InvalidArguments('Function accepts only strings, integers, lists and lists thereof.')
-
- return argstr
-
- @noKwargs
- def func_message(self, node, args, kwargs):
- argstr = self.get_message_string_arg(node)
- self.message_impl(argstr)
-
- def message_impl(self, argstr):
- mlog.log(mlog.bold('Message:'), argstr)
-
- @noArgsFlattening
- @permittedKwargs({'section', 'bool_yn'})
- @FeatureNew('summary', '0.53.0')
- def func_summary(self, node, args, kwargs):
- if len(args) == 1:
- if not isinstance(args[0], dict):
- raise InterpreterException('Summary first argument must be dictionary.')
- values = args[0]
- elif len(args) == 2:
- if not isinstance(args[0], str):
- raise InterpreterException('Summary first argument must be string.')
- values = {args[0]: args[1]}
- else:
- raise InterpreterException('Summary accepts at most 2 arguments.')
- section = kwargs.get('section', '')
- if not isinstance(section, str):
- raise InterpreterException('Summary\'s section keyword argument must be string.')
- self.summary_impl(section, values, kwargs)
-
- def summary_impl(self, section, values, kwargs):
- if self.subproject not in self.summary:
- self.summary[self.subproject] = Summary(self.active_projectname, self.project_version)
- self.summary[self.subproject].add_section(section, values, kwargs)
-
- def _print_summary(self):
- # Add automatic 'Supbrojects' section in main project.
- all_subprojects = collections.OrderedDict()
- for name, subp in sorted(self.subprojects.items()):
- value = subp.found()
- if not value and hasattr(subp, 'disabled_feature'):
- value = 'Feature {!r} disabled'.format(subp.disabled_feature)
- all_subprojects[name] = value
- if all_subprojects:
- self.summary_impl('Subprojects', all_subprojects, {'bool_yn': True})
- # Print all summaries, main project last.
- mlog.log('') # newline
- main_summary = self.summary.pop('', None)
- for _, summary in sorted(self.summary.items()):
- summary.dump()
- if main_summary:
- main_summary.dump()
-
- @FeatureNew('warning', '0.44.0')
- @noKwargs
- def func_warning(self, node, args, kwargs):
- argstr = self.get_message_string_arg(node)
- mlog.warning(argstr, location=node)
-
- @noKwargs
- def func_error(self, node, args, kwargs):
- self.validate_arguments(args, 1, [str])
- raise InterpreterException('Problem encountered: ' + args[0])
-
- @noKwargs
- def func_exception(self, node, args, kwargs):
- self.validate_arguments(args, 0, [])
- raise Exception()
-
- def add_languages(self, args: T.Sequence[str], required: bool) -> bool:
- success = self.add_languages_for(args, required, MachineChoice.BUILD)
- success &= self.add_languages_for(args, required, MachineChoice.HOST)
- if not self.coredata.is_cross_build():
- self.coredata.copy_build_options_from_regular_ones()
- return success
-
- def add_languages_for(self, args, required, for_machine: MachineChoice):
- success = True
- for lang in sorted(args, key=compilers.sort_clink):
- lang = lang.lower()
- clist = self.coredata.compilers[for_machine]
- machine_name = for_machine.get_lower_case_name()
- if lang in clist:
- comp = clist[lang]
- else:
- try:
- comp = self.environment.detect_compiler_for(lang, for_machine)
- if comp is None:
- raise InvalidArguments('Tried to use unknown language "%s".' % lang)
- comp.sanity_check(self.environment.get_scratch_dir(), self.environment)
- except Exception:
- if not required:
- mlog.log('Compiler for language',
- mlog.bold(lang), 'for the', machine_name,
- 'machine not found.')
- success = False
- continue
- else:
- raise
-
- if for_machine == MachineChoice.HOST or self.environment.is_cross_build():
- logger_fun = mlog.log
- else:
- logger_fun = mlog.debug
- logger_fun(comp.get_display_language(), 'compiler for the', machine_name, 'machine:',
- mlog.bold(' '.join(comp.get_exelist())), comp.get_version_string())
- if comp.linker is not None:
- logger_fun(comp.get_display_language(), 'linker for the', machine_name, 'machine:',
- mlog.bold(' '.join(comp.linker.get_exelist())), comp.linker.id, comp.linker.version)
- self.build.ensure_static_linker(comp)
-
- langs = self.coredata.compilers[for_machine].keys()
- if 'vala' in langs:
- if 'c' not in langs:
- raise InterpreterException('Compiling Vala requires C. Add C to your project languages and rerun Meson.')
-
- return success
-
- def program_from_file_for(self, for_machine, prognames, silent):
- bins = self.environment.binaries[for_machine]
- for p in prognames:
- if hasattr(p, 'held_object'):
- p = p.held_object
- if isinstance(p, mesonlib.File):
- continue # Always points to a local (i.e. self generated) file.
- if not isinstance(p, str):
- raise InterpreterException('Executable name must be a string')
- prog = ExternalProgram.from_bin_list(bins, p)
- if prog.found():
- return ExternalProgramHolder(prog)
- return None
-
- def program_from_system(self, args, search_dirs, silent=False):
- # Search for scripts relative to current subdir.
- # Do not cache found programs because find_program('foobar')
- # might give different results when run from different source dirs.
- source_dir = os.path.join(self.environment.get_source_dir(), self.subdir)
- for exename in args:
- if isinstance(exename, mesonlib.File):
- if exename.is_built:
- search_dir = os.path.join(self.environment.get_build_dir(),
- exename.subdir)
- else:
- search_dir = os.path.join(self.environment.get_source_dir(),
- exename.subdir)
- exename = exename.fname
- extra_search_dirs = []
- elif isinstance(exename, str):
- search_dir = source_dir
- extra_search_dirs = search_dirs
- else:
- raise InvalidArguments('find_program only accepts strings and '
- 'files, not {!r}'.format(exename))
- extprog = dependencies.ExternalProgram(exename, search_dir=search_dir,
- extra_search_dirs=extra_search_dirs,
- silent=silent)
- progobj = ExternalProgramHolder(extprog)
- if progobj.found():
- return progobj
-
- def program_from_overrides(self, command_names, silent=False):
- for name in command_names:
- if not isinstance(name, str):
- continue
- if name in self.build.find_overrides:
- exe = self.build.find_overrides[name]
- if not silent:
- mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
- '(overridden: %s)' % exe.description())
- return ExternalProgramHolder(exe)
- return None
-
- def store_name_lookups(self, command_names):
- for name in command_names:
- if isinstance(name, str):
- self.build.searched_programs.add(name)
-
- def add_find_program_override(self, name, exe):
- if name in self.build.searched_programs:
- raise InterpreterException('Tried to override finding of executable "%s" which has already been found.'
- % name)
- if name in self.build.find_overrides:
- raise InterpreterException('Tried to override executable "%s" which has already been overridden.'
- % name)
- self.build.find_overrides[name] = exe
-
- # TODO update modules to always pass `for_machine`. It is bad-form to assume
- # the host machine.
- def find_program_impl(self, args, for_machine: MachineChoice = MachineChoice.HOST,
- required=True, silent=True, wanted='', search_dirs=None):
- if not isinstance(args, list):
- args = [args]
-
- progobj = self.program_from_overrides(args, silent=silent)
- if progobj is None:
- progobj = self.program_from_file_for(for_machine, args, silent=silent)
- if progobj is None:
- progobj = self.program_from_system(args, search_dirs, silent=silent)
- if progobj is None and args[0].endswith('python3'):
- prog = dependencies.ExternalProgram('python3', mesonlib.python_command, silent=True)
- progobj = ExternalProgramHolder(prog)
- if required and (progobj is None or not progobj.found()):
- raise InvalidArguments('Program(s) {!r} not found or not executable'.format(args))
- if progobj is None:
- return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
- # Only store successful lookups
- self.store_name_lookups(args)
- if wanted:
- version = progobj.get_version(self)
- is_found, not_found, found = mesonlib.version_compare_many(version, wanted)
- if not is_found:
- mlog.log('Program', mlog.bold(progobj.get_name()), 'found:', mlog.red('NO'),
- 'found {!r} but need:'.format(version),
- ', '.join(["'{}'".format(e) for e in not_found]))
- if required:
- m = 'Invalid version of program, need {!r} {!r} found {!r}.'
- raise InvalidArguments(m.format(progobj.get_name(), not_found, version))
- return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
- return progobj
-
- @FeatureNewKwargs('find_program', '0.53.0', ['dirs'])
- @FeatureNewKwargs('find_program', '0.52.0', ['version'])
- @FeatureNewKwargs('find_program', '0.49.0', ['disabler'])
- @disablerIfNotFound
- @permittedKwargs(permitted_kwargs['find_program'])
- def func_find_program(self, node, args, kwargs):
- if not args:
- raise InterpreterException('No program name specified.')
-
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
- if disabled:
- mlog.log('Program', mlog.bold(' '.join(args)), 'skipped: feature', mlog.bold(feature), 'disabled')
- return ExternalProgramHolder(dependencies.NonExistingExternalProgram())
-
- search_dirs = extract_search_dirs(kwargs)
- wanted = mesonlib.stringlistify(kwargs.get('version', []))
- for_machine = self.machine_from_native_kwarg(kwargs)
- return self.find_program_impl(args, for_machine, required=required,
- silent=False, wanted=wanted,
- search_dirs=search_dirs)
-
- def func_find_library(self, node, args, kwargs):
- raise InvalidCode('find_library() is removed, use meson.get_compiler(\'name\').find_library() instead.\n'
- 'Look here for documentation: http://mesonbuild.com/Reference-manual.html#compiler-object\n'
- 'Look here for example: http://mesonbuild.com/howtox.html#add-math-library-lm-portably\n'
- )
-
- def _find_cached_dep(self, name, kwargs):
- # Check if we want this as a build-time / build machine or runt-time /
- # host machine dep.
- for_machine = self.machine_from_native_kwarg(kwargs)
-
- identifier = dependencies.get_dep_identifier(name, kwargs)
- cached_dep = self.coredata.deps[for_machine].get(identifier)
- if cached_dep:
- if not cached_dep.found():
- mlog.log('Dependency', mlog.bold(name),
- 'found:', mlog.red('NO'), mlog.blue('(cached)'))
- return identifier, cached_dep
-
- # Verify the cached dep version match
- wanted_vers = mesonlib.stringlistify(kwargs.get('version', []))
- found_vers = cached_dep.get_version()
- if not wanted_vers or mesonlib.version_compare_many(found_vers, wanted_vers)[0]:
- info = [mlog.blue('(cached)')]
- if found_vers:
- info = [mlog.normal_cyan(found_vers), *info]
- mlog.log('Dependency', mlog.bold(name),
- 'found:', mlog.green('YES'), *info)
- return identifier, cached_dep
-
- return identifier, None
-
- @staticmethod
- def check_subproject_version(wanted, found):
- if not wanted:
- return True
- if found == 'undefined' or not mesonlib.version_compare_many(found, wanted)[0]:
- return False
- return True
-
- def notfound_dependency(self):
- return DependencyHolder(NotFoundDependency(self.environment), self.subproject)
-
- def get_subproject_dep(self, display_name, dirname, varname, kwargs):
- dep = self.notfound_dependency()
- try:
- subproject = self.subprojects[dirname]
- if subproject.found():
- dep = self.subprojects[dirname].get_variable_method([varname], {})
- except InvalidArguments:
- pass
-
- if not isinstance(dep, DependencyHolder):
- raise InvalidCode('Fetched variable {!r} in the subproject {!r} is '
- 'not a dependency object.'.format(varname, dirname))
-
- required = kwargs.get('required', True)
- wanted = mesonlib.stringlistify(kwargs.get('version', []))
- subproj_path = os.path.join(self.subproject_dir, dirname)
-
- if not dep.found():
- if required:
- raise DependencyException('Could not find dependency {} in subproject {}'
- ''.format(varname, dirname))
- # If the dependency is not required, don't raise an exception
- mlog.log('Dependency', mlog.bold(display_name), 'from subproject',
- mlog.bold(subproj_path), 'found:', mlog.red('NO'))
- return dep
-
- found = dep.held_object.get_version()
- if not self.check_subproject_version(wanted, found):
- if required:
- raise DependencyException('Version {} of subproject dependency {} already '
- 'cached, requested incompatible version {} for '
- 'dep {}'.format(found, dirname, wanted, display_name))
-
- mlog.log('Dependency', mlog.bold(display_name), 'from subproject',
- mlog.bold(subproj_path), 'found:', mlog.red('NO'),
- 'found', mlog.normal_cyan(found), 'but need:',
- mlog.bold(', '.join(["'{}'".format(e) for e in wanted])))
- return self.notfound_dependency()
-
- found = mlog.normal_cyan(found) if found else None
- mlog.log('Dependency', mlog.bold(display_name), 'from subproject',
- mlog.bold(subproj_path), 'found:', mlog.green('YES'), found)
- return dep
-
- def _handle_featurenew_dependencies(self, name):
- 'Do a feature check on dependencies used by this subproject'
- if name == 'mpi':
- FeatureNew('MPI Dependency', '0.42.0').use(self.subproject)
- elif name == 'pcap':
- FeatureNew('Pcap Dependency', '0.42.0').use(self.subproject)
- elif name == 'vulkan':
- FeatureNew('Vulkan Dependency', '0.42.0').use(self.subproject)
- elif name == 'libwmf':
- FeatureNew('LibWMF Dependency', '0.44.0').use(self.subproject)
- elif name == 'openmp':
- FeatureNew('OpenMP Dependency', '0.46.0').use(self.subproject)
-
- @FeatureNewKwargs('dependency', '0.52.0', ['include_type'])
- @FeatureNewKwargs('dependency', '0.50.0', ['not_found_message', 'cmake_module_path', 'cmake_args'])
- @FeatureNewKwargs('dependency', '0.49.0', ['disabler'])
- @FeatureNewKwargs('dependency', '0.40.0', ['method'])
- @FeatureNewKwargs('dependency', '0.38.0', ['default_options'])
- @disablerIfNotFound
- @permittedKwargs(permitted_kwargs['dependency'])
- def func_dependency(self, node, args, kwargs):
- self.validate_arguments(args, 1, [str])
- name = args[0]
- display_name = name if name else '(anonymous)'
- not_found_message = kwargs.get('not_found_message', '')
- if not isinstance(not_found_message, str):
- raise InvalidArguments('The not_found_message must be a string.')
- try:
- d = self.dependency_impl(name, display_name, kwargs)
- except Exception:
- if not_found_message:
- self.message_impl(not_found_message)
- raise
- if not d.found() and not_found_message:
- self.message_impl(not_found_message)
- return d
-
- def dependency_impl(self, name, display_name, kwargs):
- disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
- if disabled:
- mlog.log('Dependency', mlog.bold(display_name), 'skipped: feature', mlog.bold(feature), 'disabled')
- return self.notfound_dependency()
-
- has_fallback = 'fallback' in kwargs
- if 'default_options' in kwargs and not has_fallback:
- mlog.warning('The "default_options" keyworg argument does nothing without a "fallback" keyword argument.',
- location=self.current_node)
-
- # writing just "dependency('')" is an error, because it can only fail
- if name == '' and required and not has_fallback:
- raise InvalidArguments('Dependency is both required and not-found')
-
- if '<' in name or '>' in name or '=' in name:
- raise InvalidArguments('Characters <, > and = are forbidden in dependency names. To specify'
- 'version\n requirements use the \'version\' keyword argument instead.')
-
- identifier, cached_dep = self._find_cached_dep(name, kwargs)
- if cached_dep:
- if required and not cached_dep.found():
- m = 'Dependency {!r} was already checked and was not found'
- raise DependencyException(m.format(display_name))
- return DependencyHolder(cached_dep, self.subproject)
-
- # If the dependency has already been configured, possibly by
- # a higher level project, try to use it first.
- if has_fallback:
- dirname, varname = self.get_subproject_infos(kwargs)
- if dirname in self.subprojects:
- return self.get_subproject_dep(name, dirname, varname, kwargs)
-
- wrap_mode = self.coredata.get_builtin_option('wrap_mode')
- forcefallback = wrap_mode == WrapMode.forcefallback and has_fallback
- if name != '' and not forcefallback:
- self._handle_featurenew_dependencies(name)
- kwargs['required'] = required and not has_fallback
- dep = dependencies.find_external_dependency(name, self.environment, kwargs)
-
- kwargs['required'] = required
- # Only store found-deps in the cache
- # Never add fallback deps to self.coredata.deps since we
- # cannot cache them. They must always be evaluated else
- # we won't actually read all the build files.
- if dep.found():
- for_machine = self.machine_from_native_kwarg(kwargs)
- self.coredata.deps[for_machine].put(identifier, dep)
- return DependencyHolder(dep, self.subproject)
-
- if has_fallback:
- return self.dependency_fallback(display_name, kwargs)
-
- return self.notfound_dependency()
-
- @FeatureNew('disabler', '0.44.0')
- @noKwargs
- @noPosargs
- def func_disabler(self, node, args, kwargs):
- return Disabler()
-
- def print_nested_info(self, dependency_name):
- message = ['Dependency', mlog.bold(dependency_name), 'not found but it is available in a sub-subproject.\n' +
- 'To use it in the current project, promote it by going in the project source\n'
- 'root and issuing']
- sprojs = mesonlib.detect_subprojects('subprojects', self.source_root)
- if dependency_name not in sprojs:
- return
- found = sprojs[dependency_name]
- if len(found) > 1:
- message.append('one of the following commands:')
- else:
- message.append('the following command:')
- command_templ = '\nmeson wrap promote {}'
- for l in found:
- message.append(mlog.bold(command_templ.format(l[len(self.source_root) + 1:])))
- mlog.warning(*message, location=self.current_node)
-
- def get_subproject_infos(self, kwargs):
- fbinfo = kwargs['fallback']
- check_stringlist(fbinfo)
- if len(fbinfo) != 2:
- raise InterpreterException('Fallback info must have exactly two items.')
- return fbinfo
-
- def dependency_fallback(self, display_name, kwargs):
- if self.coredata.get_builtin_option('wrap_mode') == WrapMode.nofallback:
- mlog.log('Not looking for a fallback subproject for the dependency',
- mlog.bold(display_name), 'because:\nUse of fallback'
- 'dependencies is disabled.')
- return self.notfound_dependency()
- elif self.coredata.get_builtin_option('wrap_mode') == WrapMode.forcefallback:
- mlog.log('Looking for a fallback subproject for the dependency',
- mlog.bold(display_name), 'because:\nUse of fallback dependencies is forced.')
- else:
- mlog.log('Looking for a fallback subproject for the dependency',
- mlog.bold(display_name))
- dirname, varname = self.get_subproject_infos(kwargs)
- sp_kwargs = {
- 'default_options': kwargs.get('default_options', []),
- 'required': kwargs.get('required', True),
- }
- self.do_subproject(dirname, 'meson', sp_kwargs)
- return self.get_subproject_dep(display_name, dirname, varname, kwargs)
-
- @FeatureNewKwargs('executable', '0.42.0', ['implib'])
- @permittedKwargs(permitted_kwargs['executable'])
- def func_executable(self, node, args, kwargs):
- return self.build_target(node, args, kwargs, ExecutableHolder)
-
- @permittedKwargs(permitted_kwargs['static_library'])
- def func_static_lib(self, node, args, kwargs):
- return self.build_target(node, args, kwargs, StaticLibraryHolder)
-
- @permittedKwargs(permitted_kwargs['shared_library'])
- def func_shared_lib(self, node, args, kwargs):
- holder = self.build_target(node, args, kwargs, SharedLibraryHolder)
- holder.held_object.shared_library_only = True
- return holder
-
- @permittedKwargs(permitted_kwargs['both_libraries'])
- def func_both_lib(self, node, args, kwargs):
- return self.build_both_libraries(node, args, kwargs)
-
- @FeatureNew('shared_module', '0.37.0')
- @permittedKwargs(permitted_kwargs['shared_module'])
- def func_shared_module(self, node, args, kwargs):
- return self.build_target(node, args, kwargs, SharedModuleHolder)
-
- @permittedKwargs(permitted_kwargs['library'])
- def func_library(self, node, args, kwargs):
- return self.build_library(node, args, kwargs)
-
- @permittedKwargs(permitted_kwargs['jar'])
- def func_jar(self, node, args, kwargs):
- return self.build_target(node, args, kwargs, JarHolder)
-
- @FeatureNewKwargs('build_target', '0.40.0', ['link_whole', 'override_options'])
- @permittedKwargs(permitted_kwargs['build_target'])
- def func_build_target(self, node, args, kwargs):
- if 'target_type' not in kwargs:
- raise InterpreterException('Missing target_type keyword argument')
- target_type = kwargs.pop('target_type')
- if target_type == 'executable':
- return self.build_target(node, args, kwargs, ExecutableHolder)
- elif target_type == 'shared_library':
- return self.build_target(node, args, kwargs, SharedLibraryHolder)
- elif target_type == 'shared_module':
- FeatureNew('build_target(target_type: \'shared_module\')',
- '0.51.0').use(self.subproject)
- return self.build_target(node, args, kwargs, SharedModuleHolder)
- elif target_type == 'static_library':
- return self.build_target(node, args, kwargs, StaticLibraryHolder)
- elif target_type == 'both_libraries':
- return self.build_both_libraries(node, args, kwargs)
- elif target_type == 'library':
- return self.build_library(node, args, kwargs)
- elif target_type == 'jar':
- return self.build_target(node, args, kwargs, JarHolder)
- else:
- raise InterpreterException('Unknown target_type.')
-
- @permittedKwargs(permitted_kwargs['vcs_tag'])
- def func_vcs_tag(self, node, args, kwargs):
- if 'input' not in kwargs or 'output' not in kwargs:
- raise InterpreterException('Keyword arguments input and output must exist')
- if 'fallback' not in kwargs:
- FeatureNew('T.Optional fallback in vcs_tag', '0.41.0').use(self.subproject)
- fallback = kwargs.pop('fallback', self.project_version)
- if not isinstance(fallback, str):
- raise InterpreterException('Keyword argument fallback must be a string.')
- replace_string = kwargs.pop('replace_string', '@VCS_TAG@')
- regex_selector = '(.*)' # default regex selector for custom command: use complete output
- vcs_cmd = kwargs.get('command', None)
- if vcs_cmd and not isinstance(vcs_cmd, list):
- vcs_cmd = [vcs_cmd]
- source_dir = os.path.normpath(os.path.join(self.environment.get_source_dir(), self.subdir))
- if vcs_cmd:
- # Is the command an executable in path or maybe a script in the source tree?
- vcs_cmd[0] = shutil.which(vcs_cmd[0]) or os.path.join(source_dir, vcs_cmd[0])
- else:
- vcs = mesonlib.detect_vcs(source_dir)
- if vcs:
- mlog.log('Found %s repository at %s' % (vcs['name'], vcs['wc_dir']))
- vcs_cmd = vcs['get_rev'].split()
- regex_selector = vcs['rev_regex']
- else:
- vcs_cmd = [' '] # executing this cmd will fail in vcstagger.py and force to use the fallback string
- # vcstagger.py parameters: infile, outfile, fallback, source_dir, replace_string, regex_selector, command...
- kwargs['command'] = self.environment.get_build_command() + \
- ['--internal',
- 'vcstagger',
- '@INPUT0@',
- '@OUTPUT0@',
- fallback,
- source_dir,
- replace_string,
- regex_selector] + vcs_cmd
- kwargs.setdefault('build_by_default', True)
- kwargs.setdefault('build_always_stale', True)
- return self._func_custom_target_impl(node, [kwargs['output']], kwargs)
-
- @FeatureNew('subdir_done', '0.46.0')
- @stringArgs
- def func_subdir_done(self, node, args, kwargs):
- if len(kwargs) > 0:
- raise InterpreterException('exit does not take named arguments')
- if len(args) > 0:
- raise InterpreterException('exit does not take any arguments')
- raise SubdirDoneRequest()
-
- @stringArgs
- @FeatureNewKwargs('custom_target', '0.48.0', ['console'])
- @FeatureNewKwargs('custom_target', '0.47.0', ['install_mode', 'build_always_stale'])
- @FeatureNewKwargs('custom_target', '0.40.0', ['build_by_default'])
- @permittedKwargs(permitted_kwargs['custom_target'])
- def func_custom_target(self, node, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('custom_target: Only one positional argument is allowed, and it must be a string name')
- if 'depfile' in kwargs and ('@BASENAME@' in kwargs['depfile'] or '@PLAINNAME@' in kwargs['depfile']):
- FeatureNew('substitutions in custom_target depfile', '0.47.0').use(self.subproject)
- return self._func_custom_target_impl(node, args, kwargs)
-
- def _func_custom_target_impl(self, node, args, kwargs):
- 'Implementation-only, without FeatureNew checks, for internal use'
- name = args[0]
- kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
- if 'input' in kwargs:
- try:
- kwargs['input'] = self.source_strings_to_files(extract_as_list(kwargs, 'input'))
- except mesonlib.MesonException:
- mlog.warning('''Custom target input \'%s\' can\'t be converted to File object(s).
-This will become a hard error in the future.''' % kwargs['input'], location=self.current_node)
- tg = CustomTargetHolder(build.CustomTarget(name, self.subdir, self.subproject, kwargs, backend=self.backend), self)
- self.add_target(name, tg.held_object)
- return tg
-
- @permittedKwargs(permitted_kwargs['run_target'])
- def func_run_target(self, node, args, kwargs):
- if len(args) > 1:
- raise InvalidCode('Run_target takes only one positional argument: the target name.')
- elif len(args) == 1:
- if 'command' not in kwargs:
- raise InterpreterException('Missing "command" keyword argument')
- all_args = extract_as_list(kwargs, 'command')
- deps = extract_as_list(kwargs, 'depends', unholder=True)
- else:
- raise InterpreterException('Run_target needs at least one positional argument.')
-
- cleaned_args = []
- for i in listify(all_args, unholder=True):
- if not isinstance(i, (str, build.BuildTarget, build.CustomTarget, dependencies.ExternalProgram, mesonlib.File)):
- mlog.debug('Wrong type:', str(i))
- raise InterpreterException('Invalid argument to run_target.')
- if isinstance(i, dependencies.ExternalProgram) and not i.found():
- raise InterpreterException('Tried to use non-existing executable {!r}'.format(i.name))
- cleaned_args.append(i)
- name = args[0]
- if not isinstance(name, str):
- raise InterpreterException('First argument must be a string.')
- cleaned_deps = []
- for d in deps:
- if not isinstance(d, (build.BuildTarget, build.CustomTarget)):
- raise InterpreterException('Depends items must be build targets.')
- cleaned_deps.append(d)
- command, *cmd_args = cleaned_args
- tg = RunTargetHolder(build.RunTarget(name, command, cmd_args, cleaned_deps, self.subdir, self.subproject), self)
- self.add_target(name, tg.held_object)
- full_name = (self.subproject, name)
- assert(full_name not in self.build.run_target_names)
- self.build.run_target_names.add(full_name)
- return tg
-
- @FeatureNew('alias_target', '0.52.0')
- @noKwargs
- def func_alias_target(self, node, args, kwargs):
- if len(args) < 2:
- raise InvalidCode('alias_target takes at least 2 arguments.')
- name = args[0]
- if not isinstance(name, str):
- raise InterpreterException('First argument must be a string.')
- deps = listify(args[1:], unholder=True)
- for d in deps:
- if not isinstance(d, (build.BuildTarget, build.CustomTarget)):
- raise InterpreterException('Depends items must be build targets.')
- tg = RunTargetHolder(build.AliasTarget(name, deps, self.subdir, self.subproject), self)
- self.add_target(name, tg.held_object)
- return tg
-
- @permittedKwargs(permitted_kwargs['generator'])
- def func_generator(self, node, args, kwargs):
- gen = GeneratorHolder(self, args, kwargs)
- self.generators.append(gen)
- return gen
-
- @FeatureNewKwargs('benchmark', '0.46.0', ['depends'])
- @FeatureNewKwargs('benchmark', '0.52.0', ['priority'])
- @permittedKwargs(permitted_kwargs['benchmark'])
- def func_benchmark(self, node, args, kwargs):
- # is_parallel isn't valid here, so make sure it isn't passed
- if 'is_parallel' in kwargs:
- del kwargs['is_parallel']
- self.add_test(node, args, kwargs, False)
-
- @FeatureNewKwargs('test', '0.46.0', ['depends'])
- @FeatureNewKwargs('test', '0.52.0', ['priority'])
- @permittedKwargs(permitted_kwargs['test'])
- def func_test(self, node, args, kwargs):
- self.add_test(node, args, kwargs, True)
-
- def unpack_env_kwarg(self, kwargs) -> build.EnvironmentVariables:
- envlist = kwargs.get('env', EnvironmentVariablesHolder())
- if isinstance(envlist, EnvironmentVariablesHolder):
- env = envlist.held_object
- elif isinstance(envlist, dict):
- FeatureNew('environment dictionary', '0.52.0').use(self.subproject)
- env = EnvironmentVariablesHolder(envlist)
- env = env.held_object
- else:
- envlist = listify(envlist)
- # Convert from array to environment object
- env = EnvironmentVariablesHolder(envlist)
- env = env.held_object
- return env
-
- def add_test(self, node, args, kwargs, is_base_test):
- if len(args) != 2:
- raise InterpreterException('Incorrect number of arguments')
- if not isinstance(args[0], str):
- raise InterpreterException('First argument of test must be a string.')
- exe = args[1]
- if not isinstance(exe, (ExecutableHolder, JarHolder, ExternalProgramHolder)):
- if isinstance(exe, mesonlib.File):
- exe = self.func_find_program(node, args[1], {})
- else:
- raise InterpreterException('Second argument must be executable.')
- par = kwargs.get('is_parallel', True)
- if not isinstance(par, bool):
- raise InterpreterException('Keyword argument is_parallel must be a boolean.')
- cmd_args = extract_as_list(kwargs, 'args', unholder=True)
- for i in cmd_args:
- if not isinstance(i, (str, mesonlib.File, build.Target)):
- raise InterpreterException('Command line arguments must be strings, files or targets.')
- env = self.unpack_env_kwarg(kwargs)
- should_fail = kwargs.get('should_fail', False)
- if not isinstance(should_fail, bool):
- raise InterpreterException('Keyword argument should_fail must be a boolean.')
- timeout = kwargs.get('timeout', 30)
- if 'workdir' in kwargs:
- workdir = kwargs['workdir']
- if not isinstance(workdir, str):
- raise InterpreterException('Workdir keyword argument must be a string.')
- if not os.path.isabs(workdir):
- raise InterpreterException('Workdir keyword argument must be an absolute path.')
- else:
- workdir = None
- if not isinstance(timeout, int):
- raise InterpreterException('Timeout must be an integer.')
- protocol = kwargs.get('protocol', 'exitcode')
- if protocol not in ('exitcode', 'tap'):
- raise InterpreterException('Protocol must be "exitcode" or "tap".')
- suite = []
- prj = self.subproject if self.is_subproject() else self.build.project_name
- for s in mesonlib.stringlistify(kwargs.get('suite', '')):
- if len(s) > 0:
- s = ':' + s
- suite.append(prj.replace(' ', '_').replace(':', '_') + s)
- depends = extract_as_list(kwargs, 'depends', unholder=True)
- for dep in depends:
- if not isinstance(dep, (build.CustomTarget, build.BuildTarget)):
- raise InterpreterException('Depends items must be build targets.')
- priority = kwargs.get('priority', 0)
- if not isinstance(priority, int):
- raise InterpreterException('Keyword argument priority must be an integer.')
- t = Test(args[0], prj, suite, exe.held_object, depends, par, cmd_args,
- env, should_fail, timeout, workdir, protocol, priority)
- if is_base_test:
- self.build.tests.append(t)
- mlog.debug('Adding test', mlog.bold(args[0], True))
- else:
- self.build.benchmarks.append(t)
- mlog.debug('Adding benchmark', mlog.bold(args[0], True))
-
- @FeatureNewKwargs('install_headers', '0.47.0', ['install_mode'])
- @permittedKwargs(permitted_kwargs['install_headers'])
- def func_install_headers(self, node, args, kwargs):
- source_files = self.source_strings_to_files(args)
- kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
- h = Headers(source_files, kwargs)
- self.build.headers.append(h)
- return h
-
- @FeatureNewKwargs('install_man', '0.47.0', ['install_mode'])
- @permittedKwargs(permitted_kwargs['install_man'])
- def func_install_man(self, node, args, kwargs):
- fargs = self.source_strings_to_files(args)
- kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
- m = Man(fargs, kwargs)
- self.build.man.append(m)
- return m
-
- @FeatureNewKwargs('subdir', '0.44.0', ['if_found'])
- @permittedKwargs(permitted_kwargs['subdir'])
- def func_subdir(self, node, args, kwargs):
- self.validate_arguments(args, 1, [str])
- mesonlib.check_direntry_issues(args)
- if '..' in args[0]:
- raise InvalidArguments('Subdir contains ..')
- if self.subdir == '' and args[0] == self.subproject_dir:
- raise InvalidArguments('Must not go into subprojects dir with subdir(), use subproject() instead.')
- if self.subdir == '' and args[0].startswith('meson-'):
- raise InvalidArguments('The "meson-" prefix is reserved and cannot be used for top-level subdir().')
- for i in mesonlib.extract_as_list(kwargs, 'if_found'):
- if not hasattr(i, 'found_method'):
- raise InterpreterException('Object used in if_found does not have a found method.')
- if not i.found_method([], {}):
- return
- prev_subdir = self.subdir
- subdir = os.path.join(prev_subdir, args[0])
- if os.path.isabs(subdir):
- raise InvalidArguments('Subdir argument must be a relative path.')
- absdir = os.path.join(self.environment.get_source_dir(), subdir)
- symlinkless_dir = os.path.realpath(absdir)
- if symlinkless_dir in self.visited_subdirs:
- raise InvalidArguments('Tried to enter directory "%s", which has already been visited.'
- % subdir)
- self.visited_subdirs[symlinkless_dir] = True
- self.subdir = subdir
- os.makedirs(os.path.join(self.environment.build_dir, subdir), exist_ok=True)
- buildfilename = os.path.join(self.subdir, environment.build_filename)
- self.build_def_files.append(buildfilename)
- absname = os.path.join(self.environment.get_source_dir(), buildfilename)
- if not os.path.isfile(absname):
- self.subdir = prev_subdir
- raise InterpreterException('Non-existent build file {!r}'.format(buildfilename))
- with open(absname, encoding='utf8') as f:
- code = f.read()
- assert(isinstance(code, str))
- try:
- codeblock = mparser.Parser(code, self.subdir).parse()
- except mesonlib.MesonException as me:
- me.file = buildfilename
- raise me
- try:
- self.evaluate_codeblock(codeblock)
- except SubdirDoneRequest:
- pass
- self.subdir = prev_subdir
-
- def _get_kwarg_install_mode(self, kwargs):
- if kwargs.get('install_mode', None) is None:
- return None
- install_mode = []
- mode = mesonlib.typeslistify(kwargs.get('install_mode', []), (str, int))
- for m in mode:
- # We skip any arguments that are set to `false`
- if m is False:
- m = None
- install_mode.append(m)
- if len(install_mode) > 3:
- raise InvalidArguments('Keyword argument install_mode takes at '
- 'most 3 arguments.')
- if len(install_mode) > 0 and install_mode[0] is not None and \
- not isinstance(install_mode[0], str):
- raise InvalidArguments('Keyword argument install_mode requires the '
- 'permissions arg to be a string or false')
- return FileMode(*install_mode)
-
- @FeatureNewKwargs('install_data', '0.46.0', ['rename'])
- @FeatureNewKwargs('install_data', '0.38.0', ['install_mode'])
- @permittedKwargs(permitted_kwargs['install_data'])
- def func_install_data(self, node, args, kwargs):
- kwsource = mesonlib.stringlistify(kwargs.get('sources', []))
- raw_sources = args + kwsource
- sources = []
- source_strings = []
- for s in raw_sources:
- if isinstance(s, mesonlib.File):
- sources.append(s)
- elif isinstance(s, str):
- source_strings.append(s)
- else:
- raise InvalidArguments('Argument {!r} must be string or file.'.format(s))
- sources += self.source_strings_to_files(source_strings)
- install_dir = kwargs.get('install_dir', None)
- if not isinstance(install_dir, (str, type(None))):
- raise InvalidArguments('Keyword argument install_dir not a string.')
- install_mode = self._get_kwarg_install_mode(kwargs)
- rename = kwargs.get('rename', None)
- data = DataHolder(build.Data(sources, install_dir, install_mode, rename))
- self.build.data.append(data.held_object)
- return data
-
- @FeatureNewKwargs('install_subdir', '0.42.0', ['exclude_files', 'exclude_directories'])
- @FeatureNewKwargs('install_subdir', '0.38.0', ['install_mode'])
- @permittedKwargs(permitted_kwargs['install_subdir'])
- @stringArgs
- def func_install_subdir(self, node, args, kwargs):
- if len(args) != 1:
- raise InvalidArguments('Install_subdir requires exactly one argument.')
- subdir = args[0]
- if 'install_dir' not in kwargs:
- raise InvalidArguments('Missing keyword argument install_dir')
- install_dir = kwargs['install_dir']
- if not isinstance(install_dir, str):
- raise InvalidArguments('Keyword argument install_dir not a string.')
- if 'strip_directory' in kwargs:
- if not isinstance(kwargs['strip_directory'], bool):
- raise InterpreterException('"strip_directory" keyword must be a boolean.')
- strip_directory = kwargs['strip_directory']
- else:
- strip_directory = False
- if 'exclude_files' in kwargs:
- exclude = extract_as_list(kwargs, 'exclude_files')
- for f in exclude:
- if not isinstance(f, str):
- raise InvalidArguments('Exclude argument not a string.')
- elif os.path.isabs(f):
- raise InvalidArguments('Exclude argument cannot be absolute.')
- exclude_files = set(exclude)
- else:
- exclude_files = set()
- if 'exclude_directories' in kwargs:
- exclude = extract_as_list(kwargs, 'exclude_directories')
- for d in exclude:
- if not isinstance(d, str):
- raise InvalidArguments('Exclude argument not a string.')
- elif os.path.isabs(d):
- raise InvalidArguments('Exclude argument cannot be absolute.')
- exclude_directories = set(exclude)
- else:
- exclude_directories = set()
- exclude = (exclude_files, exclude_directories)
- install_mode = self._get_kwarg_install_mode(kwargs)
- idir = InstallDir(self.subdir, subdir, install_dir, install_mode, exclude, strip_directory)
- self.build.install_dirs.append(idir)
- return idir
-
- @FeatureNewKwargs('configure_file', '0.47.0', ['copy', 'output_format', 'install_mode', 'encoding'])
- @FeatureNewKwargs('configure_file', '0.46.0', ['format'])
- @FeatureNewKwargs('configure_file', '0.41.0', ['capture'])
- @FeatureNewKwargs('configure_file', '0.50.0', ['install'])
- @FeatureNewKwargs('configure_file', '0.52.0', ['depfile'])
- @permittedKwargs(permitted_kwargs['configure_file'])
- def func_configure_file(self, node, args, kwargs):
- if len(args) > 0:
- raise InterpreterException("configure_file takes only keyword arguments.")
- if 'output' not in kwargs:
- raise InterpreterException('Required keyword argument "output" not defined.')
- actions = set(['configuration', 'command', 'copy']).intersection(kwargs.keys())
- if len(actions) == 0:
- raise InterpreterException('Must specify an action with one of these '
- 'keyword arguments: \'configuration\', '
- '\'command\', or \'copy\'.')
- elif len(actions) == 2:
- raise InterpreterException('Must not specify both {!r} and {!r} '
- 'keyword arguments since they are '
- 'mutually exclusive.'.format(*actions))
- elif len(actions) == 3:
- raise InterpreterException('Must specify one of {!r}, {!r}, and '
- '{!r} keyword arguments since they are '
- 'mutually exclusive.'.format(*actions))
- if 'capture' in kwargs:
- if not isinstance(kwargs['capture'], bool):
- raise InterpreterException('"capture" keyword must be a boolean.')
- if 'command' not in kwargs:
- raise InterpreterException('"capture" keyword requires "command" keyword.')
-
- if 'format' in kwargs:
- fmt = kwargs['format']
- if not isinstance(fmt, str):
- raise InterpreterException('"format" keyword must be a string.')
- else:
- fmt = 'meson'
-
- if fmt not in ('meson', 'cmake', 'cmake@'):
- raise InterpreterException('"format" possible values are "meson", "cmake" or "cmake@".')
-
- if 'output_format' in kwargs:
- output_format = kwargs['output_format']
- if not isinstance(output_format, str):
- raise InterpreterException('"output_format" keyword must be a string.')
- else:
- output_format = 'c'
-
- if output_format not in ('c', 'nasm'):
- raise InterpreterException('"format" possible values are "c" or "nasm".')
-
- if 'depfile' in kwargs:
- depfile = kwargs['depfile']
- if not isinstance(depfile, str):
- raise InterpreterException('depfile file name must be a string')
- else:
- depfile = None
-
- # Validate input
- inputs = self.source_strings_to_files(extract_as_list(kwargs, 'input'))
- inputs_abs = []
- for f in inputs:
- if isinstance(f, mesonlib.File):
- inputs_abs.append(f.absolute_path(self.environment.source_dir,
- self.environment.build_dir))
- self.add_build_def_file(f)
- else:
- raise InterpreterException('Inputs can only be strings or file objects')
- # Validate output
- output = kwargs['output']
- if not isinstance(output, str):
- raise InterpreterException('Output file name must be a string')
- if inputs_abs:
- values = mesonlib.get_filenames_templates_dict(inputs_abs, None)
- outputs = mesonlib.substitute_values([output], values)
- output = outputs[0]
- if depfile:
- depfile = mesonlib.substitute_values([depfile], values)[0]
- ofile_rpath = os.path.join(self.subdir, output)
- if ofile_rpath in self.configure_file_outputs:
- mesonbuildfile = os.path.join(self.subdir, 'meson.build')
- current_call = "{}:{}".format(mesonbuildfile, self.current_lineno)
- first_call = "{}:{}".format(mesonbuildfile, self.configure_file_outputs[ofile_rpath])
- mlog.warning('Output file', mlog.bold(ofile_rpath, True), 'for configure_file() at', current_call, 'overwrites configure_file() output at', first_call)
- else:
- self.configure_file_outputs[ofile_rpath] = self.current_lineno
- if os.path.dirname(output) != '':
- raise InterpreterException('Output file name must not contain a subdirectory.')
- (ofile_path, ofile_fname) = os.path.split(os.path.join(self.subdir, output))
- ofile_abs = os.path.join(self.environment.build_dir, ofile_path, ofile_fname)
- # Perform the appropriate action
- if 'configuration' in kwargs:
- conf = kwargs['configuration']
- if isinstance(conf, dict):
- FeatureNew('configure_file.configuration dictionary', '0.49.0').use(self.subproject)
- conf = ConfigurationDataHolder(self.subproject, conf)
- elif not isinstance(conf, ConfigurationDataHolder):
- raise InterpreterException('Argument "configuration" is not of type configuration_data')
- mlog.log('Configuring', mlog.bold(output), 'using configuration')
- if len(inputs) > 1:
- raise InterpreterException('At most one input file can given in configuration mode')
- if inputs:
- os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
- file_encoding = kwargs.setdefault('encoding', 'utf-8')
- missing_variables, confdata_useless = \
- mesonlib.do_conf_file(inputs_abs[0], ofile_abs, conf.held_object,
- fmt, file_encoding)
- if missing_variables:
- var_list = ", ".join(map(repr, sorted(missing_variables)))
- mlog.warning(
- "The variable(s) %s in the input file '%s' are not "
- "present in the given configuration data." % (
- var_list, inputs[0]), location=node)
- if confdata_useless:
- ifbase = os.path.basename(inputs_abs[0])
- mlog.warning('Got an empty configuration_data() object and found no '
- 'substitutions in the input file {!r}. If you want to '
- 'copy a file to the build dir, use the \'copy:\' keyword '
- 'argument added in 0.47.0'.format(ifbase), location=node)
- else:
- mesonlib.dump_conf_header(ofile_abs, conf.held_object, output_format)
- conf.mark_used()
- elif 'command' in kwargs:
- if len(inputs) > 1:
- FeatureNew('multiple inputs in configure_file()', '0.52.0').use(self.subproject)
- # We use absolute paths for input and output here because the cwd
- # that the command is run from is 'unspecified', so it could change.
- # Currently it's builddir/subdir for in_builddir else srcdir/subdir.
- values = mesonlib.get_filenames_templates_dict(inputs_abs, [ofile_abs])
- if depfile:
- depfile = os.path.join(self.environment.get_scratch_dir(), depfile)
- values['@DEPFILE@'] = depfile
- # Substitute @INPUT@, @OUTPUT@, etc here.
- cmd = mesonlib.substitute_values(kwargs['command'], values)
- mlog.log('Configuring', mlog.bold(output), 'with command')
- res = self.run_command_impl(node, cmd, {}, True)
- if res.returncode != 0:
- raise InterpreterException('Running configure command failed.\n%s\n%s' %
- (res.stdout, res.stderr))
- if 'capture' in kwargs and kwargs['capture']:
- dst_tmp = ofile_abs + '~'
- file_encoding = kwargs.setdefault('encoding', 'utf-8')
- with open(dst_tmp, 'w', encoding=file_encoding) as f:
- f.writelines(res.stdout)
- if inputs_abs:
- shutil.copymode(inputs_abs[0], dst_tmp)
- mesonlib.replace_if_different(ofile_abs, dst_tmp)
- if depfile:
- mlog.log('Reading depfile:', mlog.bold(depfile))
- with open(depfile, 'r') as f:
- df = DepFile(f.readlines())
- deps = df.get_all_dependencies(ofile_fname)
- for dep in deps:
- self.add_build_def_file(dep)
-
- elif 'copy' in kwargs:
- if len(inputs_abs) != 1:
- raise InterpreterException('Exactly one input file must be given in copy mode')
- os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True)
- shutil.copyfile(inputs_abs[0], ofile_abs)
- shutil.copystat(inputs_abs[0], ofile_abs)
- else:
- # Not reachable
- raise AssertionError
- # Install file if requested, we check for the empty string
- # for backwards compatibility. That was the behaviour before
- # 0.45.0 so preserve it.
- idir = kwargs.get('install_dir', '')
- if idir is False:
- idir = ''
- mlog.deprecation('Please use the new `install:` kwarg instead of passing '
- '`false` to `install_dir:`', location=node)
- if not isinstance(idir, str):
- if isinstance(idir, list) and len(idir) == 0:
- mlog.deprecation('install_dir: kwarg must be a string and not an empty array. '
- 'Please use the install: kwarg to enable or disable installation. '
- 'This will be a hard error in the next release.')
- else:
- raise InterpreterException('"install_dir" must be a string')
- install = kwargs.get('install', idir != '')
- if not isinstance(install, bool):
- raise InterpreterException('"install" must be a boolean')
- if install:
- if not idir:
- raise InterpreterException('"install_dir" must be specified '
- 'when "install" in a configure_file '
- 'is true')
- cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)
- install_mode = self._get_kwarg_install_mode(kwargs)
- self.build.data.append(build.Data([cfile], idir, install_mode))
- return mesonlib.File.from_built_file(self.subdir, output)
-
- def extract_incdirs(self, kwargs):
- prospectives = listify(kwargs.get('include_directories', []), unholder=True)
- result = []
- for p in prospectives:
- if isinstance(p, build.IncludeDirs):
- result.append(p)
- elif isinstance(p, str):
- result.append(self.build_incdir_object([p]).held_object)
- else:
- raise InterpreterException('Include directory objects can only be created from strings or include directories.')
- return result
-
- @permittedKwargs(permitted_kwargs['include_directories'])
- @stringArgs
- def func_include_directories(self, node, args, kwargs):
- return self.build_incdir_object(args, kwargs.get('is_system', False))
-
- def build_incdir_object(self, incdir_strings, is_system=False):
- if not isinstance(is_system, bool):
- raise InvalidArguments('Is_system must be boolean.')
- src_root = self.environment.get_source_dir()
- build_root = self.environment.get_build_dir()
- absbase_src = os.path.join(src_root, self.subdir)
- absbase_build = os.path.join(build_root, self.subdir)
-
- for a in incdir_strings:
- if a.startswith(src_root):
- raise InvalidArguments('''Tried to form an absolute path to a source dir. You should not do that but use
-relative paths instead.
-
-To get include path to any directory relative to the current dir do
-
-incdir = include_directories(dirname)
-
-After this incdir will contain both the current source dir as well as the
-corresponding build dir. It can then be used in any subdirectory and
-Meson will take care of all the busywork to make paths work.
-
-Dirname can even be '.' to mark the current directory. Though you should
-remember that the current source and build directories are always
-put in the include directories by default so you only need to do
-include_directories('.') if you intend to use the result in a
-different subdirectory.
-''')
- absdir_src = os.path.join(absbase_src, a)
- absdir_build = os.path.join(absbase_build, a)
- if not os.path.isdir(absdir_src) and not os.path.isdir(absdir_build):
- raise InvalidArguments('Include dir %s does not exist.' % a)
- i = IncludeDirsHolder(build.IncludeDirs(self.subdir, incdir_strings, is_system))
- return i
-
- @permittedKwargs(permitted_kwargs['add_test_setup'])
- @stringArgs
- def func_add_test_setup(self, node, args, kwargs):
- if len(args) != 1:
- raise InterpreterException('Add_test_setup needs one argument for the setup name.')
- setup_name = args[0]
- if re.fullmatch('([_a-zA-Z][_0-9a-zA-Z]*:)?[_a-zA-Z][_0-9a-zA-Z]*', setup_name) is None:
- raise InterpreterException('Setup name may only contain alphanumeric characters.')
- if ":" not in setup_name:
- setup_name = (self.subproject if self.subproject else self.build.project_name) + ":" + setup_name
- try:
- inp = extract_as_list(kwargs, 'exe_wrapper', unholder=True)
- exe_wrapper = []
- for i in inp:
- if isinstance(i, str):
- exe_wrapper.append(i)
- elif isinstance(i, dependencies.ExternalProgram):
- if not i.found():
- raise InterpreterException('Tried to use non-found executable.')
- exe_wrapper += i.get_command()
- else:
- raise InterpreterException('Exe wrapper can only contain strings or external binaries.')
- except KeyError:
- exe_wrapper = None
- gdb = kwargs.get('gdb', False)
- if not isinstance(gdb, bool):
- raise InterpreterException('Gdb option must be a boolean')
- timeout_multiplier = kwargs.get('timeout_multiplier', 1)
- if not isinstance(timeout_multiplier, int):
- raise InterpreterException('Timeout multiplier must be a number.')
- is_default = kwargs.get('is_default', False)
- if not isinstance(is_default, bool):
- raise InterpreterException('is_default option must be a boolean')
- if is_default:
- if self.build.test_setup_default_name is not None:
- raise InterpreterException('\'%s\' is already set as default. '
- 'is_default can be set to true only once' % self.build.test_setup_default_name)
- self.build.test_setup_default_name = setup_name
- env = self.unpack_env_kwarg(kwargs)
- self.build.test_setups[setup_name] = build.TestSetup(exe_wrapper, gdb, timeout_multiplier, env)
-
- @permittedKwargs(permitted_kwargs['add_global_arguments'])
- @stringArgs
- def func_add_global_arguments(self, node, args, kwargs):
- for_machine = self.machine_from_native_kwarg(kwargs)
- self.add_global_arguments(node, self.build.global_args[for_machine], args, kwargs)
-
- @permittedKwargs(permitted_kwargs['add_global_link_arguments'])
- @stringArgs
- def func_add_global_link_arguments(self, node, args, kwargs):
- for_machine = self.machine_from_native_kwarg(kwargs)
- self.add_global_arguments(node, self.build.global_link_args[for_machine], args, kwargs)
-
- @permittedKwargs(permitted_kwargs['add_project_arguments'])
- @stringArgs
- def func_add_project_arguments(self, node, args, kwargs):
- for_machine = self.machine_from_native_kwarg(kwargs)
- self.add_project_arguments(node, self.build.projects_args[for_machine], args, kwargs)
-
- @permittedKwargs(permitted_kwargs['add_project_link_arguments'])
- @stringArgs
- def func_add_project_link_arguments(self, node, args, kwargs):
- for_machine = self.machine_from_native_kwarg(kwargs)
- self.add_project_arguments(node, self.build.projects_link_args[for_machine], args, kwargs)
-
- def warn_about_builtin_args(self, args):
- warnargs = ('/W1', '/W2', '/W3', '/W4', '/Wall', '-Wall', '-Wextra', '-Wpedantic')
- optargs = ('-O0', '-O2', '-O3', '-Os', '/O1', '/O2', '/Os')
- for arg in args:
- if arg in warnargs:
- mlog.warning('Consider using the built-in warning_level option instead of using "{}".'.format(arg),
- location=self.current_node)
- elif arg in optargs:
- mlog.warning('Consider using the built-in optimization level instead of using "{}".'.format(arg),
- location=self.current_node)
- elif arg == '-g':
- mlog.warning('Consider using the built-in debug option instead of using "{}".'.format(arg),
- location=self.current_node)
- elif arg == '-pipe':
- mlog.warning("You don't need to add -pipe, Meson will use it automatically when it is available.",
- location=self.current_node)
- elif arg.startswith('-fsanitize'):
- mlog.warning('Consider using the built-in option for sanitizers instead of using "{}".'.format(arg),
- location=self.current_node)
- elif arg.startswith('-std=') or arg.startswith('/std:'):
- mlog.warning('Consider using the built-in option for language standard version instead of using "{}".'.format(arg),
- location=self.current_node)
-
- def add_global_arguments(self, node, argsdict, args, kwargs):
- if self.is_subproject():
- msg = 'Function \'{}\' cannot be used in subprojects because ' \
- 'there is no way to make that reliable.\nPlease only call ' \
- 'this if is_subproject() returns false. Alternatively, ' \
- 'define a variable that\ncontains your language-specific ' \
- 'arguments and add it to the appropriate *_args kwarg ' \
- 'in each target.'.format(node.func_name)
- raise InvalidCode(msg)
- frozen = self.project_args_frozen or self.global_args_frozen
- self.add_arguments(node, argsdict, frozen, args, kwargs)
-
- def add_project_arguments(self, node, argsdict, args, kwargs):
- if self.subproject not in argsdict:
- argsdict[self.subproject] = {}
- self.add_arguments(node, argsdict[self.subproject],
- self.project_args_frozen, args, kwargs)
-
- def add_arguments(self, node, argsdict, args_frozen, args, kwargs):
- if args_frozen:
- msg = 'Tried to use \'{}\' after a build target has been declared.\n' \
- 'This is not permitted. Please declare all ' \
- 'arguments before your targets.'.format(node.func_name)
- raise InvalidCode(msg)
-
- if 'language' not in kwargs:
- raise InvalidCode('Missing language definition in {}'.format(node.func_name))
-
- self.warn_about_builtin_args(args)
-
- for lang in mesonlib.stringlistify(kwargs['language']):
- lang = lang.lower()
- argsdict[lang] = argsdict.get(lang, []) + args
-
- @noKwargs
- @noArgsFlattening
- def func_environment(self, node, args, kwargs):
- if len(args) > 1:
- raise InterpreterException('environment takes only one optional positional arguments')
- elif len(args) == 1:
- FeatureNew('environment positional arguments', '0.52.0').use(self.subproject)
- initial_values = args[0]
- if not isinstance(initial_values, dict) and not isinstance(initial_values, list):
- raise InterpreterException('environment first argument must be a dictionary or a list')
- else:
- initial_values = {}
- return EnvironmentVariablesHolder(initial_values)
-
- @stringArgs
- @noKwargs
- def func_join_paths(self, node, args, kwargs):
- return self.join_path_strings(args)
-
- def run(self):
- super().run()
- mlog.log('Build targets in project:', mlog.bold(str(len(self.build.targets))))
- FeatureNew.report(self.subproject)
- FeatureDeprecated.report(self.subproject)
- if not self.is_subproject():
- self.print_extra_warnings()
- if self.subproject == '':
- self._print_summary()
-
- def print_extra_warnings(self):
- # TODO cross compilation
- for c in self.coredata.compilers.host.values():
- if c.get_id() == 'clang':
- self.check_clang_asan_lundef()
- break
-
- def check_clang_asan_lundef(self):
- if 'b_lundef' not in self.coredata.base_options:
- return
- if 'b_sanitize' not in self.coredata.base_options:
- return
- if (self.coredata.base_options['b_lundef'].value and
- self.coredata.base_options['b_sanitize'].value != 'none'):
- mlog.warning('''Trying to use {} sanitizer on Clang with b_lundef.
-This will probably not work.
-Try setting b_lundef to false instead.'''.format(self.coredata.base_options['b_sanitize'].value),
- location=self.current_node)
-
- def evaluate_subproject_info(self, path_from_source_root, subproject_dirname):
- depth = 0
- subproj_name = ''
- segs = PurePath(path_from_source_root).parts
- segs_spd = PurePath(subproject_dirname).parts
- while segs and segs[0] == segs_spd[0]:
- if len(segs_spd) == 1:
- subproj_name = segs[1]
- segs = segs[2:]
- depth += 1
- else:
- segs_spd = segs_spd[1:]
- segs = segs[1:]
- return (depth, subproj_name)
-
- # Check that the indicated file is within the same subproject
- # as we currently are. This is to stop people doing
- # nasty things like:
- #
- # f = files('../../master_src/file.c')
- #
- # Note that this is validated only when the file
- # object is generated. The result can be used in a different
- # subproject than it is defined in (due to e.g. a
- # declare_dependency).
- def validate_within_subproject(self, subdir, fname):
- norm = os.path.normpath(os.path.join(subdir, fname))
- if os.path.isabs(norm):
- if not norm.startswith(self.environment.source_dir):
- # Grabbing files outside the source tree is ok.
- # This is for vendor stuff like:
- #
- # /opt/vendorsdk/src/file_with_license_restrictions.c
- return
- norm = os.path.relpath(norm, self.environment.source_dir)
- assert(not os.path.isabs(norm))
- (num_sps, sproj_name) = self.evaluate_subproject_info(norm, self.subproject_dir)
- plain_filename = os.path.basename(norm)
- if num_sps == 0:
- if not self.is_subproject():
- return
- raise InterpreterException('Sandbox violation: Tried to grab file %s from a different subproject.' % plain_filename)
- if num_sps > 1:
- raise InterpreterException('Sandbox violation: Tried to grab file %s from a nested subproject.' % plain_filename)
- if sproj_name != self.subproject_directory_name:
- raise InterpreterException('Sandbox violation: Tried to grab file %s from a different subproject.' % plain_filename)
-
- def source_strings_to_files(self, sources):
- results = []
- mesonlib.check_direntry_issues(sources)
- if not isinstance(sources, list):
- sources = [sources]
- for s in sources:
- if isinstance(s, (mesonlib.File, GeneratedListHolder,
- TargetHolder, CustomTargetIndexHolder,
- GeneratedObjectsHolder)):
- pass
- elif isinstance(s, str):
- self.validate_within_subproject(self.subdir, s)
- s = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, s)
- else:
- raise InterpreterException('Source item is {!r} instead of '
- 'string or File-type object'.format(s))
- results.append(s)
- return results
-
- def add_target(self, name, tobj):
- if name == '':
- raise InterpreterException('Target name must not be empty.')
- if name.strip() == '':
- raise InterpreterException('Target name must not consist only of whitespace.')
- if name.startswith('meson-'):
- raise InvalidArguments("Target names starting with 'meson-' are reserved "
- "for Meson's internal use. Please rename.")
- if name in coredata.forbidden_target_names:
- raise InvalidArguments("Target name '%s' is reserved for Meson's "
- "internal use. Please rename." % name)
- # To permit an executable and a shared library to have the
- # same name, such as "foo.exe" and "libfoo.a".
- idname = tobj.get_id()
- if idname in self.build.targets:
- raise InvalidCode('Tried to create target "%s", but a target of that name already exists.' % name)
- self.build.targets[idname] = tobj
- if idname not in self.coredata.target_guids:
- self.coredata.target_guids[idname] = str(uuid.uuid4()).upper()
-
- @FeatureNew('both_libraries', '0.46.0')
- def build_both_libraries(self, node, args, kwargs):
- shared_holder = self.build_target(node, args, kwargs, SharedLibraryHolder)
-
- # Check if user forces non-PIC static library.
- pic = True
- if 'pic' in kwargs:
- pic = kwargs['pic']
- elif 'b_staticpic' in self.environment.coredata.base_options:
- pic = self.environment.coredata.base_options['b_staticpic'].value
-
- if pic:
- # Exclude sources from args and kwargs to avoid building them twice
- static_args = [args[0]]
- static_kwargs = kwargs.copy()
- static_kwargs['sources'] = []
- static_kwargs['objects'] = shared_holder.held_object.extract_all_objects()
- else:
- static_args = args
- static_kwargs = kwargs
-
- static_holder = self.build_target(node, static_args, static_kwargs, StaticLibraryHolder)
-
- return BothLibrariesHolder(shared_holder, static_holder, self)
-
- def build_library(self, node, args, kwargs):
- default_library = self.coredata.get_builtin_option('default_library')
- if default_library == 'shared':
- return self.build_target(node, args, kwargs, SharedLibraryHolder)
- elif default_library == 'static':
- return self.build_target(node, args, kwargs, StaticLibraryHolder)
- elif default_library == 'both':
- return self.build_both_libraries(node, args, kwargs)
- else:
- raise InterpreterException('Unknown default_library value: %s.', default_library)
-
- def build_target(self, node, args, kwargs, targetholder):
- @FeatureNewKwargs('build target', '0.42.0', ['rust_crate_type', 'build_rpath', 'implicit_include_directories'])
- @FeatureNewKwargs('build target', '0.41.0', ['rust_args'])
- @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
- @FeatureNewKwargs('build target', '0.48.0', ['gnu_symbol_visibility'])
- def build_target_decorator_caller(self, node, args, kwargs):
- return True
-
- build_target_decorator_caller(self, node, args, kwargs)
-
- if not args:
- raise InterpreterException('Target does not have a name.')
- name, *sources = args
- for_machine = self.machine_from_native_kwarg(kwargs)
- if 'sources' in kwargs:
- sources += listify(kwargs['sources'])
- sources = self.source_strings_to_files(sources)
- objs = extract_as_list(kwargs, 'objects')
- kwargs['dependencies'] = extract_as_list(kwargs, 'dependencies')
- kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs)
- if 'extra_files' in kwargs:
- ef = extract_as_list(kwargs, 'extra_files')
- kwargs['extra_files'] = self.source_strings_to_files(ef)
- self.check_sources_exist(os.path.join(self.source_root, self.subdir), sources)
- if targetholder is ExecutableHolder:
- targetclass = build.Executable
- elif targetholder is SharedLibraryHolder:
- targetclass = build.SharedLibrary
- elif targetholder is SharedModuleHolder:
- targetclass = build.SharedModule
- elif targetholder is StaticLibraryHolder:
- targetclass = build.StaticLibrary
- elif targetholder is JarHolder:
- targetclass = build.Jar
- else:
- mlog.debug('Unknown target type:', str(targetholder))
- raise RuntimeError('Unreachable code')
- self.kwarg_strings_to_includedirs(kwargs)
-
- # Filter out kwargs from other target types. For example 'soversion'
- # passed to library() when default_library == 'static'.
- kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs}
-
- kwargs['include_directories'] = self.extract_incdirs(kwargs)
- target = targetclass(name, self.subdir, self.subproject, for_machine, sources, objs, self.environment, kwargs)
-
- if not self.environment.machines.matches_build_machine(for_machine):
- self.add_cross_stdlib_info(target)
- l = targetholder(target, self)
- self.add_target(name, l.held_object)
- self.project_args_frozen = True
- return l
-
- def kwarg_strings_to_includedirs(self, kwargs):
- if 'd_import_dirs' in kwargs:
- items = mesonlib.extract_as_list(kwargs, 'd_import_dirs')
- cleaned_items = []
- for i in items:
- if isinstance(i, str):
- # BW compatibility. This was permitted so we must support it
- # for a few releases so people can transition to "correct"
- # path declarations.
- if os.path.normpath(i).startswith(self.environment.get_source_dir()):
- mlog.warning('''Building a path to the source dir is not supported. Use a relative path instead.
-This will become a hard error in the future.''', location=self.current_node)
- i = os.path.relpath(i, os.path.join(self.environment.get_source_dir(), self.subdir))
- i = self.build_incdir_object([i])
- cleaned_items.append(i)
- kwargs['d_import_dirs'] = cleaned_items
-
- def get_used_languages(self, target):
- result = {}
- for i in target.sources:
- # TODO other platforms
- for lang, c in self.coredata.compilers.host.items():
- if c.can_compile(i):
- result[lang] = True
- break
- return result
-
- def add_cross_stdlib_info(self, target):
- if target.for_machine != MachineChoice.HOST:
- return
- for l in self.get_used_languages(target):
- props = self.environment.properties.host
- if props.has_stdlib(l) \
- and self.subproject != props.get_stdlib(l)[0]:
- target.add_deps(self.build.stdlibs.host[l])
-
- def check_sources_exist(self, subdir, sources):
- for s in sources:
- if not isinstance(s, str):
- continue # This means a generated source and they always exist.
- fname = os.path.join(subdir, s)
- if not os.path.isfile(fname):
- raise InterpreterException('Tried to add non-existing source file %s.' % s)
-
- # Only permit object extraction from the same subproject
- def validate_extraction(self, buildtarget):
- if not self.subdir.startswith(self.subproject_dir):
- if buildtarget.subdir.startswith(self.subproject_dir):
- raise InterpreterException('Tried to extract objects from a subproject target.')
- else:
- if not buildtarget.subdir.startswith(self.subproject_dir):
- raise InterpreterException('Tried to extract objects from the main project from a subproject.')
- if self.subdir.split('/')[1] != buildtarget.subdir.split('/')[1]:
- raise InterpreterException('Tried to extract objects from a different subproject.')
-
- def check_contains(self, obj, args):
- if len(args) != 1:
- raise InterpreterException('Contains method takes exactly one argument.')
- item = args[0]
- for element in obj:
- if isinstance(element, list):
- found = self.check_contains(element, args)
- if found:
- return True
- if element == item:
- return True
- return False
-
- def is_subproject(self):
- return self.subproject != ''
-
- @noKwargs
- @noArgsFlattening
- def func_set_variable(self, node, args, kwargs):
- if len(args) != 2:
- raise InvalidCode('Set_variable takes two arguments.')
- varname, value = args
- self.set_variable(varname, value)
-
- @noKwargs
- @noArgsFlattening
- def func_get_variable(self, node, args, kwargs):
- if len(args) < 1 or len(args) > 2:
- raise InvalidCode('Get_variable takes one or two arguments.')
- varname = args[0]
- if not isinstance(varname, str):
- raise InterpreterException('First argument must be a string.')
- try:
- return self.variables[varname]
- except KeyError:
- pass
- if len(args) == 2:
- return args[1]
- raise InterpreterException('Tried to get unknown variable "%s".' % varname)
-
- @stringArgs
- @noKwargs
- def func_is_variable(self, node, args, kwargs):
- if len(args) != 1:
- raise InvalidCode('Is_variable takes two arguments.')
- varname = args[0]
- return varname in self.variables
-
- @staticmethod
- def machine_from_native_kwarg(kwargs: T.Dict[str, T.Any]) -> MachineChoice:
- native = kwargs.get('native', False)
- if not isinstance(native, bool):
- raise InvalidArguments('Argument to "native" must be a boolean.')
- return MachineChoice.BUILD if native else MachineChoice.HOST
-
- @FeatureNew('is_disabler', '0.52.0')
- @noKwargs
- def func_is_disabler(self, node, args, kwargs):
- if len(args) != 1:
- raise InvalidCode('Is_disabler takes one argument.')
- varname = args[0]
- return isinstance(varname, Disabler)
diff -Nru meson-0.53.2/mesonbuild/linkers/detect.py meson-0.61.2/mesonbuild/linkers/detect.py
--- meson-0.53.2/mesonbuild/linkers/detect.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/linkers/detect.py 2021-11-02 19:58:13.000000000 +0000
@@ -0,0 +1,218 @@
+# Copyright 2012-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 ..mesonlib import (
+ EnvironmentException, MachineChoice, OptionKey,
+ Popen_safe, search_version
+)
+from .linkers import (
+ DynamicLinker,
+ AppleDynamicLinker,
+ GnuDynamicLinker,
+ GnuGoldDynamicLinker,
+ GnuBFDDynamicLinker,
+ LLVMDynamicLinker,
+ QualcommLLVMDynamicLinker,
+ MSVCDynamicLinker,
+ ClangClDynamicLinker,
+ SolarisDynamicLinker,
+ AIXDynamicLinker,
+ OptlinkDynamicLinker,
+)
+
+import re
+import shlex
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+ from ..compilers import Compiler
+
+defaults: T.Dict[str, T.List[str]] = {}
+defaults['static_linker'] = ['ar', 'gar']
+defaults['vs_static_linker'] = ['lib']
+defaults['clang_cl_static_linker'] = ['llvm-lib']
+defaults['cuda_static_linker'] = ['nvlink']
+defaults['gcc_static_linker'] = ['gcc-ar']
+defaults['clang_static_linker'] = ['llvm-ar']
+
+def __failed_to_detect_linker(compiler: T.List[str], args: T.List[str], stdout: str, stderr: str) -> 'T.NoReturn':
+ msg = 'Unable to detect linker for compiler "{} {}"\nstdout: {}\nstderr: {}'.format(
+ ' '.join(compiler), ' '.join(args), stdout, stderr)
+ raise EnvironmentException(msg)
+
+
+def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Type['Compiler'],
+ for_machine: MachineChoice, *,
+ use_linker_prefix: bool = True, invoked_directly: bool = True,
+ extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
+ env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+
+ # Explicitly pass logo here so that we can get the version of link.exe
+ if not use_linker_prefix or comp_class.LINKER_PREFIX is None:
+ check_args = ['/logo', '--version']
+ elif isinstance(comp_class.LINKER_PREFIX, str):
+ check_args = [comp_class.LINKER_PREFIX + '/logo', comp_class.LINKER_PREFIX + '--version']
+ elif isinstance(comp_class.LINKER_PREFIX, list):
+ check_args = comp_class.LINKER_PREFIX + ['/logo'] + comp_class.LINKER_PREFIX + ['--version']
+
+ check_args += env.coredata.options[OptionKey('args', lang=comp_class.language, machine=for_machine)].value
+
+ override = [] # type: T.List[str]
+ value = env.lookup_binary_entry(for_machine, comp_class.language + '_ld')
+ if value is not None:
+ override = comp_class.use_linker_args(value[0])
+ check_args += override
+
+ if extra_args is not None:
+ check_args.extend(extra_args)
+
+ p, o, _ = Popen_safe(compiler + check_args)
+ if 'LLD' in o.split('\n')[0]:
+ if '(compatible with GNU linkers)' in o:
+ return LLVMDynamicLinker(
+ compiler, for_machine, comp_class.LINKER_PREFIX,
+ override, version=search_version(o))
+ elif not invoked_directly:
+ return ClangClDynamicLinker(
+ for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX,
+ version=search_version(o), direct=False, machine=None)
+
+ if value is not None and invoked_directly:
+ compiler = value
+ # We've already hanedled the non-direct case above
+
+ p, o, e = Popen_safe(compiler + check_args)
+ if 'LLD' in o.split('\n')[0]:
+ return ClangClDynamicLinker(
+ for_machine, [],
+ prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
+ exelist=compiler, version=search_version(o), direct=invoked_directly)
+ elif 'OPTLINK' in o:
+ # Opltink's stdout *may* beging with a \r character.
+ return OptlinkDynamicLinker(compiler, for_machine, version=search_version(o))
+ elif o.startswith('Microsoft') or e.startswith('Microsoft'):
+ out = o or e
+ match = re.search(r'.*(X86|X64|ARM|ARM64).*', out)
+ if match:
+ target = str(match.group(1))
+ else:
+ target = 'x86'
+
+ return MSVCDynamicLinker(
+ for_machine, [], machine=target, exelist=compiler,
+ prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
+ version=search_version(out), direct=invoked_directly)
+ elif 'GNU coreutils' in o:
+ import shutil
+ fullpath = shutil.which(compiler[0])
+ raise EnvironmentException(
+ f"Found GNU link.exe instead of MSVC link.exe in {fullpath}.\n"
+ "This link.exe is not a linker.\n"
+ "You may need to reorder entries to your %PATH% variable to resolve this.")
+ __failed_to_detect_linker(compiler, check_args, o, e)
+
+def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Type['Compiler'],
+ for_machine: MachineChoice, *,
+ extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
+ """Helper for guessing what linker to use on Unix-Like OSes.
+
+ :compiler: Invocation to use to get linker
+ :comp_class: The Compiler Type (uninstantiated)
+ :for_machine: which machine this linker targets
+ :extra_args: Any additional arguments required (such as a source file)
+ """
+ env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+ extra_args = extra_args or []
+ extra_args += env.coredata.options[OptionKey('args', lang=comp_class.language, machine=for_machine)].value
+
+ if isinstance(comp_class.LINKER_PREFIX, str):
+ check_args = [comp_class.LINKER_PREFIX + '--version'] + extra_args
+ else:
+ check_args = comp_class.LINKER_PREFIX + ['--version'] + extra_args
+
+ override = [] # type: T.List[str]
+ value = env.lookup_binary_entry(for_machine, comp_class.language + '_ld')
+ if value is not None:
+ override = comp_class.use_linker_args(value[0])
+ check_args += override
+
+ _, o, e = Popen_safe(compiler + check_args)
+ v = search_version(o + e)
+ linker: DynamicLinker
+ if 'LLD' in o.split('\n')[0]:
+ linker = LLVMDynamicLinker(
+ compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+ elif 'Snapdragon' in e and 'LLVM' in e:
+ linker = QualcommLLVMDynamicLinker(
+ compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+ elif e.startswith('lld-link: '):
+ # The LLD MinGW frontend didn't respond to --version before version 9.0.0,
+ # and produced an error message about failing to link (when no object
+ # files were specified), instead of printing the version number.
+ # Let's try to extract the linker invocation command to grab the version.
+
+ _, o, e = Popen_safe(compiler + check_args + ['-v'])
+
+ try:
+ linker_cmd = re.match(r'.*\n(.*?)\nlld-link: ', e, re.DOTALL).group(1)
+ linker_cmd = shlex.split(linker_cmd)[0]
+ except (AttributeError, IndexError, ValueError):
+ pass
+ else:
+ _, o, e = Popen_safe([linker_cmd, '--version'])
+ v = search_version(o)
+
+ linker = LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+ # first is for apple clang, second is for real gcc, the third is icc
+ elif e.endswith('(use -v to see invocation)\n') or 'macosx_version' in e or 'ld: unknown option:' in e:
+ if isinstance(comp_class.LINKER_PREFIX, str):
+ _, _, e = Popen_safe(compiler + [comp_class.LINKER_PREFIX + '-v'] + extra_args)
+ else:
+ _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-v'] + extra_args)
+ for line in e.split('\n'):
+ if 'PROJECT:ld' in line:
+ v = line.split('-')[1]
+ break
+ else:
+ v = 'unknown version'
+ linker = AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+ elif 'GNU' in o or 'GNU' in e:
+ cls: T.Type[GnuDynamicLinker]
+ if 'gold' in o or 'gold' in e:
+ cls = GnuGoldDynamicLinker
+ else:
+ cls = GnuBFDDynamicLinker
+ linker = cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+ elif 'Solaris' in e or 'Solaris' in o:
+ for line in (o+e).split('\n'):
+ if 'ld: Software Generation Utilities' in line:
+ v = line.split(':')[2].lstrip()
+ break
+ else:
+ v = 'unknown version'
+ linker = SolarisDynamicLinker(
+ compiler, for_machine, comp_class.LINKER_PREFIX, override,
+ version=v)
+ elif 'ld: 0706-012 The -- flag is not recognized' in e:
+ if isinstance(comp_class.LINKER_PREFIX, str):
+ _, _, e = Popen_safe(compiler + [comp_class.LINKER_PREFIX + '-V'] + extra_args)
+ else:
+ _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-V'] + extra_args)
+ linker = AIXDynamicLinker(
+ compiler, for_machine, comp_class.LINKER_PREFIX, override,
+ version=search_version(e))
+ else:
+ __failed_to_detect_linker(compiler, check_args, o, e)
+ return linker
diff -Nru meson-0.53.2/mesonbuild/linkers/__init__.py meson-0.61.2/mesonbuild/linkers/__init__.py
--- meson-0.53.2/mesonbuild/linkers/__init__.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/linkers/__init__.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,128 @@
+# Copyright 2012-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 .detect import (
+ defaults,
+ guess_win_linker,
+ guess_nix_linker,
+)
+from .linkers import (
+ RSPFileSyntax,
+
+ StaticLinker,
+ VisualStudioLikeLinker,
+ VisualStudioLinker,
+ IntelVisualStudioLinker,
+ ArLinker,
+ ArmarLinker,
+ DLinker,
+ CcrxLinker,
+ Xc16Linker,
+ CompCertLinker,
+ C2000Linker,
+ AIXArLinker,
+ PGIStaticLinker,
+ NvidiaHPC_StaticLinker,
+
+ DynamicLinker,
+ PosixDynamicLinkerMixin,
+ GnuLikeDynamicLinkerMixin,
+ AppleDynamicLinker,
+ GnuDynamicLinker,
+ GnuGoldDynamicLinker,
+ GnuBFDDynamicLinker,
+ LLVMDynamicLinker,
+ WASMDynamicLinker,
+ CcrxDynamicLinker,
+ Xc16DynamicLinker,
+ CompCertDynamicLinker,
+ C2000DynamicLinker,
+ ArmDynamicLinker,
+ ArmClangDynamicLinker,
+ QualcommLLVMDynamicLinker,
+ PGIDynamicLinker,
+ NvidiaHPC_DynamicLinker,
+ NAGDynamicLinker,
+
+ VisualStudioLikeLinkerMixin,
+ MSVCDynamicLinker,
+ ClangClDynamicLinker,
+ XilinkDynamicLinker,
+ SolarisDynamicLinker,
+ AIXDynamicLinker,
+ OptlinkDynamicLinker,
+ CudaLinker,
+
+ prepare_rpaths,
+ order_rpaths,
+ evaluate_rpath,
+)
+
+__all__ = [
+ # detect.py
+ 'defaults',
+ 'guess_win_linker',
+ 'guess_nix_linker',
+
+ # linkers.py
+ 'RSPFileSyntax',
+
+ 'StaticLinker',
+ 'VisualStudioLikeLinker',
+ 'VisualStudioLinker',
+ 'IntelVisualStudioLinker',
+ 'ArLinker',
+ 'ArmarLinker',
+ 'DLinker',
+ 'CcrxLinker',
+ 'Xc16Linker',
+ 'CompCertLinker',
+ 'C2000Linker',
+ 'AIXArLinker',
+ 'PGIStaticLinker',
+ 'NvidiaHPC_StaticLinker',
+
+ 'DynamicLinker',
+ 'PosixDynamicLinkerMixin',
+ 'GnuLikeDynamicLinkerMixin',
+ 'AppleDynamicLinker',
+ 'GnuDynamicLinker',
+ 'GnuGoldDynamicLinker',
+ 'GnuBFDDynamicLinker',
+ 'LLVMDynamicLinker',
+ 'WASMDynamicLinker',
+ 'CcrxDynamicLinker',
+ 'Xc16DynamicLinker',
+ 'CompCertDynamicLinker',
+ 'C2000DynamicLinker',
+ 'ArmDynamicLinker',
+ 'ArmClangDynamicLinker',
+ 'QualcommLLVMDynamicLinker',
+ 'PGIDynamicLinker',
+ 'NvidiaHPC_DynamicLinker',
+ 'NAGDynamicLinker',
+
+ 'VisualStudioLikeLinkerMixin',
+ 'MSVCDynamicLinker',
+ 'ClangClDynamicLinker',
+ 'XilinkDynamicLinker',
+ 'SolarisDynamicLinker',
+ 'AIXDynamicLinker',
+ 'OptlinkDynamicLinker',
+ 'CudaLinker',
+
+ 'prepare_rpaths',
+ 'order_rpaths',
+ 'evaluate_rpath',
+]
diff -Nru meson-0.53.2/mesonbuild/linkers/linkers.py meson-0.61.2/mesonbuild/linkers/linkers.py
--- meson-0.53.2/mesonbuild/linkers/linkers.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/linkers/linkers.py 2022-01-02 20:12:32.000000000 +0000
@@ -0,0 +1,1467 @@
+# Copyright 2012-2017 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.
+
+import abc
+import enum
+import os
+import typing as T
+
+from .. import mesonlib
+from ..mesonlib import EnvironmentException, MesonException
+from ..arglist import CompilerArgs
+
+if T.TYPE_CHECKING:
+ from ..coredata import KeyedOptionDictType
+ from ..environment import Environment
+ from ..mesonlib import MachineChoice
+
+
+@enum.unique
+class RSPFileSyntax(enum.Enum):
+
+ """Which RSP file syntax the compiler supports."""
+
+ MSVC = enum.auto()
+ GCC = enum.auto()
+
+
+class StaticLinker:
+
+ id: str
+
+ def __init__(self, exelist: T.List[str]):
+ self.exelist = exelist
+
+ def compiler_args(self, args: T.Optional[T.Iterable[str]] = None) -> CompilerArgs:
+ return CompilerArgs(self, args)
+
+ def can_linker_accept_rsp(self) -> bool:
+ """
+ Determines whether the linker can accept arguments using the @rsp syntax.
+ """
+ return mesonlib.is_windows()
+
+ def get_base_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ """Like compilers.get_base_link_args, but for the static linker."""
+ return []
+
+ def get_exelist(self) -> T.List[str]:
+ return self.exelist.copy()
+
+ def get_std_link_args(self, is_thin: bool) -> T.List[str]:
+ return []
+
+ def get_buildtype_linker_args(self, buildtype: str) -> T.List[str]:
+ return []
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return[]
+
+ def get_coverage_link_args(self) -> T.List[str]:
+ return []
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ return ([], set())
+
+ def thread_link_flags(self, env: 'Environment') -> T.List[str]:
+ return []
+
+ def openmp_flags(self) -> T.List[str]:
+ return []
+
+ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ return []
+
+ @classmethod
+ def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
+ return args[:]
+
+ @classmethod
+ def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]:
+ return args[:]
+
+ def get_link_debugfile_name(self, targetfile: str) -> str:
+ return None
+
+ def get_link_debugfile_args(self, targetfile: str) -> T.List[str]:
+ # Static libraries do not have PDB files
+ return []
+
+ def get_always_args(self) -> T.List[str]:
+ return []
+
+ def get_linker_always_args(self) -> T.List[str]:
+ return []
+
+ def rsp_file_syntax(self) -> RSPFileSyntax:
+ """The format of the RSP file that this compiler supports.
+
+ If `self.can_linker_accept_rsp()` returns True, then this needs to
+ be implemented
+ """
+ assert not self.can_linker_accept_rsp(), f'{self.id} linker accepts RSP, but doesn\' provide a supported format, this is a bug'
+ raise EnvironmentException(f'{self.id} does not implement rsp format, this shouldn\'t be called')
+
+
+class VisualStudioLikeLinker:
+ always_args = ['/NOLOGO']
+
+ def __init__(self, machine: str):
+ self.machine = machine
+
+ def get_always_args(self) -> T.List[str]:
+ return self.always_args.copy()
+
+ def get_linker_always_args(self) -> T.List[str]:
+ return self.always_args.copy()
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ args = [] # type: T.List[str]
+ if self.machine:
+ args += ['/MACHINE:' + self.machine]
+ args += ['/OUT:' + target]
+ return args
+
+ @classmethod
+ def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
+ from ..compilers import VisualStudioCCompiler
+ return VisualStudioCCompiler.unix_args_to_native(args)
+
+ @classmethod
+ def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]:
+ from ..compilers import VisualStudioCCompiler
+ return VisualStudioCCompiler.native_args_to_unix(args)
+
+ def rsp_file_syntax(self) -> RSPFileSyntax:
+ return RSPFileSyntax.MSVC
+
+
+class VisualStudioLinker(VisualStudioLikeLinker, StaticLinker):
+
+ """Microsoft's lib static linker."""
+
+ def __init__(self, exelist: T.List[str], machine: str):
+ StaticLinker.__init__(self, exelist)
+ VisualStudioLikeLinker.__init__(self, machine)
+
+
+class IntelVisualStudioLinker(VisualStudioLikeLinker, StaticLinker):
+
+ """Intel's xilib static linker."""
+
+ def __init__(self, exelist: T.List[str], machine: str):
+ StaticLinker.__init__(self, exelist)
+ VisualStudioLikeLinker.__init__(self, machine)
+
+
+class ArLikeLinker(StaticLinker):
+ # POSIX requires supporting the dash, GNU permits omitting it
+ std_args = ['-csr']
+
+ def can_linker_accept_rsp(self) -> bool:
+ # armar / AIX can't accept arguments using the @rsp syntax
+ # in fact, only the 'ar' id can
+ return False
+
+ def get_std_link_args(self, is_thin: bool) -> T.List[str]:
+ return self.std_args
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [target]
+
+ def rsp_file_syntax(self) -> RSPFileSyntax:
+ return RSPFileSyntax.GCC
+
+
+class ArLinker(ArLikeLinker):
+ id = 'ar'
+
+ def __init__(self, exelist: T.List[str]):
+ super().__init__(exelist)
+ stdo = mesonlib.Popen_safe(self.exelist + ['-h'])[1]
+ # Enable deterministic builds if they are available.
+ stdargs = 'csr'
+ thinargs = ''
+ if '[D]' in stdo:
+ stdargs += 'D'
+ if '[T]' in stdo:
+ thinargs = 'T'
+ self.std_args = [stdargs]
+ self.std_thin_args = [stdargs + thinargs]
+ self.can_rsp = '@<' in stdo
+
+ def can_linker_accept_rsp(self) -> bool:
+ return self.can_rsp
+
+ def get_std_link_args(self, is_thin: bool) -> T.List[str]:
+ # FIXME: osx ld rejects this: "file built for unknown-unsupported file format"
+ if is_thin and not mesonlib.is_osx():
+ return self.std_thin_args
+ else:
+ return self.std_args
+
+
+class ArmarLinker(ArLikeLinker):
+ id = 'armar'
+
+
+class DLinker(StaticLinker):
+ def __init__(self, exelist: T.List[str], arch: str, *, rsp_syntax: RSPFileSyntax = RSPFileSyntax.GCC):
+ super().__init__(exelist)
+ self.id = exelist[0]
+ self.arch = arch
+ self.__rsp_syntax = rsp_syntax
+
+ def get_std_link_args(self, is_thin: bool) -> T.List[str]:
+ return ['-lib']
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return ['-of=' + target]
+
+ def get_linker_always_args(self) -> T.List[str]:
+ if mesonlib.is_windows():
+ if self.arch == 'x86_64':
+ return ['-m64']
+ elif self.arch == 'x86_mscoff' and self.id == 'dmd':
+ return ['-m32mscoff']
+ return ['-m32']
+ return []
+
+ def rsp_file_syntax(self) -> RSPFileSyntax:
+ return self.__rsp_syntax
+
+
+class CcrxLinker(StaticLinker):
+
+ def __init__(self, exelist: T.List[str]):
+ super().__init__(exelist)
+ self.id = 'rlink'
+
+ def can_linker_accept_rsp(self) -> bool:
+ return False
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'-output={target}']
+
+ def get_linker_always_args(self) -> T.List[str]:
+ return ['-nologo', '-form=library']
+
+
+class Xc16Linker(StaticLinker):
+
+ def __init__(self, exelist: T.List[str]):
+ super().__init__(exelist)
+ self.id = 'xc16-ar'
+
+ def can_linker_accept_rsp(self) -> bool:
+ return False
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'{target}']
+
+ def get_linker_always_args(self) -> T.List[str]:
+ return ['rcs']
+
+class CompCertLinker(StaticLinker):
+
+ def __init__(self, exelist: T.List[str]):
+ super().__init__(exelist)
+ self.id = 'ccomp'
+
+ def can_linker_accept_rsp(self) -> bool:
+ return False
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'-o{target}']
+
+
+class C2000Linker(StaticLinker):
+
+ def __init__(self, exelist: T.List[str]):
+ super().__init__(exelist)
+ self.id = 'ar2000'
+
+ def can_linker_accept_rsp(self) -> bool:
+ return False
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [f'{target}']
+
+ def get_linker_always_args(self) -> T.List[str]:
+ return ['-r']
+
+
+class AIXArLinker(ArLikeLinker):
+ id = 'aixar'
+ std_args = ['-csr', '-Xany']
+
+
+def prepare_rpaths(raw_rpaths: T.Tuple[str, ...], build_dir: str, from_dir: str) -> T.List[str]:
+ # The rpaths we write must be relative if they point to the build dir,
+ # because otherwise they have different length depending on the build
+ # directory. This breaks reproducible builds.
+ internal_format_rpaths = [evaluate_rpath(p, build_dir, from_dir) for p in raw_rpaths]
+ ordered_rpaths = order_rpaths(internal_format_rpaths)
+ return ordered_rpaths
+
+
+def order_rpaths(rpath_list: T.List[str]) -> T.List[str]:
+ # We want rpaths that point inside our build dir to always override
+ # those pointing to other places in the file system. This is so built
+ # binaries prefer our libraries to the ones that may lie somewhere
+ # in the file system, such as /lib/x86_64-linux-gnu.
+ #
+ # The correct thing to do here would be C++'s std::stable_partition.
+ # Python standard library does not have it, so replicate it with
+ # sort, which is guaranteed to be stable.
+ return sorted(rpath_list, key=os.path.isabs)
+
+
+def evaluate_rpath(p: str, build_dir: str, from_dir: str) -> str:
+ if p == from_dir:
+ return '' # relpath errors out in this case
+ elif os.path.isabs(p):
+ return p # These can be outside of build dir.
+ else:
+ return os.path.relpath(os.path.join(build_dir, p), os.path.join(build_dir, from_dir))
+
+class DynamicLinker(metaclass=abc.ABCMeta):
+
+ """Base class for dynamic linkers."""
+
+ _BUILDTYPE_ARGS = {
+ 'plain': [],
+ 'debug': [],
+ 'debugoptimized': [],
+ 'release': [],
+ 'minsize': [],
+ 'custom': [],
+ } # type: T.Dict[str, T.List[str]]
+
+ @abc.abstractproperty
+ def id(self) -> str:
+ pass
+
+ def _apply_prefix(self, arg: T.Union[str, T.List[str]]) -> T.List[str]:
+ args = [arg] if isinstance(arg, str) else arg
+ if self.prefix_arg is None:
+ return args
+ elif isinstance(self.prefix_arg, str):
+ return [self.prefix_arg + arg for arg in args]
+ ret = []
+ for arg in args:
+ ret += self.prefix_arg + [arg]
+ return ret
+
+ def __init__(self, exelist: T.List[str],
+ for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
+ always_args: T.List[str], *, version: str = 'unknown version'):
+ self.exelist = exelist
+ self.for_machine = for_machine
+ self.version = version
+ self.prefix_arg = prefix_arg
+ self.always_args = always_args
+ self.machine = None # type: T.Optional[str]
+
+ def __repr__(self) -> str:
+ return '<{}: v{} `{}`>'.format(type(self).__name__, self.version, ' '.join(self.exelist))
+
+ def get_id(self) -> str:
+ return self.id
+
+ def get_version_string(self) -> str:
+ return f'({self.id} {self.version})'
+
+ def get_exelist(self) -> T.List[str]:
+ return self.exelist.copy()
+
+ def get_accepts_rsp(self) -> bool:
+ # rsp files are only used when building on Windows because we want to
+ # avoid issues with quoting and max argument length
+ return mesonlib.is_windows()
+
+ def rsp_file_syntax(self) -> RSPFileSyntax:
+ """The format of the RSP file that this compiler supports.
+
+ If `self.can_linker_accept_rsp()` returns True, then this needs to
+ be implemented
+ """
+ return RSPFileSyntax.GCC
+
+ def get_always_args(self) -> T.List[str]:
+ return self.always_args.copy()
+
+ def get_lib_prefix(self) -> str:
+ return ''
+
+ # XXX: is use_ldflags a compiler or a linker attribute?
+
+ def get_option_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ return []
+
+ def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
+ raise EnvironmentException(f'Language {self.id} does not support has_multi_link_arguments.')
+
+ def get_debugfile_name(self, targetfile: str) -> str:
+ '''Name of debug file written out (see below)'''
+ return None
+
+ def get_debugfile_args(self, targetfile: str) -> T.List[str]:
+ """Some compilers (MSVC) write debug into a separate file.
+
+ This method takes the target object path and returns a list of
+ commands to append to the linker invocation to control where that
+ file is written.
+ """
+ return []
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return []
+
+ def get_std_shared_module_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ return self.get_std_shared_lib_args()
+
+ def get_pie_args(self) -> T.List[str]:
+ # TODO: this really needs to take a boolean and return the args to
+ # disable pie, otherwise it only acts to enable pie if pie *isn't* the
+ # default.
+ raise EnvironmentException(f'Linker {self.id} does not support position-independent executable')
+
+ def get_lto_args(self) -> T.List[str]:
+ return []
+
+ def sanitizer_args(self, value: str) -> T.List[str]:
+ return []
+
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ # We can override these in children by just overriding the
+ # _BUILDTYPE_ARGS value.
+ return self._BUILDTYPE_ARGS[buildtype]
+
+ def get_asneeded_args(self) -> T.List[str]:
+ return []
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ raise EnvironmentException(
+ f'Linker {self.id} does not support link_whole')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ raise EnvironmentException(
+ f'Linker {self.id} does not support allow undefined')
+
+ @abc.abstractmethod
+ def get_output_args(self, outname: str) -> T.List[str]:
+ pass
+
+ def get_coverage_args(self) -> T.List[str]:
+ raise EnvironmentException(f"Linker {self.id} doesn't implement coverage data generation.")
+
+ @abc.abstractmethod
+ def get_search_args(self, dirname: str) -> T.List[str]:
+ pass
+
+ def export_dynamic_args(self, env: 'Environment') -> T.List[str]:
+ return []
+
+ def import_library_args(self, implibname: str) -> T.List[str]:
+ """The name of the outputted import library.
+
+ This implementation is used only on Windows by compilers that use GNU ld
+ """
+ return []
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ return []
+
+ def no_undefined_args(self) -> T.List[str]:
+ """Arguments to error if there are any undefined symbols at link time.
+
+ This is the inverse of get_allow_undefined_args().
+
+ TODO: A future cleanup might merge this and
+ get_allow_undefined_args() into a single method taking a
+ boolean
+ """
+ return []
+
+ def fatal_warnings(self) -> T.List[str]:
+ """Arguments to make all warnings errors."""
+ return []
+
+ def headerpad_args(self) -> T.List[str]:
+ # Only used by the Apple linker
+ return []
+
+ def get_gui_app_args(self, value: bool) -> T.List[str]:
+ # Only used by VisualStudioLikeLinkers
+ return []
+
+ def get_win_subsystem_args(self, value: str) -> T.List[str]:
+ # Only used if supported by the dynamic linker and
+ # only when targeting Windows
+ return []
+
+ def bitcode_args(self) -> T.List[str]:
+ raise MesonException('This linker does not support bitcode bundles')
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ return ([], set())
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ return []
+
+
+class PosixDynamicLinkerMixin:
+
+ """Mixin class for POSIX-ish linkers.
+
+ This is obviously a pretty small subset of the linker interface, but
+ enough dynamic linkers that meson supports are POSIX-like but not
+ GNU-like that it makes sense to split this out.
+ """
+
+ def get_output_args(self, outname: str) -> T.List[str]:
+ return ['-o', outname]
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return ['-shared']
+
+ def get_search_args(self, dirname: str) -> T.List[str]:
+ return ['-L' + dirname]
+
+
+class GnuLikeDynamicLinkerMixin:
+
+ """Mixin class for dynamic linkers that provides gnu-like interface.
+
+ This acts as a base for the GNU linkers (bfd and gold), LLVM's lld, and
+ other linkers like GNU-ld.
+ """
+
+ if T.TYPE_CHECKING:
+ for_machine = MachineChoice.HOST
+ def _apply_prefix(self, arg: T.Union[str, T.List[str]]) -> T.List[str]: ...
+
+ _BUILDTYPE_ARGS = {
+ 'plain': [],
+ 'debug': [],
+ 'debugoptimized': [],
+ 'release': ['-O1'],
+ 'minsize': [],
+ 'custom': [],
+ } # type: T.Dict[str, T.List[str]]
+
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ # We can override these in children by just overriding the
+ # _BUILDTYPE_ARGS value.
+ return mesonlib.listify([self._apply_prefix(a) for a in self._BUILDTYPE_ARGS[buildtype]])
+
+ def get_pie_args(self) -> T.List[str]:
+ return ['-pie']
+
+ def get_asneeded_args(self) -> T.List[str]:
+ return self._apply_prefix('--as-needed')
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ if not args:
+ return args
+ return self._apply_prefix('--whole-archive') + args + self._apply_prefix('--no-whole-archive')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return self._apply_prefix('--allow-shlib-undefined')
+
+ def get_lto_args(self) -> T.List[str]:
+ return ['-flto']
+
+ def sanitizer_args(self, value: str) -> T.List[str]:
+ if value == 'none':
+ return []
+ return ['-fsanitize=' + value]
+
+ def get_coverage_args(self) -> T.List[str]:
+ return ['--coverage']
+
+ def export_dynamic_args(self, env: 'Environment') -> T.List[str]:
+ m = env.machines[self.for_machine]
+ if m.is_windows() or m.is_cygwin():
+ return self._apply_prefix('--export-all-symbols')
+ return self._apply_prefix('-export-dynamic')
+
+ def import_library_args(self, implibname: str) -> T.List[str]:
+ return self._apply_prefix('--out-implib=' + implibname)
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ if env.machines[self.for_machine].is_haiku():
+ return []
+ return ['-pthread']
+
+ def no_undefined_args(self) -> T.List[str]:
+ return self._apply_prefix('--no-undefined')
+
+ def fatal_warnings(self) -> T.List[str]:
+ return self._apply_prefix('--fatal-warnings')
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ m = env.machines[self.for_machine]
+ if m.is_windows() or m.is_cygwin():
+ # For PE/COFF the soname argument has no effect
+ return []
+ sostr = '' if soversion is None else '.' + soversion
+ return self._apply_prefix(f'-soname,{prefix}{shlib_name}.{suffix}{sostr}')
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ m = env.machines[self.for_machine]
+ if m.is_windows() or m.is_cygwin():
+ return ([], set())
+ if not rpath_paths and not install_rpath and not build_rpath:
+ return ([], set())
+ args = []
+ origin_placeholder = '$ORIGIN'
+ processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
+ # Need to deduplicate rpaths, as macOS's install_name_tool
+ # is *very* allergic to duplicate -delete_rpath arguments
+ # when calling depfixer on installation.
+ all_paths = mesonlib.OrderedSet([os.path.join(origin_placeholder, p) for p in processed_rpaths])
+ rpath_dirs_to_remove = set()
+ for p in all_paths:
+ rpath_dirs_to_remove.add(p.encode('utf8'))
+ # Build_rpath is used as-is (it is usually absolute).
+ if build_rpath != '':
+ all_paths.add(build_rpath)
+ for p in build_rpath.split(':'):
+ rpath_dirs_to_remove.add(p.encode('utf8'))
+
+ # TODO: should this actually be "for (dragonfly|open)bsd"?
+ if mesonlib.is_dragonflybsd() or mesonlib.is_openbsd():
+ # This argument instructs the compiler to record the value of
+ # ORIGIN in the .dynamic section of the elf. On Linux this is done
+ # by default, but is not on dragonfly/openbsd for some reason. Without this
+ # $ORIGIN in the runtime path will be undefined and any binaries
+ # linked against local libraries will fail to resolve them.
+ args.extend(self._apply_prefix('-z,origin'))
+
+ # In order to avoid relinking for RPATH removal, the binary needs to contain just
+ # enough space in the ELF header to hold the final installation RPATH.
+ paths = ':'.join(all_paths)
+ if len(paths) < len(install_rpath):
+ padding = 'X' * (len(install_rpath) - len(paths))
+ if not paths:
+ paths = padding
+ else:
+ paths = paths + ':' + padding
+ args.extend(self._apply_prefix('-rpath,' + paths))
+
+ # TODO: should this actually be "for solaris/sunos"?
+ if mesonlib.is_sunos():
+ return (args, rpath_dirs_to_remove)
+
+ # Rpaths to use while linking must be absolute. These are not
+ # written to the binary. Needed only with GNU ld:
+ # https://sourceware.org/bugzilla/show_bug.cgi?id=16936
+ # Not needed on Windows or other platforms that don't use RPATH
+ # https://github.com/mesonbuild/meson/issues/1897
+ #
+ # In addition, this linker option tends to be quite long and some
+ # compilers have trouble dealing with it. That's why we will include
+ # one option per folder, like this:
+ #
+ # -Wl,-rpath-link,/path/to/folder1 -Wl,-rpath,/path/to/folder2 ...
+ #
+ # ...instead of just one single looooong option, like this:
+ #
+ # -Wl,-rpath-link,/path/to/folder1:/path/to/folder2:...
+ for p in rpath_paths:
+ args.extend(self._apply_prefix('-rpath-link,' + os.path.join(build_dir, p)))
+
+ return (args, rpath_dirs_to_remove)
+
+ def get_win_subsystem_args(self, value: str) -> T.List[str]:
+ if 'windows' in value:
+ args = ['--subsystem,windows']
+ elif 'console' in value:
+ args = ['--subsystem,console']
+ else:
+ raise MesonException(f'Only "windows" and "console" are supported for win_subsystem with MinGW, not "{value}".')
+ if ',' in value:
+ args[-1] = args[-1] + ':' + value.split(',')[1]
+
+ return self._apply_prefix(args)
+
+
+class AppleDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Apple's ld implementation."""
+
+ id = 'ld64'
+
+ def get_asneeded_args(self) -> T.List[str]:
+ return self._apply_prefix('-dead_strip_dylibs')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return self._apply_prefix('-undefined,dynamic_lookup')
+
+ def get_std_shared_module_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
+ return ['-bundle'] + self._apply_prefix('-undefined,dynamic_lookup')
+
+ def get_pie_args(self) -> T.List[str]:
+ return []
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ result = [] # type: T.List[str]
+ for a in args:
+ result.extend(self._apply_prefix('-force_load'))
+ result.append(a)
+ return result
+
+ def get_coverage_args(self) -> T.List[str]:
+ return ['--coverage']
+
+ def sanitizer_args(self, value: str) -> T.List[str]:
+ if value == 'none':
+ return []
+ return ['-fsanitize=' + value]
+
+ def no_undefined_args(self) -> T.List[str]:
+ return self._apply_prefix('-undefined,error')
+
+ def headerpad_args(self) -> T.List[str]:
+ return self._apply_prefix('-headerpad_max_install_names')
+
+ def bitcode_args(self) -> T.List[str]:
+ return self._apply_prefix('-bitcode_bundle')
+
+ def fatal_warnings(self) -> T.List[str]:
+ return self._apply_prefix('-fatal_warnings')
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ install_name = ['@rpath/', prefix, shlib_name]
+ if soversion is not None:
+ install_name.append('.' + soversion)
+ install_name.append('.dylib')
+ args = ['-install_name', ''.join(install_name)]
+ if darwin_versions:
+ args.extend(['-compatibility_version', darwin_versions[0],
+ '-current_version', darwin_versions[1]])
+ return args
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ if not rpath_paths and not install_rpath and not build_rpath:
+ return ([], set())
+ args = []
+ # @loader_path is the equivalent of $ORIGIN on macOS
+ # https://stackoverflow.com/q/26280738
+ origin_placeholder = '@loader_path'
+ processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
+ all_paths = mesonlib.OrderedSet([os.path.join(origin_placeholder, p) for p in processed_rpaths])
+ if build_rpath != '':
+ all_paths.add(build_rpath)
+ for rp in all_paths:
+ args.extend(self._apply_prefix('-rpath,' + rp))
+
+ return (args, set())
+
+
+class GnuDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Representation of GNU ld.bfd and ld.gold."""
+
+ def get_accepts_rsp(self) -> bool:
+ return True
+
+
+class GnuGoldDynamicLinker(GnuDynamicLinker):
+
+ id = 'ld.gold'
+
+
+class GnuBFDDynamicLinker(GnuDynamicLinker):
+
+ id = 'ld.bfd'
+
+
+class LLVMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Representation of LLVM's ld.lld linker.
+
+ This is only the gnu-like linker, not the apple like or link.exe like
+ linkers.
+ """
+
+ id = 'ld.lld'
+
+ def __init__(self, exelist: T.List[str],
+ for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
+ always_args: T.List[str], *, version: str = 'unknown version'):
+ super().__init__(exelist, for_machine, prefix_arg, always_args, version=version)
+
+ # Some targets don't seem to support this argument (windows, wasm, ...)
+ _, _, e = mesonlib.Popen_safe(self.exelist + self._apply_prefix('--allow-shlib-undefined'))
+ self.has_allow_shlib_undefined = 'unknown argument: --allow-shlib-undefined' not in e
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ if self.has_allow_shlib_undefined:
+ return self._apply_prefix('--allow-shlib-undefined')
+ return []
+
+
+class WASMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Emscripten's wasm-ld."""
+
+ id = 'ld.wasm'
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=0']
+
+ def no_undefined_args(self) -> T.List[str]:
+ return ['-s', 'ERROR_ON_UNDEFINED_SYMBOLS=1']
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ raise MesonException(f'{self.id} does not support shared libraries.')
+
+ def get_asneeded_args(self) -> T.List[str]:
+ return []
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ return ([], set())
+
+
+class CcrxDynamicLinker(DynamicLinker):
+
+ """Linker for Renesis CCrx compiler."""
+
+ id = 'rlink'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice,
+ *, version: str = 'unknown version'):
+ super().__init__(['rlink.exe'], for_machine, '', [],
+ version=version)
+
+ def get_accepts_rsp(self) -> bool:
+ return False
+
+ def get_lib_prefix(self) -> str:
+ return '-lib='
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return []
+
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ return [f'-output={outputname}']
+
+ def get_search_args(self, dirname: str) -> 'T.NoReturn':
+ raise OSError('rlink.exe does not have a search dir argument')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ return []
+
+
+class Xc16DynamicLinker(DynamicLinker):
+
+ """Linker for Microchip XC16 compiler."""
+
+ id = 'xc16-gcc'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice,
+ *, version: str = 'unknown version'):
+ super().__init__(['xc16-gcc'], for_machine, '', [],
+ version=version)
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ if not args:
+ return args
+ return self._apply_prefix('--start-group') + args + self._apply_prefix('--end-group')
+
+ def get_accepts_rsp(self) -> bool:
+ return False
+
+ def get_lib_prefix(self) -> str:
+ return ''
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return []
+
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ return [f'-o{outputname}']
+
+ def get_search_args(self, dirname: str) -> 'T.NoReturn':
+ raise OSError('xc16-gcc does not have a search dir argument')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ return []
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ return ([], set())
+
+class CompCertDynamicLinker(DynamicLinker):
+
+ """Linker for CompCert C compiler."""
+
+ id = 'ccomp'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice,
+ *, version: str = 'unknown version'):
+ super().__init__(['ccomp'], for_machine, '', [],
+ version=version)
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ if not args:
+ return args
+ return self._apply_prefix('-Wl,--whole-archive') + args + self._apply_prefix('-Wl,--no-whole-archive')
+
+ def get_accepts_rsp(self) -> bool:
+ return False
+
+ def get_lib_prefix(self) -> str:
+ return ''
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return []
+
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ return [f'-o{outputname}']
+
+ def get_search_args(self, dirname: str) -> T.List[str]:
+ return [f'-L{dirname}']
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ raise MesonException(f'{self.id} does not support shared libraries.')
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ return ([], set())
+
+class C2000DynamicLinker(DynamicLinker):
+
+ """Linker for Texas Instruments C2000 compiler."""
+
+ id = 'cl2000'
+
+ def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+ *, version: str = 'unknown version'):
+ super().__init__(exelist or ['cl2000.exe'], for_machine, '', [],
+ version=version)
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ if not args:
+ return args
+ return self._apply_prefix('--start-group') + args + self._apply_prefix('--end-group')
+
+ def get_accepts_rsp(self) -> bool:
+ return False
+
+ def get_lib_prefix(self) -> str:
+ return '-l='
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return []
+
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ return ['-z', f'--output_file={outputname}']
+
+ def get_search_args(self, dirname: str) -> 'T.NoReturn':
+ raise OSError('cl2000.exe does not have a search dir argument')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_always_args(self) -> T.List[str]:
+ return []
+
+
+class ArmDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Linker for the ARM compiler."""
+
+ id = 'armlink'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice,
+ *, version: str = 'unknown version'):
+ super().__init__(['armlink'], for_machine, '', [],
+ version=version)
+
+ def get_accepts_rsp(self) -> bool:
+ return False
+
+ def get_std_shared_lib_args(self) -> 'T.NoReturn':
+ raise MesonException('The Arm Linkers do not support shared libraries')
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+
+class ArmClangDynamicLinker(ArmDynamicLinker):
+
+ """Linker used with ARM's clang fork.
+
+ The interface is similar enough to the old ARM ld that it inherits and
+ extends a few things as needed.
+ """
+
+ def export_dynamic_args(self, env: 'Environment') -> T.List[str]:
+ return ['--export_dynamic']
+
+ def import_library_args(self, implibname: str) -> T.List[str]:
+ return ['--symdefs=' + implibname]
+
+class QualcommLLVMDynamicLinker(LLVMDynamicLinker):
+
+ """ARM Linker from Snapdragon LLVM ARM Compiler."""
+
+ id = 'ld.qcld'
+
+
+class NAGDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
+
+ """NAG Fortran linker, ld via gcc indirection.
+
+ Using nagfor -Wl,foo passes option foo to a backend gcc invocation.
+ (This linking gathers the correct objects needed from the nagfor runtime
+ system.)
+ To pass gcc -Wl,foo options (i.e., to ld) one must apply indirection
+ again: nagfor -Wl,-Wl,,foo
+ """
+
+ id = 'nag'
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ if not rpath_paths and not install_rpath and not build_rpath:
+ return ([], set())
+ args = []
+ origin_placeholder = '$ORIGIN'
+ processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
+ all_paths = mesonlib.OrderedSet([os.path.join(origin_placeholder, p) for p in processed_rpaths])
+ if build_rpath != '':
+ all_paths.add(build_rpath)
+ for rp in all_paths:
+ args.extend(self._apply_prefix('-Wl,-Wl,,-rpath,,' + rp))
+
+ return (args, set())
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ from ..compilers import NAGFortranCompiler
+ return NAGFortranCompiler.get_nagfor_quiet(self.version) + ['-Wl,-shared']
+
+
+class PGIDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
+
+ """PGI linker."""
+
+ id = 'pgi'
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ return []
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ # PGI -shared is Linux only.
+ if mesonlib.is_windows():
+ return ['-Bdynamic', '-Mmakedll']
+ elif mesonlib.is_linux():
+ return ['-shared']
+ return []
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ if not env.machines[self.for_machine].is_windows():
+ return (['-R' + os.path.join(build_dir, p) for p in rpath_paths], set())
+ return ([], set())
+
+NvidiaHPC_DynamicLinker = PGIDynamicLinker
+
+
+class PGIStaticLinker(StaticLinker):
+ def __init__(self, exelist: T.List[str]):
+ super().__init__(exelist)
+ self.id = 'ar'
+ self.std_args = ['-r']
+
+ def get_std_link_args(self, is_thin: bool) -> T.List[str]:
+ return self.std_args
+
+ def get_output_args(self, target: str) -> T.List[str]:
+ return [target]
+
+NvidiaHPC_StaticLinker = PGIStaticLinker
+
+
+class VisualStudioLikeLinkerMixin:
+
+ """Mixin class for for dynamic linkers that act like Microsoft's link.exe."""
+
+ if T.TYPE_CHECKING:
+ for_machine = MachineChoice.HOST
+ def _apply_prefix(self, arg: T.Union[str, T.List[str]]) -> T.List[str]: ...
+
+ _BUILDTYPE_ARGS = {
+ 'plain': [],
+ 'debug': [],
+ 'debugoptimized': [],
+ # The otherwise implicit REF and ICF linker optimisations are disabled by
+ # /DEBUG. REF implies ICF.
+ 'release': ['/OPT:REF'],
+ 'minsize': ['/INCREMENTAL:NO', '/OPT:REF'],
+ 'custom': [],
+ } # type: T.Dict[str, T.List[str]]
+
+ def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+ prefix_arg: T.Union[str, T.List[str]], always_args: T.List[str], *,
+ version: str = 'unknown version', direct: bool = True, machine: str = 'x86'):
+ # There's no way I can find to make mypy understand what's going on here
+ super().__init__(exelist, for_machine, prefix_arg, always_args, version=version) # type: ignore
+ self.machine = machine
+ self.direct = direct
+
+ def get_buildtype_args(self, buildtype: str) -> T.List[str]:
+ return mesonlib.listify([self._apply_prefix(a) for a in self._BUILDTYPE_ARGS[buildtype]])
+
+ def invoked_by_compiler(self) -> bool:
+ return not self.direct
+
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ return self._apply_prefix(['/MACHINE:' + self.machine, '/OUT:' + outputname])
+
+ def get_always_args(self) -> T.List[str]:
+ parent = super().get_always_args() # type: ignore
+ return self._apply_prefix('/nologo') + T.cast(T.List[str], parent)
+
+ def get_search_args(self, dirname: str) -> T.List[str]:
+ return self._apply_prefix('/LIBPATH:' + dirname)
+
+ def get_std_shared_lib_args(self) -> T.List[str]:
+ return self._apply_prefix('/DLL')
+
+ def get_debugfile_name(self, targetfile: str) -> str:
+ basename = targetfile.rsplit('.', maxsplit=1)[0]
+ return basename + '.pdb'
+
+ def get_debugfile_args(self, targetfile: str) -> T.List[str]:
+ return self._apply_prefix(['/DEBUG', '/PDB:' + self.get_debugfile_name(targetfile)])
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ # Only since VS2015
+ args = mesonlib.listify(args)
+ l = [] # T.List[str]
+ for a in args:
+ l.extend(self._apply_prefix('/WHOLEARCHIVE:' + a))
+ return l
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ return []
+
+ def import_library_args(self, implibname: str) -> T.List[str]:
+ """The command to generate the import library."""
+ return self._apply_prefix(['/IMPLIB:' + implibname])
+
+ def rsp_file_syntax(self) -> RSPFileSyntax:
+ return RSPFileSyntax.MSVC
+
+
+class MSVCDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
+
+ """Microsoft's Link.exe."""
+
+ id = 'link'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
+ exelist: T.Optional[T.List[str]] = None,
+ prefix: T.Union[str, T.List[str]] = '',
+ machine: str = 'x86', version: str = 'unknown version',
+ direct: bool = True):
+ super().__init__(exelist or ['link.exe'], for_machine,
+ prefix, always_args, machine=machine, version=version, direct=direct)
+
+ def get_always_args(self) -> T.List[str]:
+ return self._apply_prefix(['/nologo', '/release']) + super().get_always_args()
+
+ def get_gui_app_args(self, value: bool) -> T.List[str]:
+ return self.get_win_subsystem_args("windows" if value else "console")
+
+ def get_win_subsystem_args(self, value: str) -> T.List[str]:
+ return self._apply_prefix([f'/SUBSYSTEM:{value.upper()}'])
+
+
+class ClangClDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
+
+ """Clang's lld-link.exe."""
+
+ id = 'lld-link'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
+ exelist: T.Optional[T.List[str]] = None,
+ prefix: T.Union[str, T.List[str]] = '',
+ machine: str = 'x86', version: str = 'unknown version',
+ direct: bool = True):
+ super().__init__(exelist or ['lld-link.exe'], for_machine,
+ prefix, always_args, machine=machine, version=version, direct=direct)
+
+ def get_output_args(self, outputname: str) -> T.List[str]:
+ # If we're being driven indirectly by clang just skip /MACHINE
+ # as clang's target triple will handle the machine selection
+ if self.machine is None:
+ return self._apply_prefix([f"/OUT:{outputname}"])
+
+ return super().get_output_args(outputname)
+
+ def get_gui_app_args(self, value: bool) -> T.List[str]:
+ return self.get_win_subsystem_args("windows" if value else "console")
+
+ def get_win_subsystem_args(self, value: str) -> T.List[str]:
+ return self._apply_prefix([f'/SUBSYSTEM:{value.upper()}'])
+
+
+class XilinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
+
+ """Intel's Xilink.exe."""
+
+ id = 'xilink'
+
+ def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
+ exelist: T.Optional[T.List[str]] = None,
+ prefix: T.Union[str, T.List[str]] = '',
+ machine: str = 'x86', version: str = 'unknown version',
+ direct: bool = True):
+ super().__init__(['xilink.exe'], for_machine, '', always_args, version=version)
+
+ def get_gui_app_args(self, value: bool) -> T.List[str]:
+ return self.get_win_subsystem_args("windows" if value else "console")
+
+ def get_win_subsystem_args(self, value: str) -> T.List[str]:
+ return self._apply_prefix([f'/SUBSYSTEM:{value.upper()}'])
+
+
+class SolarisDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Sys-V derived linker used on Solaris and OpenSolaris."""
+
+ id = 'ld.solaris'
+
+ def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
+ if not args:
+ return args
+ return self._apply_prefix('--whole-archive') + args + self._apply_prefix('--no-whole-archive')
+
+ def get_pie_args(self) -> T.List[str]:
+ # Available in Solaris 11.2 and later
+ pc, stdo, stde = mesonlib.Popen_safe(self.exelist + self._apply_prefix('-zhelp'))
+ for line in (stdo + stde).split('\n'):
+ if '-z type' in line:
+ if 'pie' in line:
+ return ['-z', 'type=pie']
+ break
+ return []
+
+ def get_asneeded_args(self) -> T.List[str]:
+ return self._apply_prefix(['-z', 'ignore'])
+
+ def no_undefined_args(self) -> T.List[str]:
+ return ['-z', 'defs']
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return ['-z', 'nodefs']
+
+ def fatal_warnings(self) -> T.List[str]:
+ return ['-z', 'fatal-warnings']
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ if not rpath_paths and not install_rpath and not build_rpath:
+ return ([], set())
+ processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
+ all_paths = mesonlib.OrderedSet([os.path.join('$ORIGIN', p) for p in processed_rpaths])
+ rpath_dirs_to_remove = set()
+ for p in all_paths:
+ rpath_dirs_to_remove.add(p.encode('utf8'))
+ if build_rpath != '':
+ all_paths.add(build_rpath)
+ for p in build_rpath.split(':'):
+ rpath_dirs_to_remove.add(p.encode('utf8'))
+
+ # In order to avoid relinking for RPATH removal, the binary needs to contain just
+ # enough space in the ELF header to hold the final installation RPATH.
+ paths = ':'.join(all_paths)
+ if len(paths) < len(install_rpath):
+ padding = 'X' * (len(install_rpath) - len(paths))
+ if not paths:
+ paths = padding
+ else:
+ paths = paths + ':' + padding
+ return (self._apply_prefix(f'-rpath,{paths}'), rpath_dirs_to_remove)
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ sostr = '' if soversion is None else '.' + soversion
+ return self._apply_prefix(f'-soname,{prefix}{shlib_name}.{suffix}{sostr}')
+
+
+class AIXDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
+
+ """Sys-V derived linker used on AIX"""
+
+ id = 'ld.aix'
+
+ def get_always_args(self) -> T.List[str]:
+ return self._apply_prefix(['-bnoipath', '-bbigtoc']) + super().get_always_args()
+
+ def no_undefined_args(self) -> T.List[str]:
+ return self._apply_prefix(['-bernotok'])
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return self._apply_prefix(['-berok'])
+
+ def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
+ rpath_paths: T.Tuple[str, ...], build_rpath: str,
+ install_rpath: str) -> T.Tuple[T.List[str], T.Set[bytes]]:
+ all_paths = mesonlib.OrderedSet() # type: mesonlib.OrderedSet[str]
+ # install_rpath first, followed by other paths, and the system path last
+ if install_rpath != '':
+ all_paths.add(install_rpath)
+ if build_rpath != '':
+ all_paths.add(build_rpath)
+ for p in rpath_paths:
+ all_paths.add(os.path.join(build_dir, p))
+ # We should consider allowing the $LIBPATH environment variable
+ # to override sys_path.
+ sys_path = env.get_compiler_system_dirs(self.for_machine)
+ if len(sys_path) == 0:
+ # get_compiler_system_dirs doesn't support our compiler.
+ # Use the default system library path
+ all_paths.update(['/usr/lib', '/lib'])
+ else:
+ # Include the compiler's default library paths, but filter out paths that don't exist
+ for p in sys_path:
+ if os.path.isdir(p):
+ all_paths.add(p)
+ return (self._apply_prefix('-blibpath:' + ':'.join(all_paths)), set())
+
+ def thread_flags(self, env: 'Environment') -> T.List[str]:
+ return ['-pthread']
+
+
+class OptlinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
+
+ """Digital Mars dynamic linker for windows."""
+
+ id = 'optlink'
+
+ def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+ *, version: str = 'unknown version'):
+ # Use optlink instead of link so we don't interfer with other link.exe
+ # implementations.
+ super().__init__(exelist, for_machine, '', [], version=version)
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_debugfile_args(self, targetfile: str) -> T.List[str]:
+ # Optlink does not generate pdb files.
+ return []
+
+ def get_always_args(self) -> T.List[str]:
+ return []
+
+
+class CudaLinker(PosixDynamicLinkerMixin, DynamicLinker):
+ """Cuda linker (nvlink)"""
+
+ id = 'nvlink'
+
+ @staticmethod
+ def parse_version() -> str:
+ version_cmd = ['nvlink', '--version']
+ try:
+ _, out, _ = mesonlib.Popen_safe(version_cmd)
+ except OSError:
+ return 'unknown version'
+ # Output example:
+ # nvlink: NVIDIA (R) Cuda linker
+ # Copyright (c) 2005-2018 NVIDIA Corporation
+ # Built on Sun_Sep_30_21:09:22_CDT_2018
+ # Cuda compilation tools, release 10.0, V10.0.166
+ # we need the most verbose version output. Luckily starting with V
+ return out.strip().split('V')[-1]
+
+ def get_accepts_rsp(self) -> bool:
+ # nvcc does not support response files
+ return False
+
+ def get_lib_prefix(self) -> str:
+ # nvcc doesn't recognize Meson's default .a extension for static libraries on
+ # Windows and passes it to cl as an object file, resulting in 'warning D9024 :
+ # unrecognized source file type 'xxx.a', object file assumed'.
+ #
+ # nvcc's --library= option doesn't help: it takes the library name without the
+ # extension and assumes that the extension on Windows is .lib; prefixing the
+ # library with -Xlinker= seems to work.
+ #
+ # On Linux, we have to use rely on -Xlinker= too, since nvcc/nvlink chokes on
+ # versioned shared libraries:
+ #
+ # nvcc fatal : Don't know what to do with 'subprojects/foo/libbar.so.0.1.2'
+ #
+ from ..compilers import CudaCompiler
+ return CudaCompiler.LINKER_PREFIX
+
+ def fatal_warnings(self) -> T.List[str]:
+ return ['--warning-as-error']
+
+ def get_allow_undefined_args(self) -> T.List[str]:
+ return []
+
+ def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
+ suffix: str, soversion: str, darwin_versions: T.Tuple[str, str]) -> T.List[str]:
+ return []
diff -Nru meson-0.53.2/mesonbuild/linkers.py meson-0.61.2/mesonbuild/linkers.py
--- meson-0.53.2/mesonbuild/linkers.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/linkers.py 1970-01-01 00:00:00.000000000 +0000
@@ -1,1006 +0,0 @@
-# Copyright 2012-2017 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.
-
-import abc
-import os
-import typing as T
-
-from . import mesonlib
-
-if T.TYPE_CHECKING:
- from .coredata import OptionDictType
- from .environment import Environment
-
-
-class StaticLinker:
-
- def __init__(self, exelist: T.List[str]):
- self.exelist = exelist
-
- def can_linker_accept_rsp(self) -> bool:
- """
- Determines whether the linker can accept arguments using the @rsp syntax.
- """
- return mesonlib.is_windows()
-
- def get_base_link_args(self, options: 'OptionDictType') -> T.List[str]:
- """Like compilers.get_base_link_args, but for the static linker."""
- return []
-
- def get_exelist(self) -> T.List[str]:
- return self.exelist.copy()
-
- def get_std_link_args(self) -> T.List[str]:
- return []
-
- def get_buildtype_linker_args(self, buildtype: str) -> T.List[str]:
- return []
-
- def get_output_args(self, target: str) -> T.List[str]:
- return[]
-
- def get_coverage_link_args(self) -> T.List[str]:
- return []
-
- def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
- return []
-
- def thread_link_flags(self, env: 'Environment') -> T.List[str]:
- return []
-
- def openmp_flags(self) -> T.List[str]:
- return []
-
- def get_option_link_args(self, options: 'OptionDictType') -> T.List[str]:
- return []
-
- @classmethod
- def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
- return args[:]
-
- @classmethod
- def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]:
- return args[:]
-
- def get_link_debugfile_args(self, targetfile: str) -> T.List[str]:
- # Static libraries do not have PDB files
- return []
-
- def get_always_args(self) -> T.List[str]:
- return []
-
- def get_linker_always_args(self) -> T.List[str]:
- return []
-
-
-class VisualStudioLikeLinker:
- always_args = ['/NOLOGO']
-
- def __init__(self, machine: str):
- self.machine = machine
-
- def get_always_args(self) -> T.List[str]:
- return self.always_args.copy()
-
- def get_linker_always_args(self) -> T.List[str]:
- return self.always_args.copy()
-
- def get_output_args(self, target: str) -> T.List[str]:
- args = [] # type: T.List[str]
- if self.machine:
- args += ['/MACHINE:' + self.machine]
- args += ['/OUT:' + target]
- return args
-
- @classmethod
- def unix_args_to_native(cls, args: T.List[str]) -> T.List[str]:
- from .compilers import VisualStudioCCompiler
- return VisualStudioCCompiler.unix_args_to_native(args)
-
- @classmethod
- def native_args_to_unix(cls, args: T.List[str]) -> T.List[str]:
- from .compilers import VisualStudioCCompiler
- return VisualStudioCCompiler.native_args_to_unix(args)
-
-
-class VisualStudioLinker(VisualStudioLikeLinker, StaticLinker):
-
- """Microsoft's lib static linker."""
-
- def __init__(self, exelist: T.List[str], machine: str):
- StaticLinker.__init__(self, exelist)
- VisualStudioLikeLinker.__init__(self, machine)
-
-
-class IntelVisualStudioLinker(VisualStudioLikeLinker, StaticLinker):
-
- """Intel's xilib static linker."""
-
- def __init__(self, exelist: T.List[str], machine: str):
- StaticLinker.__init__(self, exelist)
- VisualStudioLikeLinker.__init__(self, machine)
-
-
-class ArLinker(StaticLinker):
-
- def __init__(self, exelist: T.List[str]):
- super().__init__(exelist)
- self.id = 'ar'
- pc, stdo = mesonlib.Popen_safe(self.exelist + ['-h'])[0:2]
- # Enable deterministic builds if they are available.
- if '[D]' in stdo:
- self.std_args = ['csrD']
- else:
- self.std_args = ['csr']
-
- def get_std_link_args(self) -> T.List[str]:
- return self.std_args
-
- def get_output_args(self, target: str) -> T.List[str]:
- return [target]
-
-
-class ArmarLinker(ArLinker): # lgtm [py/missing-call-to-init]
-
- def __init__(self, exelist: T.List[str]):
- StaticLinker.__init__(self, exelist)
- self.id = 'armar'
- self.std_args = ['-csr']
-
- def can_linker_accept_rsp(self) -> bool:
- # armar can't accept arguments using the @rsp syntax
- return False
-
-
-class DLinker(StaticLinker):
- def __init__(self, exelist: T.List[str], arch: str):
- super().__init__(exelist)
- self.id = exelist[0]
- self.arch = arch
-
- def get_std_link_args(self) -> T.List[str]:
- return ['-lib']
-
- def get_output_args(self, target: str) -> T.List[str]:
- return ['-of=' + target]
-
- def get_linker_always_args(self) -> T.List[str]:
- if mesonlib.is_windows():
- if self.arch == 'x86_64':
- return ['-m64']
- elif self.arch == 'x86_mscoff' and self.id == 'dmd':
- return ['-m32mscoff']
- return ['-m32']
- return []
-
-
-class CcrxLinker(StaticLinker):
-
- def __init__(self, exelist: T.List[str]):
- super().__init__(exelist)
- self.id = 'rlink'
-
- def can_linker_accept_rsp(self) -> bool:
- return False
-
- def get_output_args(self, target: str) -> T.List[str]:
- return ['-output=%s' % target]
-
- def get_linker_always_args(self) -> T.List[str]:
- return ['-nologo', '-form=library']
-
-
-def prepare_rpaths(raw_rpaths: str, build_dir: str, from_dir: str) -> T.List[str]:
- # The rpaths we write must be relative if they point to the build dir,
- # because otherwise they have different length depending on the build
- # directory. This breaks reproducible builds.
- internal_format_rpaths = [evaluate_rpath(p, build_dir, from_dir) for p in raw_rpaths]
- ordered_rpaths = order_rpaths(internal_format_rpaths)
- return ordered_rpaths
-
-
-def order_rpaths(rpath_list: T.List[str]) -> T.List[str]:
- # We want rpaths that point inside our build dir to always override
- # those pointing to other places in the file system. This is so built
- # binaries prefer our libraries to the ones that may lie somewhere
- # in the file system, such as /lib/x86_64-linux-gnu.
- #
- # The correct thing to do here would be C++'s std::stable_partition.
- # Python standard library does not have it, so replicate it with
- # sort, which is guaranteed to be stable.
- return sorted(rpath_list, key=os.path.isabs)
-
-
-def evaluate_rpath(p: str, build_dir: str, from_dir: str) -> str:
- if p == from_dir:
- return '' # relpath errors out in this case
- elif os.path.isabs(p):
- return p # These can be outside of build dir.
- else:
- return os.path.relpath(os.path.join(build_dir, p), os.path.join(build_dir, from_dir))
-
-
-class DynamicLinker(metaclass=abc.ABCMeta):
-
- """Base class for dynamic linkers."""
-
- _BUILDTYPE_ARGS = {
- 'plain': [],
- 'debug': [],
- 'debugoptimized': [],
- 'release': [],
- 'minsize': [],
- 'custom': [],
- } # type: T.Dict[str, T.List[str]]
-
- def _apply_prefix(self, arg: T.Union[str, T.List[str]]) -> T.List[str]:
- args = [arg] if isinstance(arg, str) else arg
- if self.prefix_arg is None:
- return args
- elif isinstance(self.prefix_arg, str):
- return [self.prefix_arg + arg for arg in args]
- ret = []
- for arg in args:
- ret += self.prefix_arg + [arg]
- return ret
-
- def __init__(self, id_: str, exelist: T.List[str],
- for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
- always_args: T.List[str], *, version: str = 'unknown version'):
- self.exelist = exelist
- self.for_machine = for_machine
- self.version = version
- self.id = id_
- self.prefix_arg = prefix_arg
- self.always_args = always_args
-
- def __repr__(self) -> str:
- return '<{}: v{} `{}`>'.format(type(self).__name__, self.version, ' '.join(self.exelist))
-
- def get_id(self) -> str:
- return self.id
-
- def get_version_string(self) -> str:
- return '({} {})'.format(self.id, self.version)
-
- def get_exelist(self) -> T.List[str]:
- return self.exelist.copy()
-
- def get_accepts_rsp(self) -> bool:
- # rsp files are only used when building on Windows because we want to
- # avoid issues with quoting and max argument length
- return mesonlib.is_windows()
-
- def get_always_args(self) -> T.List[str]:
- return self.always_args.copy()
-
- def get_lib_prefix(self) -> str:
- return ''
-
- # XXX: is use_ldflags a compiler or a linker attribute?
-
- def get_args_from_envvars(self) -> T.List[str]:
- flags = os.environ.get('LDFLAGS')
- if not flags:
- return []
- return mesonlib.split_args(flags)
-
- def get_option_args(self, options: 'OptionDictType') -> T.List[str]:
- return []
-
- def has_multi_arguments(self, args: T.List[str], env: 'Environment') -> T.Tuple[bool, bool]:
- m = 'Language {} does not support has_multi_link_arguments.'
- raise mesonlib.EnvironmentException(m.format(self.id))
-
- def get_debugfile_args(self, targetfile: str) -> T.List[str]:
- """Some compilers (MSVC) write debug into a separate file.
-
- This method takes the target object path and returns a list of
- commands to append to the linker invocation to control where that
- file is written.
- """
- return []
-
- def get_std_shared_lib_args(self) -> T.List[str]:
- return []
-
- def get_std_shared_module_args(self, options: 'OptionDictType') -> T.List[str]:
- return self.get_std_shared_lib_args()
-
- def get_pie_args(self) -> T.List[str]:
- # TODO: this really needs to take a boolean and return the args to
- # disable pie, otherwise it only acts to enable pie if pie *isn't* the
- # default.
- m = 'Linker {} does not support position-independent executable'
- raise mesonlib.EnvironmentException(m.format(self.id))
-
- def get_lto_args(self) -> T.List[str]:
- return []
-
- def sanitizer_args(self, value: str) -> T.List[str]:
- return []
-
- def get_buildtype_args(self, buildtype: str) -> T.List[str]:
- # We can override these in children by just overriding the
- # _BUILDTYPE_ARGS value.
- return self._BUILDTYPE_ARGS[buildtype]
-
- def get_asneeded_args(self) -> T.List[str]:
- return []
-
- def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
- raise mesonlib.EnvironmentException(
- 'Linker {} does not support link_whole'.format(self.id))
-
- def get_allow_undefined_args(self) -> T.List[str]:
- raise mesonlib.EnvironmentException(
- 'Linker {} does not support allow undefined'.format(self.id))
-
- @abc.abstractmethod
- def get_output_args(self, outname: str) -> T.List[str]:
- pass
-
- def get_coverage_args(self) -> T.List[str]:
- m = "Linker {} doesn't implement coverage data generation.".format(self.id)
- raise mesonlib.EnvironmentException(m)
-
- @abc.abstractmethod
- def get_search_args(self, dirname: str) -> T.List[str]:
- pass
-
- def export_dynamic_args(self, env: 'Environment') -> T.List[str]:
- return []
-
- def import_library_args(self, implibname: str) -> T.List[str]:
- """The name of the outputted import library.
-
- This implementation is used only on Windows by compilers that use GNU ld
- """
- return []
-
- def thread_flags(self, env: 'Environment') -> T.List[str]:
- return []
-
- def no_undefined_args(self) -> T.List[str]:
- """Arguments to error if there are any undefined symbols at link time.
-
- This is the inverse of get_allow_undefined_args().
-
- TODO: A future cleanup might merge this and
- get_allow_undefined_args() into a single method taking a
- boolean
- """
- return []
-
- def fatal_warnings(self) -> T.List[str]:
- """Arguments to make all warnings errors."""
- return []
-
- def bitcode_args(self) -> T.List[str]:
- raise mesonlib.MesonException('This linker does not support bitcode bundles')
-
- def get_debug_crt_args(self) -> T.List[str]:
- return []
-
- def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
- return []
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- return []
-
-
-class PosixDynamicLinkerMixin:
-
- """Mixin class for POSIX-ish linkers.
-
- This is obviously a pretty small subset of the linker interface, but
- enough dynamic linkers that meson supports are POSIX-like but not
- GNU-like that it makes sense to split this out.
- """
-
- def get_output_args(self, outname: str) -> T.List[str]:
- return ['-o', outname]
-
- def get_std_shared_lib_args(self) -> T.List[str]:
- return ['-shared']
-
- def get_search_args(self, dirname: str) -> T.List[str]:
- return ['-L' + dirname]
-
-
-class GnuLikeDynamicLinkerMixin:
-
- """Mixin class for dynamic linkers that provides gnu-like interface.
-
- This acts as a base for the GNU linkers (bfd and gold), LLVM's lld, and
- other linkers like GNU-ld.
- """
-
- _BUILDTYPE_ARGS = {
- 'plain': [],
- 'debug': [],
- 'debugoptimized': [],
- 'release': ['-O1'],
- 'minsize': [],
- 'custom': [],
- } # type: T.Dict[str, T.List[str]]
-
- def get_buildtype_args(self, buildtype: str) -> T.List[str]:
- # We can override these in children by just overriding the
- # _BUILDTYPE_ARGS value.
- return mesonlib.listify([self._apply_prefix(a) for a in self._BUILDTYPE_ARGS[buildtype]])
-
- def get_pie_args(self) -> T.List[str]:
- return ['-pie']
-
- def get_asneeded_args(self) -> T.List[str]:
- return self._apply_prefix('--as-needed')
-
- def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
- if not args:
- return args
- return self._apply_prefix('--whole-archive') + args + self._apply_prefix('--no-whole-archive')
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return self._apply_prefix('--allow-shlib-undefined')
-
- def get_lto_args(self) -> T.List[str]:
- return ['-flto']
-
- def sanitizer_args(self, value: str) -> T.List[str]:
- if value == 'none':
- return []
- return ['-fsanitize=' + value]
-
- def get_coverage_args(self) -> T.List[str]:
- return ['--coverage']
-
- def export_dynamic_args(self, env: 'Environment') -> T.List[str]:
- m = env.machines[self.for_machine]
- if m.is_windows() or m.is_cygwin():
- return self._apply_prefix('--export-all-symbols')
- return self._apply_prefix('-export-dynamic')
-
- def import_library_args(self, implibname: str) -> T.List[str]:
- return self._apply_prefix('--out-implib=' + implibname)
-
- def thread_flags(self, env: 'Environment') -> T.List[str]:
- if env.machines[self.for_machine].is_haiku():
- return []
- return ['-pthread']
-
- def no_undefined_args(self) -> T.List[str]:
- return self._apply_prefix('--no-undefined')
-
- def fatal_warnings(self) -> T.List[str]:
- return self._apply_prefix('--fatal-warnings')
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- m = env.machines[self.for_machine]
- if m.is_windows() or m.is_cygwin():
- # For PE/COFF the soname argument has no effect
- return []
- sostr = '' if soversion is None else '.' + soversion
- return self._apply_prefix('-soname,{}{}.{}{}'.format(prefix, shlib_name, suffix, sostr))
-
- def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
- m = env.machines[self.for_machine]
- if m.is_windows() or m.is_cygwin():
- return []
- if not rpath_paths and not install_rpath and not build_rpath:
- return []
- args = []
- origin_placeholder = '$ORIGIN'
- processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
- # Need to deduplicate rpaths, as macOS's install_name_tool
- # is *very* allergic to duplicate -delete_rpath arguments
- # when calling depfixer on installation.
- all_paths = mesonlib.OrderedSet([os.path.join(origin_placeholder, p) for p in processed_rpaths])
- # Build_rpath is used as-is (it is usually absolute).
- if build_rpath != '':
- all_paths.add(build_rpath)
-
- # TODO: should this actually be "for (dragonfly|open)bsd"?
- if mesonlib.is_dragonflybsd() or mesonlib.is_openbsd():
- # This argument instructs the compiler to record the value of
- # ORIGIN in the .dynamic section of the elf. On Linux this is done
- # by default, but is not on dragonfly/openbsd for some reason. Without this
- # $ORIGIN in the runtime path will be undefined and any binaries
- # linked against local libraries will fail to resolve them.
- args.extend(self._apply_prefix('-z,origin'))
-
- # In order to avoid relinking for RPATH removal, the binary needs to contain just
- # enough space in the ELF header to hold the final installation RPATH.
- paths = ':'.join(all_paths)
- if len(paths) < len(install_rpath):
- padding = 'X' * (len(install_rpath) - len(paths))
- if not paths:
- paths = padding
- else:
- paths = paths + ':' + padding
- args.extend(self._apply_prefix('-rpath,' + paths))
-
- # TODO: should this actually be "for solaris/sunos"?
- if mesonlib.is_sunos():
- return args
-
- # Rpaths to use while linking must be absolute. These are not
- # written to the binary. Needed only with GNU ld:
- # https://sourceware.org/bugzilla/show_bug.cgi?id=16936
- # Not needed on Windows or other platforms that don't use RPATH
- # https://github.com/mesonbuild/meson/issues/1897
- #
- # In addition, this linker option tends to be quite long and some
- # compilers have trouble dealing with it. That's why we will include
- # one option per folder, like this:
- #
- # -Wl,-rpath-link,/path/to/folder1 -Wl,-rpath,/path/to/folder2 ...
- #
- # ...instead of just one single looooong option, like this:
- #
- # -Wl,-rpath-link,/path/to/folder1:/path/to/folder2:...
- for p in rpath_paths:
- args.extend(self._apply_prefix('-rpath-link,' + os.path.join(build_dir, p)))
-
- return args
-
-
-class AppleDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
-
- """Apple's ld implementation."""
-
- def __init__(self, *args, **kwargs):
- super().__init__('ld64', *args, **kwargs)
-
- def get_asneeded_args(self) -> T.List[str]:
- return self._apply_prefix('-dead_strip_dylibs')
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return self._apply_prefix('-undefined,dynamic_lookup')
-
- def get_std_shared_module_args(self, options: 'OptionDictType') -> T.List[str]:
- return ['-bundle'] + self._apply_prefix('-undefined,dynamic_lookup')
-
- def get_pie_args(self) -> T.List[str]:
- return ['-pie']
-
- def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
- result = [] # type: T.List[str]
- for a in args:
- result.extend(self._apply_prefix('-force_load'))
- result.append(a)
- return result
-
- def get_coverage_args(self) -> T.List[str]:
- return ['--coverage']
-
- def sanitizer_args(self, value: str) -> T.List[str]:
- if value == 'none':
- return []
- return ['-fsanitize=' + value]
-
- def no_undefined_args(self) -> T.List[str]:
- return self._apply_prefix('-undefined,error')
-
- def get_always_args(self) -> T.List[str]:
- return self._apply_prefix('-headerpad_max_install_names') + super().get_always_args()
-
- def bitcode_args(self) -> T.List[str]:
- return self._apply_prefix('-bitcode_bundle')
-
- def fatal_warnings(self) -> T.List[str]:
- return self._apply_prefix('-fatal_warnings')
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- if is_shared_module:
- return []
- install_name = ['@rpath/', prefix, shlib_name]
- if soversion is not None:
- install_name.append('.' + soversion)
- install_name.append('.dylib')
- args = ['-install_name', ''.join(install_name)]
- if darwin_versions:
- args.extend(['-compatibility_version', darwin_versions[0],
- '-current_version', darwin_versions[1]])
- return args
-
- def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
- if not rpath_paths and not install_rpath and not build_rpath:
- return []
- # Ensure that there is enough space for install_name_tool in-place
- # editing of large RPATHs
- args = self._apply_prefix('-headerpad_max_install_names')
- # @loader_path is the equivalent of $ORIGIN on macOS
- # https://stackoverflow.com/q/26280738
- origin_placeholder = '@loader_path'
- processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
- all_paths = mesonlib.OrderedSet([os.path.join(origin_placeholder, p) for p in processed_rpaths])
- if build_rpath != '':
- all_paths.add(build_rpath)
- for rp in all_paths:
- args.extend(self._apply_prefix('-rpath,' + rp))
-
- return args
-
-
-class GnuDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
-
- """Representation of GNU ld.bfd and ld.gold."""
-
-
-class GnuGoldDynamicLinker(GnuDynamicLinker):
-
- def __init__(self, *args, **kwargs):
- super().__init__('ld.gold', *args, **kwargs)
-
-
-class GnuBFDDynamicLinker(GnuDynamicLinker):
-
- def __init__(self, *args, **kwargs):
- super().__init__('ld.bfd', *args, **kwargs)
-
-
-class LLVMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, DynamicLinker):
-
- """Representation of LLVM's ld.lld linker.
-
- This is only the gnu-like linker, not the apple like or link.exe like
- linkers.
- """
-
- def __init__(self, *args, **kwargs):
- super().__init__('ld.lld', *args, **kwargs)
-
-
-class CcrxDynamicLinker(DynamicLinker):
-
- """Linker for Renesis CCrx compiler."""
-
- def __init__(self, for_machine: mesonlib.MachineChoice,
- *, version: str = 'unknown version'):
- super().__init__('rlink', ['rlink.exe'], for_machine, '', [],
- version=version)
-
- def get_accepts_rsp(self) -> bool:
- return False
-
- def get_lib_prefix(self) -> str:
- return '-lib='
-
- def get_std_shared_lib_args(self) -> T.List[str]:
- return []
-
- def get_output_args(self, outputname: str) -> T.List[str]:
- return ['-output=%s' % outputname]
-
- def get_search_args(self, dirname: str) -> 'T.NoReturn':
- raise EnvironmentError('rlink.exe does not have a search dir argument')
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return []
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- return []
-
-
-class ArmDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
-
- """Linker for the ARM compiler."""
-
- def __init__(self, for_machine: mesonlib.MachineChoice,
- *, version: str = 'unknown version'):
- super().__init__('armlink', ['armlink'], for_machine, '', [],
- version=version)
-
- def get_accepts_rsp(self) -> bool:
- return False
-
- def get_std_shared_lib_args(self) -> 'T.NoReturn':
- raise mesonlib.MesonException('The Arm Linkers do not support shared libraries')
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return []
-
-
-class ArmClangDynamicLinker(ArmDynamicLinker):
-
- """Linker used with ARM's clang fork.
-
- The interface is similar enough to the old ARM ld that it inherits and
- extends a few things as needed.
- """
-
- def export_dynamic_args(self, env: 'Environment') -> T.List[str]:
- return ['--export_dynamic']
-
- def import_library_args(self, implibname: str) -> T.List[str]:
- return ['--symdefs=' + implibname]
-
-
-class PGIDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
-
- """PGI linker."""
-
- def __init__(self, *args, **kwargs):
- super().__init__('pgi', *args, **kwargs)
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return []
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- return []
-
- def get_std_shared_lib_args(self) -> T.List[str]:
- # PGI -shared is Linux only.
- if mesonlib.is_windows():
- return ['-Bdynamic', '-Mmakedll']
- elif mesonlib.is_linux():
- return ['-shared']
- return []
-
- def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
- if not env.machines[self.for_machine].is_windows():
- return ['-R' + os.path.join(build_dir, p) for p in rpath_paths]
- return []
-
-
-class PGIStaticLinker(StaticLinker):
- def __init__(self, exelist: T.List[str]):
- super().__init__(exelist)
- self.id = 'ar'
- self.std_args = ['-r']
-
- def get_std_link_args(self) -> T.List[str]:
- return self.std_args
-
- def get_output_args(self, target: str) -> T.List[str]:
- return [target]
-
-
-class VisualStudioLikeLinkerMixin:
-
- _BUILDTYPE_ARGS = {
- 'plain': [],
- 'debug': [],
- 'debugoptimized': [],
- # The otherwise implicit REF and ICF linker optimisations are disabled by
- # /DEBUG. REF implies ICF.
- 'release': ['/OPT:REF'],
- 'minsize': ['/INCREMENTAL:NO', '/OPT:REF'],
- 'custom': [],
- } # type: T.Dict[str, T.List[str]]
-
- def __init__(self, *args, direct: bool = True, machine: str = 'x86', **kwargs):
- super().__init__(*args, **kwargs)
- self.machine = machine
-
- def get_buildtype_args(self, buildtype: str) -> T.List[str]:
- return mesonlib.listify([self._apply_prefix(a) for a in self._BUILDTYPE_ARGS[buildtype]])
-
- def invoked_by_compiler(self) -> bool:
- return not self.direct
-
- def get_debug_crt_args(self) -> T.List[str]:
- """Arguments needed to select a debug crt for the linker.
-
- Sometimes we need to manually select the CRT (C runtime) to use with
- MSVC. One example is when trying to link with static libraries since
- MSVC won't auto-select a CRT for us in that case and will error out
- asking us to select one.
- """
- return self._apply_prefix('/MDd')
-
- def get_output_args(self, outputname: str) -> T.List[str]:
- return self._apply_prefix(['/MACHINE:' + self.machine, '/OUT:' + outputname])
-
- def get_always_args(self) -> T.List[str]:
- return self._apply_prefix('/nologo') + super().get_always_args()
-
- def get_search_args(self, dirname: str) -> T.List[str]:
- return self._apply_prefix('/LIBPATH:' + dirname)
-
- def get_std_shared_lib_args(self) -> T.List[str]:
- return self._apply_prefix('/DLL')
-
- def get_debugfile_args(self, targetfile: str) -> T.List[str]:
- pdbarr = targetfile.split('.')[:-1]
- pdbarr += ['pdb']
- return self._apply_prefix(['/DEBUG', '/PDB:' + '.'.join(pdbarr)])
-
- def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
- # Only since VS2015
- args = mesonlib.listify(args)
- l = [] # T.List[str]
- for a in args:
- l.extend(self._apply_prefix('/WHOLEARCHIVE:' + a))
- return l
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return []
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- return []
-
-
-class MSVCDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
-
- """Microsoft's Link.exe."""
-
- def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
- exelist: T.Optional[T.List[str]] = None,
- prefix: T.Union[str, T.List[str]] = '',
- machine: str = 'x86', version: str = 'unknown version',
- direct: bool = True):
- super().__init__('link', exelist or ['link.exe'], for_machine,
- prefix, always_args, machine=machine, version=version, direct=direct)
-
- def get_always_args(self) -> T.List[str]:
- return self._apply_prefix(['/nologo', '/release']) + super().get_always_args()
-
-
-class ClangClDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
-
- """Clang's lld-link.exe."""
-
- def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
- exelist: T.Optional[T.List[str]] = None,
- prefix: T.Union[str, T.List[str]] = '',
- machine: str = 'x86', version: str = 'unknown version',
- direct: bool = True):
- super().__init__('lld-link', exelist or ['lld-link.exe'], for_machine,
- prefix, always_args, machine=machine, version=version, direct=direct)
-
-
-class XilinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
-
- """Intel's Xilink.exe."""
-
- def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str],
- *, version: str = 'unknown version'):
- super().__init__('xilink', ['xilink.exe'], for_machine, '', always_args, version=version)
-
-
-class SolarisDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
-
- """Sys-V derived linker used on Solaris and OpenSolaris."""
-
- def __init__(self, *args, **kwargs):
- super().__init__('ld.solaris', *args, **kwargs)
-
- def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
- if not args:
- return args
- return self._apply_prefix('--whole-archive') + args + self._apply_prefix('--no-whole-archive')
-
- def no_undefined_args(self) -> T.List[str]:
- return ['-z', 'defs']
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return ['-z', 'nodefs']
-
- def fatal_warnings(self) -> T.List[str]:
- return ['-z', 'fatal-warnings']
-
- def build_rpath_args(self, env: 'Environment', build_dir: str, from_dir: str,
- rpath_paths: str, build_rpath: str,
- install_rpath: str) -> T.List[str]:
- if not rpath_paths and not install_rpath and not build_rpath:
- return []
- processed_rpaths = prepare_rpaths(rpath_paths, build_dir, from_dir)
- all_paths = mesonlib.OrderedSet([os.path.join('$ORIGIN', p) for p in processed_rpaths])
- if build_rpath != '':
- all_paths.add(build_rpath)
-
- # In order to avoid relinking for RPATH removal, the binary needs to contain just
- # enough space in the ELF header to hold the final installation RPATH.
- paths = ':'.join(all_paths)
- if len(paths) < len(install_rpath):
- padding = 'X' * (len(install_rpath) - len(paths))
- if not paths:
- paths = padding
- else:
- paths = paths + ':' + padding
- return self._apply_prefix('-rpath,{}'.format(paths))
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- sostr = '' if soversion is None else '.' + soversion
- return self._apply_prefix('-soname,{}{}.{}{}'.format(prefix, shlib_name, suffix, sostr))
-
-
-class OptlinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
-
- """Digital Mars dynamic linker for windows."""
-
- def __init__(self, for_machine: mesonlib.MachineChoice,
- *, version: str = 'unknown version'):
- # Use optlink instead of link so we don't interfer with other link.exe
- # implementations.
- super().__init__('optlink', ['optlink.exe'], for_machine, '', [], version=version)
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return []
-
-
-class CudaLinker(PosixDynamicLinkerMixin, DynamicLinker):
- """Cuda linker (nvlink)"""
-
- def __init__(self, *args, **kwargs):
- super().__init__('nvlink', *args, **kwargs)
-
- @staticmethod
- def parse_version():
- version_cmd = ['nvlink', '--version']
- try:
- _, out, _ = mesonlib.Popen_safe(version_cmd)
- except OSError:
- return 'unknown version'
- # Output example:
- # nvlink: NVIDIA (R) Cuda linker
- # Copyright (c) 2005-2018 NVIDIA Corporation
- # Built on Sun_Sep_30_21:09:22_CDT_2018
- # Cuda compilation tools, release 10.0, V10.0.166
- # we need the most verbose version output. Luckily starting with V
- return out.strip().split('V')[-1]
-
- def get_accepts_rsp(self) -> bool:
- # nvcc does not support response files
- return False
-
- def get_lib_prefix(self) -> str:
- if not mesonlib.is_windows():
- return ''
- # nvcc doesn't recognize Meson's default .a extension for static libraries on
- # Windows and passes it to cl as an object file, resulting in 'warning D9024 :
- # unrecognized source file type 'xxx.a', object file assumed'.
- #
- # nvcc's --library= option doesn't help: it takes the library name without the
- # extension and assumes that the extension on Windows is .lib; prefixing the
- # library with -Xlinker= seems to work.
- from .compilers import CudaCompiler
- return CudaCompiler.LINKER_PREFIX
-
- def fatal_warnings(self) -> T.List[str]:
- return ['--warning-as-error']
-
- def get_allow_undefined_args(self) -> T.List[str]:
- return []
-
- def get_soname_args(self, env: 'Environment', prefix: str, shlib_name: str,
- suffix: str, soversion: str, darwin_versions: T.Tuple[str, str],
- is_shared_module: bool) -> T.List[str]:
- return []
diff -Nru meson-0.53.2/mesonbuild/mcompile.py meson-0.61.2/mesonbuild/mcompile.py
--- meson-0.53.2/mesonbuild/mcompile.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mcompile.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,351 @@
+# Copyright 2020 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.
+
+"""Entrypoint script for backend agnostic compile."""
+
+import os
+import json
+import re
+import sys
+import shutil
+import typing as T
+from collections import defaultdict
+from pathlib import Path
+
+from . import mlog
+from . import mesonlib
+from . import coredata
+from .mesonlib import MesonException, RealPathAction, setup_vsenv
+from mesonbuild.environment import detect_ninja
+from mesonbuild.coredata import UserArrayOption
+from mesonbuild import build
+
+if T.TYPE_CHECKING:
+ import argparse
+
+def array_arg(value: str) -> T.List[str]:
+ return UserArrayOption(None, value, allow_dups=True, user_input=True).value
+
+def validate_builddir(builddir: Path) -> None:
+ if not (builddir / 'meson-private' / 'coredata.dat').is_file():
+ raise MesonException(f'Current directory is not a meson build directory: `{builddir}`.\n'
+ 'Please specify a valid build dir or change the working directory to it.\n'
+ 'It is also possible that the build directory was generated with an old\n'
+ 'meson version. Please regenerate it in this case.')
+
+def parse_introspect_data(builddir: Path) -> T.Dict[str, T.List[dict]]:
+ """
+ Converts a List of name-to-dict to a dict of name-to-dicts (since names are not unique)
+ """
+ path_to_intro = builddir / 'meson-info' / 'intro-targets.json'
+ if not path_to_intro.exists():
+ raise MesonException(f'`{path_to_intro.name}` is missing! Directory is not configured yet?')
+ with path_to_intro.open(encoding='utf-8') as f:
+ schema = json.load(f)
+
+ parsed_data = defaultdict(list) # type: T.Dict[str, T.List[dict]]
+ for target in schema:
+ parsed_data[target['name']] += [target]
+ return parsed_data
+
+class ParsedTargetName:
+ full_name = ''
+ name = ''
+ type = ''
+ path = ''
+
+ def __init__(self, target: str):
+ self.full_name = target
+ split = target.rsplit(':', 1)
+ if len(split) > 1:
+ self.type = split[1]
+ if not self._is_valid_type(self.type):
+ raise MesonException(f'Can\'t invoke target `{target}`: unknown target type: `{self.type}`')
+
+ split = split[0].rsplit('/', 1)
+ if len(split) > 1:
+ self.path = split[0]
+ self.name = split[1]
+ else:
+ self.name = split[0]
+
+ @staticmethod
+ def _is_valid_type(type: str) -> bool:
+ # Amend docs in Commands.md when editing this list
+ allowed_types = {
+ 'executable',
+ 'static_library',
+ 'shared_library',
+ 'shared_module',
+ 'custom',
+ 'run',
+ 'jar',
+ }
+ return type in allowed_types
+
+def get_target_from_intro_data(target: ParsedTargetName, builddir: Path, introspect_data: T.Dict[str, T.Any]) -> T.Dict[str, T.Any]:
+ if target.name not in introspect_data:
+ raise MesonException(f'Can\'t invoke target `{target.full_name}`: target not found')
+
+ intro_targets = introspect_data[target.name]
+ found_targets = [] # type: T.List[T.Dict[str, T.Any]]
+
+ resolved_bdir = builddir.resolve()
+
+ if not target.type and not target.path:
+ found_targets = intro_targets
+ else:
+ for intro_target in intro_targets:
+ if (intro_target['subproject'] or
+ (target.type and target.type != intro_target['type'].replace(' ', '_')) or
+ (target.path
+ and intro_target['filename'] != 'no_name'
+ and Path(target.path) != Path(intro_target['filename'][0]).relative_to(resolved_bdir).parent)):
+ continue
+ found_targets += [intro_target]
+
+ if not found_targets:
+ raise MesonException(f'Can\'t invoke target `{target.full_name}`: target not found')
+ elif len(found_targets) > 1:
+ raise MesonException(f'Can\'t invoke target `{target.full_name}`: ambiguous name. Add target type and/or path: `PATH/NAME:TYPE`')
+
+ return found_targets[0]
+
+def generate_target_names_ninja(target: ParsedTargetName, builddir: Path, introspect_data: dict) -> T.List[str]:
+ intro_target = get_target_from_intro_data(target, builddir, introspect_data)
+
+ if intro_target['type'] == 'run':
+ return [target.name]
+ else:
+ return [str(Path(out_file).relative_to(builddir.resolve())) for out_file in intro_target['filename']]
+
+def get_parsed_args_ninja(options: 'argparse.Namespace', builddir: Path) -> T.Tuple[T.List[str], T.Optional[T.Dict[str, str]]]:
+ runner = detect_ninja()
+ if runner is None:
+ raise MesonException('Cannot find ninja.')
+
+ cmd = runner
+ if not builddir.samefile('.'):
+ cmd.extend(['-C', builddir.as_posix()])
+
+ # If the value is set to < 1 then don't set anything, which let's
+ # ninja/samu decide what to do.
+ if options.jobs > 0:
+ cmd.extend(['-j', str(options.jobs)])
+ if options.load_average > 0:
+ cmd.extend(['-l', str(options.load_average)])
+
+ if options.verbose:
+ cmd.append('-v')
+
+ cmd += options.ninja_args
+
+ # operands must be processed after options/option-arguments
+ if options.targets:
+ intro_data = parse_introspect_data(builddir)
+ for t in options.targets:
+ cmd.extend(generate_target_names_ninja(ParsedTargetName(t), builddir, intro_data))
+ if options.clean:
+ cmd.append('clean')
+
+ return cmd, None
+
+def generate_target_name_vs(target: ParsedTargetName, builddir: Path, introspect_data: dict) -> str:
+ intro_target = get_target_from_intro_data(target, builddir, introspect_data)
+
+ assert intro_target['type'] != 'run', 'Should not reach here: `run` targets must be handle above'
+
+ # Normalize project name
+ # Source: https://docs.microsoft.com/en-us/visualstudio/msbuild/how-to-build-specific-targets-in-solutions-by-using-msbuild-exe
+ target_name = re.sub(r"[\%\$\@\;\.\(\)']", '_', intro_target['id']) # type: str
+ rel_path = Path(intro_target['filename'][0]).relative_to(builddir.resolve()).parent
+ if rel_path != Path('.'):
+ target_name = str(rel_path / target_name)
+ return target_name
+
+def get_parsed_args_vs(options: 'argparse.Namespace', builddir: Path) -> T.Tuple[T.List[str], T.Optional[T.Dict[str, str]]]:
+ slns = list(builddir.glob('*.sln'))
+ assert len(slns) == 1, 'More than one solution in a project?'
+ sln = slns[0]
+
+ cmd = ['msbuild']
+
+ if options.targets:
+ intro_data = parse_introspect_data(builddir)
+ has_run_target = any(map(
+ lambda t:
+ get_target_from_intro_data(ParsedTargetName(t), builddir, intro_data)['type'] == 'run',
+ options.targets
+ ))
+
+ if has_run_target:
+ # `run` target can't be used the same way as other targets on `vs` backend.
+ # They are defined as disabled projects, which can't be invoked as `.sln`
+ # target and have to be invoked directly as project instead.
+ # Issue: https://github.com/microsoft/msbuild/issues/4772
+
+ if len(options.targets) > 1:
+ raise MesonException('Only one target may be specified when `run` target type is used on this backend.')
+ intro_target = get_target_from_intro_data(ParsedTargetName(options.targets[0]), builddir, intro_data)
+ proj_dir = Path(intro_target['filename'][0]).parent
+ proj = proj_dir/'{}.vcxproj'.format(intro_target['id'])
+ cmd += [str(proj.resolve())]
+ else:
+ cmd += [str(sln.resolve())]
+ cmd.extend(['-target:{}'.format(generate_target_name_vs(ParsedTargetName(t), builddir, intro_data)) for t in options.targets])
+ else:
+ cmd += [str(sln.resolve())]
+
+ if options.clean:
+ cmd.extend(['-target:Clean'])
+
+ # In msbuild `-maxCpuCount` with no number means "detect cpus", the default is `-maxCpuCount:1`
+ if options.jobs > 0:
+ cmd.append(f'-maxCpuCount:{options.jobs}')
+ else:
+ cmd.append('-maxCpuCount')
+
+ if options.load_average:
+ mlog.warning('Msbuild does not have a load-average switch, ignoring.')
+
+ if not options.verbose:
+ cmd.append('-verbosity:minimal')
+
+ cmd += options.vs_args
+
+ # Remove platform from env if set so that msbuild does not
+ # pick x86 platform when solution platform is Win32
+ env = os.environ.copy()
+ env.pop('PLATFORM', None)
+
+ return cmd, env
+
+def get_parsed_args_xcode(options: 'argparse.Namespace', builddir: Path) -> T.Tuple[T.List[str], T.Optional[T.Dict[str, str]]]:
+ runner = 'xcodebuild'
+ if not shutil.which(runner):
+ raise MesonException('Cannot find xcodebuild, did you install XCode?')
+
+ # No argument to switch directory
+ os.chdir(str(builddir))
+
+ cmd = [runner, '-parallelizeTargets']
+
+ if options.targets:
+ for t in options.targets:
+ cmd += ['-target', t]
+
+ if options.clean:
+ if options.targets:
+ cmd += ['clean']
+ else:
+ cmd += ['-alltargets', 'clean']
+ # Otherwise xcodebuild tries to delete the builddir and fails
+ cmd += ['-UseNewBuildSystem=FALSE']
+
+ if options.jobs > 0:
+ cmd.extend(['-jobs', str(options.jobs)])
+
+ if options.load_average > 0:
+ mlog.warning('xcodebuild does not have a load-average switch, ignoring')
+
+ if options.verbose:
+ # xcodebuild is already quite verbose, and -quiet doesn't print any
+ # status messages
+ pass
+
+ cmd += options.xcode_args
+ return cmd, None
+
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
+ """Add compile specific arguments."""
+ parser.add_argument(
+ 'targets',
+ metavar='TARGET',
+ nargs='*',
+ default=None,
+ help='Targets to build. Target has the following format: [PATH_TO_TARGET/]TARGET_NAME[:TARGET_TYPE].')
+ parser.add_argument(
+ '--clean',
+ action='store_true',
+ help='Clean the build directory.'
+ )
+ parser.add_argument('-C', dest='wd', action=RealPathAction,
+ help='directory to cd into before running')
+
+ parser.add_argument(
+ '-j', '--jobs',
+ action='store',
+ default=0,
+ type=int,
+ help='The number of worker jobs to run (if supported). If the value is less than 1 the build program will guess.'
+ )
+ parser.add_argument(
+ '-l', '--load-average',
+ action='store',
+ default=0,
+ type=float,
+ help='The system load average to try to maintain (if supported).'
+ )
+ parser.add_argument(
+ '-v', '--verbose',
+ action='store_true',
+ help='Show more verbose output.'
+ )
+ parser.add_argument(
+ '--ninja-args',
+ type=array_arg,
+ default=[],
+ help='Arguments to pass to `ninja` (applied only on `ninja` backend).'
+ )
+ parser.add_argument(
+ '--vs-args',
+ type=array_arg,
+ default=[],
+ help='Arguments to pass to `msbuild` (applied only on `vs` backend).'
+ )
+ parser.add_argument(
+ '--xcode-args',
+ type=array_arg,
+ default=[],
+ help='Arguments to pass to `xcodebuild` (applied only on `xcode` backend).'
+ )
+
+def run(options: 'argparse.Namespace') -> int:
+ bdir = Path(options.wd)
+ validate_builddir(bdir)
+ if options.targets and options.clean:
+ raise MesonException('`TARGET` and `--clean` can\'t be used simultaneously')
+
+ cdata = coredata.load(options.wd)
+ b = build.load(options.wd)
+ setup_vsenv(b.need_vsenv)
+
+ cmd = [] # type: T.List[str]
+ env = None # type: T.Optional[T.Dict[str, str]]
+
+ backend = cdata.get_option(mesonlib.OptionKey('backend'))
+ assert isinstance(backend, str)
+ if backend == 'ninja':
+ cmd, env = get_parsed_args_ninja(options, bdir)
+ elif backend.startswith('vs'):
+ cmd, env = get_parsed_args_vs(options, bdir)
+ elif backend == 'xcode':
+ cmd, env = get_parsed_args_xcode(options, bdir)
+ else:
+ raise MesonException(
+ f'Backend `{backend}` is not yet supported by `compile`. Use generated project files directly instead.')
+
+ p, *_ = mesonlib.Popen_safe(cmd, stdout=sys.stdout.buffer, stderr=sys.stderr.buffer, env=env)
+
+ return p.returncode
diff -Nru meson-0.53.2/mesonbuild/mconf.py meson-0.61.2/mesonbuild/mconf.py
--- meson-0.53.2/mesonbuild/mconf.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/mconf.py 2021-11-02 19:58:13.000000000 +0000
@@ -12,18 +12,33 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import itertools
+import shutil
import os
-from . import coredata, environment, mesonlib, build, mintro, mlog
+import textwrap
+import typing as T
+import collections
+
+from . import build
+from . import coredata
+from . import environment
+from . import mesonlib
+from . import mintro
+from . import mlog
from .ast import AstIDGenerator
+from .mesonlib import MachineChoice, OptionKey
-def add_arguments(parser):
+if T.TYPE_CHECKING:
+ import argparse
+ from .coredata import UserOption
+
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
coredata.register_builtin_arguments(parser)
parser.add_argument('builddir', nargs='?', default='.')
parser.add_argument('--clearcache', action='store_true', default=False,
help='Clear cached state (e.g. found dependencies)')
-
-def make_lower_case(val):
+def make_lower_case(val: T.Any) -> T.Union[str, T.List[T.Any]]: # T.Any because of recursion...
if isinstance(val, bool):
return str(val).lower()
elif isinstance(val, list):
@@ -47,9 +62,10 @@
self.value_col = []
self.choices_col = []
self.descr_col = []
+ # XXX: is there a case where this can actually remain false?
self.has_choices = False
- self.all_subprojects = set()
- self.yielding_options = set()
+ self.all_subprojects: T.Set[str] = set()
+ self.yielding_options: T.Set[OptionKey] = set()
if os.path.isdir(os.path.join(self.build_dir, 'meson-private')):
self.build = build.load(self.build_dir)
@@ -67,11 +83,10 @@
self.coredata = intr.coredata
self.default_values_only = True
else:
- raise ConfException('Directory {} is neither a Meson build directory nor a project source directory.'.format(build_dir))
+ raise ConfException(f'Directory {build_dir} is neither a Meson build directory nor a project source directory.')
def clear_cache(self):
- self.coredata.deps.host.clear()
- self.coredata.deps.build.clear()
+ self.coredata.clear_deps_cache()
def set_options(self, options):
self.coredata.set_options(options)
@@ -86,38 +101,76 @@
# are erased when Meson is executed the next time, i.e. when
# Ninja is run.
- def print_aligned(self):
- col_widths = (max([len(i) for i in self.name_col], default=0),
- max([len(i) for i in self.value_col], default=0),
- max([len(i) for i in self.choices_col], default=0))
+ def print_aligned(self) -> None:
+ """Do the actual printing.
+
+ This prints the generated output in an aligned, pretty form. it aims
+ for a total width of 160 characters, but will use whatever the tty
+ reports it's value to be. Though this is much wider than the standard
+ 80 characters of terminals, and even than the newer 120, compressing
+ it to those lengths makes the output hard to read.
+
+ Each column will have a specific width, and will be line wrapped.
+ """
+ total_width = shutil.get_terminal_size(fallback=(160, 0))[0]
+ _col = max(total_width // 5, 20)
+ four_column = (_col, _col, _col, total_width - (3 * _col))
+ # In this case we don't have the choices field, so we can redistribute
+ # the extra 40 characters to val and desc
+ three_column = (_col, _col * 2, total_width // 2)
for line in zip(self.name_col, self.value_col, self.choices_col, self.descr_col):
+ if not any(line):
+ print('')
+ continue
+
+ # This is a header, like `Subproject foo:`,
+ # We just want to print that and get on with it
+ if line[0] and not any(line[1:]):
+ print(line[0])
+ continue
+
+ # wrap will take a long string, and create a list of strings no
+ # longer than the size given. Then that list can be zipped into, to
+ # print each line of the output, such the that columns are printed
+ # to the right width, row by row.
if self.has_choices:
- print('{0:{width[0]}} {1:{width[1]}} {2:{width[2]}} {3}'.format(*line, width=col_widths))
+ name = textwrap.wrap(line[0], four_column[0])
+ val = textwrap.wrap(line[1], four_column[1])
+ choice = textwrap.wrap(line[2], four_column[2])
+ desc = textwrap.wrap(line[3], four_column[3])
+ for l in itertools.zip_longest(name, val, choice, desc, fillvalue=''):
+ # We must use the length modifier here to get even rows, as
+ # `textwrap.wrap` will only shorten, not lengthen each item
+ print('{:{widths[0]}} {:{widths[1]}} {:{widths[2]}} {}'.format(*l, widths=four_column))
else:
- print('{0:{width[0]}} {1:{width[1]}} {3}'.format(*line, width=col_widths))
+ name = textwrap.wrap(line[0], three_column[0])
+ val = textwrap.wrap(line[1], three_column[1])
+ desc = textwrap.wrap(line[3], three_column[2])
+ for l in itertools.zip_longest(name, val, desc, fillvalue=''):
+ print('{:{widths[0]}} {:{widths[1]}} {}'.format(*l, widths=three_column))
- def split_options_per_subproject(self, options):
- result = {}
+ def split_options_per_subproject(self, options: 'coredata.KeyedOptionDictType') -> T.Dict[str, T.Dict[str, 'UserOption']]:
+ result: T.Dict[str, T.Dict[str, 'UserOption']] = {}
for k, o in options.items():
- subproject = ''
- if ':' in k:
- subproject, optname = k.split(':')
- if o.yielding and optname in options:
+ subproject = k.subproject
+ if k.subproject:
+ k = k.as_root()
+ if o.yielding and k in options:
self.yielding_options.add(k)
self.all_subprojects.add(subproject)
- result.setdefault(subproject, {})[k] = o
+ result.setdefault(subproject, {})[str(k)] = o
return result
- def _add_line(self, name, value, choices, descr):
- self.name_col.append(' ' * self.print_margin + name)
+ def _add_line(self, name: OptionKey, value, choices, descr) -> None:
+ self.name_col.append(' ' * self.print_margin + str(name))
self.value_col.append(value)
self.choices_col.append(choices)
self.descr_col.append(descr)
def add_option(self, name, descr, value, choices):
if isinstance(value, list):
- value = '[{0}]'.format(', '.join(make_lower_case(value)))
+ value = '[{}]'.format(', '.join(make_lower_case(value)))
else:
value = make_lower_case(value)
@@ -159,7 +212,7 @@
self._add_line(section + ':', '', '', '')
self.print_margin = 2
- def print_options(self, title, options):
+ def print_options(self, title: str, options: 'coredata.KeyedOptionDictType') -> None:
if not options:
return
if title:
@@ -184,49 +237,46 @@
if not self.default_values_only:
print(' Build dir ', self.build_dir)
- dir_option_names = ['bindir',
- 'datadir',
- 'includedir',
- 'infodir',
- 'libdir',
- 'libexecdir',
- 'localedir',
- 'localstatedir',
- 'mandir',
- 'prefix',
- 'sbindir',
- 'sharedstatedir',
- 'sysconfdir']
- test_option_names = ['errorlogs',
- 'stdsplit']
- core_option_names = [k for k in self.coredata.builtins if k not in dir_option_names + test_option_names]
-
- dir_options = {k: o for k, o in self.coredata.builtins.items() if k in dir_option_names}
- test_options = {k: o for k, o in self.coredata.builtins.items() if k in test_option_names}
- core_options = {k: o for k, o in self.coredata.builtins.items() if k in core_option_names}
-
- def insert_build_prefix(k):
- idx = k.find(':')
- if idx < 0:
- return 'build.' + k
- return k[:idx + 1] + 'build.' + k[idx + 1:]
-
- core_options = self.split_options_per_subproject(core_options)
- host_compiler_options = self.split_options_per_subproject(self.coredata.compiler_options.host)
- build_compiler_options = self.split_options_per_subproject({insert_build_prefix(k): o for k, o in self.coredata.compiler_options.build.items()})
- project_options = self.split_options_per_subproject(self.coredata.user_options)
+ dir_option_names = set(coredata.BUILTIN_DIR_OPTIONS)
+ test_option_names = {OptionKey('errorlogs'),
+ OptionKey('stdsplit')}
+
+ dir_options: 'coredata.KeyedOptionDictType' = {}
+ test_options: 'coredata.KeyedOptionDictType' = {}
+ core_options: 'coredata.KeyedOptionDictType' = {}
+ module_options: T.Dict[str, 'coredata.KeyedOptionDictType'] = collections.defaultdict(dict)
+ for k, v in self.coredata.options.items():
+ if k in dir_option_names:
+ dir_options[k] = v
+ elif k in test_option_names:
+ test_options[k] = v
+ elif k.module:
+ # Ignore module options if we did not use that module during
+ # configuration.
+ if self.build and k.module not in self.build.modules:
+ continue
+ module_options[k.module][k] = v
+ elif k.is_builtin():
+ core_options[k] = v
+
+ host_core_options = self.split_options_per_subproject({k: v for k, v in core_options.items() if k.machine is MachineChoice.HOST})
+ build_core_options = self.split_options_per_subproject({k: v for k, v in core_options.items() if k.machine is MachineChoice.BUILD})
+ host_compiler_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_compiler() and k.machine is MachineChoice.HOST})
+ build_compiler_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_compiler() and k.machine is MachineChoice.BUILD})
+ project_options = self.split_options_per_subproject({k: v for k, v in self.coredata.options.items() if k.is_project()})
show_build_options = self.default_values_only or self.build.environment.is_cross_build()
self.add_section('Main project options')
- self.print_options('Core options', core_options[''])
- self.print_options('', self.coredata.builtins_per_machine.host)
+ self.print_options('Core options', host_core_options[''])
if show_build_options:
- self.print_options('', {insert_build_prefix(k): o for k, o in self.coredata.builtins_per_machine.build.items()})
- self.print_options('Backend options', self.coredata.backend_options)
- self.print_options('Base options', self.coredata.base_options)
+ self.print_options('', build_core_options[''])
+ self.print_options('Backend options', {str(k): v for k, v in self.coredata.options.items() if k.is_backend()})
+ self.print_options('Base options', {str(k): v for k, v in self.coredata.options.items() if k.is_base()})
self.print_options('Compiler options', host_compiler_options.get('', {}))
if show_build_options:
self.print_options('', build_compiler_options.get('', {}))
+ for mod, mod_options in module_options.items():
+ self.print_options(f'{mod} module options', mod_options)
self.print_options('Directories', dir_options)
self.print_options('Testing options', test_options)
self.print_options('Project options', project_options.get('', {}))
@@ -234,8 +284,10 @@
if subproject == '':
continue
self.add_section('Subproject ' + subproject)
- if subproject in core_options:
- self.print_options('Core options', core_options[subproject])
+ if subproject in host_core_options:
+ self.print_options('Core options', host_core_options[subproject])
+ if subproject in build_core_options and show_build_options:
+ self.print_options('', build_core_options[subproject])
if subproject in host_compiler_options:
self.print_options('Compiler options', host_compiler_options[subproject])
if subproject in build_compiler_options and show_build_options:
@@ -249,6 +301,17 @@
print('')
print_default_values_warning()
+ self.print_nondefault_buildtype_options()
+
+ def print_nondefault_buildtype_options(self):
+ mismatching = self.coredata.get_nondefault_buildtype_args()
+ if not mismatching:
+ return
+ print("\nThe following option(s) have a different value than the build type default\n")
+ print(' current default')
+ for m in mismatching:
+ print(f'{m[0]:21}{m[1]:10}{m[2]:10}')
+
def run(options):
coredata.parse_cmd_line_options(options)
builddir = os.path.abspath(os.path.realpath(options.builddir))
@@ -260,7 +323,7 @@
return 0
save = False
- if len(options.cmd_line_options) > 0:
+ if options.cmd_line_options:
c.set_options(options.cmd_line_options)
coredata.update_cmd_line_file(builddir, options)
save = True
diff -Nru meson-0.53.2/mesonbuild/mdevenv.py meson-0.61.2/mesonbuild/mdevenv.py
--- meson-0.53.2/mesonbuild/mdevenv.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mdevenv.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,79 @@
+import os, subprocess
+import argparse
+import tempfile
+
+from pathlib import Path
+from . import build
+from .mesonlib import MesonException, RealPathAction, is_windows, setup_vsenv
+
+import typing as T
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+ parser.add_argument('-C', dest='wd', action=RealPathAction,
+ help='directory to cd into before running')
+ parser.add_argument('command', nargs=argparse.REMAINDER,
+ help='Command to run in developer environment (default: interactive shell)')
+
+def get_windows_shell() -> str:
+ mesonbuild = Path(__file__).parent
+ script = mesonbuild / 'scripts' / 'cmd_or_ps.ps1'
+ command = ['powershell.exe', '-noprofile', '-executionpolicy', 'bypass', '-file', str(script)]
+ result = subprocess.check_output(command)
+ return result.decode().strip()
+
+def get_env(b: build.Build, build_dir: str) -> T.Dict[str, str]:
+ env = os.environ.copy()
+ for i in b.devenv:
+ env = i.get_env(env)
+
+ extra_env = build.EnvironmentVariables()
+ extra_env.set('MESON_DEVENV', ['1'])
+ extra_env.set('MESON_PROJECT_NAME', [b.project_name])
+
+ meson_uninstalled = Path(build_dir) / 'meson-uninstalled'
+ if meson_uninstalled.is_dir():
+ extra_env.prepend('PKG_CONFIG_PATH', [str(meson_uninstalled)])
+
+ return extra_env.get_env(env)
+
+def run(options: argparse.Namespace) -> int:
+ buildfile = Path(options.wd) / 'meson-private' / 'build.dat'
+ if not buildfile.is_file():
+ raise MesonException(f'Directory {options.wd!r} does not seem to be a Meson build directory.')
+ b = build.load(options.wd)
+ setup_vsenv(b.need_vsenv)
+
+ devenv = get_env(b, options.wd)
+
+ args = options.command
+ if not args:
+ prompt_prefix = f'[{b.project_name}]'
+ if is_windows():
+ shell = get_windows_shell()
+ if shell == 'powershell.exe':
+ args = ['powershell.exe']
+ args += ['-NoLogo', '-NoExit']
+ prompt = f'function global:prompt {{ "{prompt_prefix} PS " + $PWD + "> "}}'
+ args += ['-Command', prompt]
+ else:
+ args = [os.environ.get("COMSPEC", r"C:\WINDOWS\system32\cmd.exe")]
+ args += ['/k', f'prompt {prompt_prefix} $P$G']
+ else:
+ args = [os.environ.get("SHELL", os.path.realpath("/bin/sh"))]
+ if "bash" in args[0] and not os.environ.get("MESON_DISABLE_PS1_OVERRIDE"):
+ tmprc = tempfile.NamedTemporaryFile(mode='w')
+ bashrc = os.path.expanduser('~/.bashrc')
+ if os.path.exists(bashrc):
+ tmprc.write(f'. {bashrc}\n')
+ tmprc.write(f'export PS1="{prompt_prefix} $PS1"')
+ tmprc.flush()
+ # Let the GC remove the tmp file
+ args.append("--rcfile")
+ args.append(tmprc.name)
+
+ try:
+ return subprocess.call(args, close_fds=False,
+ env=devenv,
+ cwd=options.wd)
+ except subprocess.CalledProcessError as e:
+ return e.returncode
diff -Nru meson-0.53.2/mesonbuild/mdist.py meson-0.61.2/mesonbuild/mdist.py
--- meson-0.53.2/mesonbuild/mdist.py 2020-01-23 22:29:05.000000000 +0000
+++ meson-0.61.2/mesonbuild/mdist.py 2021-11-02 19:58:07.000000000 +0000
@@ -18,116 +18,161 @@
import sys
import shutil
import subprocess
+import tarfile
+import tempfile
import hashlib
import json
from glob import glob
from pathlib import Path
from mesonbuild.environment import detect_ninja
-from mesonbuild.mesonlib import windows_proof_rmtree, MesonException
+from mesonbuild.mesonlib import (MesonException, RealPathAction, quiet_git,
+ windows_proof_rmtree, setup_vsenv)
from mesonbuild.wrap import wrap
from mesonbuild import mlog, build
+from .scripts.meson_exe import run_exe
archive_choices = ['gztar', 'xztar', 'zip']
+
archive_extension = {'gztar': '.tar.gz',
'xztar': '.tar.xz',
'zip': '.zip'}
def add_arguments(parser):
- parser.add_argument('-C', default='.', dest='wd',
+ parser.add_argument('-C', dest='wd', action=RealPathAction,
help='directory to cd into before running')
parser.add_argument('--formats', default='xztar',
- help='Comma separated list of archive types to create.')
+ help='Comma separated list of archive types to create. Supports xztar (default), gztar, and zip.')
parser.add_argument('--include-subprojects', action='store_true',
help='Include source code of subprojects that have been used for the build.')
+ parser.add_argument('--no-tests', action='store_true',
+ help='Do not build and test generated packages.')
def create_hash(fname):
hashname = fname + '.sha256sum'
m = hashlib.sha256()
m.update(open(fname, 'rb').read())
- with open(hashname, 'w') as f:
- f.write('%s %s\n' % (m.hexdigest(), os.path.basename(fname)))
-
-
-def del_gitfiles(dirname):
- for f in glob(os.path.join(dirname, '.git*')):
- if os.path.isdir(f) and not os.path.islink(f):
- windows_proof_rmtree(f)
- else:
- os.unlink(f)
+ with open(hashname, 'w', encoding='utf-8') as f:
+ # A space and an asterisk because that is the format defined by GNU coreutils
+ # and accepted by busybox and the Perl shasum tool.
+ f.write('{} *{}\n'.format(m.hexdigest(), os.path.basename(fname)))
+
+
+def copy_git(src, distdir, revision='HEAD', prefix=None, subdir=None):
+ cmd = ['git', 'archive', '--format', 'tar', revision]
+ if prefix is not None:
+ cmd.insert(2, f'--prefix={prefix}/')
+ if subdir is not None:
+ cmd.extend(['--', subdir])
+ with tempfile.TemporaryFile() as f:
+ subprocess.check_call(cmd, cwd=src, stdout=f)
+ f.seek(0)
+ t = tarfile.open(fileobj=f) # [ignore encoding]
+ t.extractall(path=distdir)
-def process_submodules(dirname):
- module_file = os.path.join(dirname, '.gitmodules')
+def process_submodules(src, distdir):
+ module_file = os.path.join(src, '.gitmodules')
if not os.path.exists(module_file):
return
- subprocess.check_call(['git', 'submodule', 'update', '--init', '--recursive'], cwd=dirname)
- for line in open(module_file):
- line = line.strip()
- if '=' not in line:
- continue
- k, v = line.split('=', 1)
- k = k.strip()
- v = v.strip()
- if k != 'path':
+ cmd = ['git', 'submodule', 'status', '--cached', '--recursive']
+ modlist = subprocess.check_output(cmd, cwd=src, universal_newlines=True).splitlines()
+ for submodule in modlist:
+ status = submodule[:1]
+ sha1, rest = submodule[1:].split(' ', 1)
+ subpath = rest.rsplit(' ', 1)[0]
+
+ if status == '-':
+ mlog.warning(f'Submodule {subpath!r} is not checked out and cannot be added to the dist')
continue
- del_gitfiles(os.path.join(dirname, v))
+ elif status in {'+', 'U'}:
+ mlog.warning(f'Submodule {subpath!r} has uncommitted changes that will not be included in the dist tarball')
+
+ copy_git(os.path.join(src, subpath), distdir, revision=sha1, prefix=subpath)
-def run_dist_scripts(dist_root, dist_scripts):
- assert(os.path.isabs(dist_root))
- env = os.environ.copy()
+def run_dist_scripts(src_root, bld_root, dist_root, dist_scripts, subprojects):
+ assert os.path.isabs(dist_root)
+ env = {}
env['MESON_DIST_ROOT'] = dist_root
+ env['MESON_SOURCE_ROOT'] = src_root
+ env['MESON_BUILD_ROOT'] = bld_root
for d in dist_scripts:
- script = d['exe']
- args = d['args']
- name = ' '.join(script + args)
- print('Running custom dist script {!r}'.format(name))
+ if d.subproject and d.subproject not in subprojects:
+ continue
+ subdir = subprojects.get(d.subproject, '')
+ env['MESON_PROJECT_DIST_ROOT'] = os.path.join(dist_root, subdir)
+ env['MESON_PROJECT_SOURCE_ROOT'] = os.path.join(src_root, subdir)
+ env['MESON_PROJECT_BUILD_ROOT'] = os.path.join(bld_root, subdir)
+ name = ' '.join(d.cmd_args)
+ print(f'Running custom dist script {name!r}')
try:
- rc = subprocess.call(script + args, env=env)
+ rc = run_exe(d, env)
if rc != 0:
sys.exit('Dist script errored out')
except OSError:
- print('Failed to run dist script {!r}'.format(name))
+ print(f'Failed to run dist script {name!r}')
sys.exit(1)
+def git_root(src_root):
+ # Cannot use --show-toplevel here because git in our CI prints cygwin paths
+ # that python cannot resolve. Workaround this by taking parent of src_root.
+ prefix = quiet_git(['rev-parse', '--show-prefix'], src_root, check=True)[1].strip()
+ if not prefix:
+ return Path(src_root)
+ prefix_level = len(Path(prefix).parents)
+ return Path(src_root).parents[prefix_level - 1]
+
def is_git(src_root):
- _git = os.path.join(src_root, '.git')
- return os.path.isdir(_git) or os.path.isfile(_git)
+ '''
+ Checks if meson.build file at the root source directory is tracked by git.
+ It could be a subproject part of the parent project git repository.
+ '''
+ return quiet_git(['ls-files', '--error-unmatch', 'meson.build'], src_root)[0]
def git_have_dirty_index(src_root):
'''Check whether there are uncommitted changes in git'''
ret = subprocess.call(['git', '-C', src_root, 'diff-index', '--quiet', 'HEAD'])
return ret == 1
-def git_clone(src_root, distdir):
+def process_git_project(src_root, distdir):
if git_have_dirty_index(src_root):
mlog.warning('Repository has uncommitted changes that will not be included in the dist tarball')
if os.path.exists(distdir):
- shutil.rmtree(distdir)
- os.makedirs(distdir)
- subprocess.check_call(['git', 'clone', '--shared', src_root, distdir])
- process_submodules(distdir)
- del_gitfiles(distdir)
+ windows_proof_rmtree(distdir)
+ repo_root = git_root(src_root)
+ if repo_root.samefile(src_root):
+ os.makedirs(distdir)
+ copy_git(src_root, distdir)
+ else:
+ subdir = Path(src_root).relative_to(repo_root)
+ tmp_distdir = distdir + '-tmp'
+ if os.path.exists(tmp_distdir):
+ windows_proof_rmtree(tmp_distdir)
+ os.makedirs(tmp_distdir)
+ copy_git(repo_root, tmp_distdir, subdir=str(subdir))
+ Path(tmp_distdir, subdir).rename(distdir)
+ windows_proof_rmtree(tmp_distdir)
+ process_submodules(src_root, distdir)
def create_dist_git(dist_name, archives, src_root, bld_root, dist_sub, dist_scripts, subprojects):
distdir = os.path.join(dist_sub, dist_name)
- git_clone(src_root, distdir)
- for path in subprojects:
+ process_git_project(src_root, distdir)
+ for path in subprojects.values():
sub_src_root = os.path.join(src_root, path)
sub_distdir = os.path.join(distdir, path)
if os.path.exists(sub_distdir):
continue
if is_git(sub_src_root):
- git_clone(sub_src_root, sub_distdir)
+ process_git_project(sub_src_root, sub_distdir)
else:
shutil.copytree(sub_src_root, sub_distdir)
- run_dist_scripts(distdir, dist_scripts)
+ run_dist_scripts(src_root, bld_root, distdir, dist_scripts, subprojects)
output_names = []
for a in archives:
compressed_name = distdir + archive_extension[a]
shutil.make_archive(distdir, a, root_dir=dist_sub, base_dir=dist_name)
output_names.append(compressed_name)
- shutil.rmtree(distdir)
+ windows_proof_rmtree(distdir)
return output_names
def is_hg(src_root):
@@ -141,16 +186,25 @@
def create_dist_hg(dist_name, archives, src_root, bld_root, dist_sub, dist_scripts):
if hg_have_dirty_index(src_root):
mlog.warning('Repository has uncommitted changes that will not be included in the dist tarball')
+ if dist_scripts:
+ mlog.warning('dist scripts are not supported in Mercurial projects')
os.makedirs(dist_sub, exist_ok=True)
tarname = os.path.join(dist_sub, dist_name + '.tar')
xzname = tarname + '.xz'
gzname = tarname + '.gz'
zipname = os.path.join(dist_sub, dist_name + '.zip')
- subprocess.check_call(['hg', 'archive', '-R', src_root, '-S', '-t', 'tar', tarname])
+ # Note that -X interprets relative paths using the current working
+ # directory, not the repository root, so this must be an absolute path:
+ # https://bz.mercurial-scm.org/show_bug.cgi?id=6267
+ #
+ # .hg[a-z]* is used instead of .hg* to keep .hg_archival.txt, which may
+ # be useful to link the tarball to the Mercurial revision for either
+ # manual inspection or in case any code interprets it for a --version or
+ # similar.
+ subprocess.check_call(['hg', 'archive', '-R', src_root, '-S', '-t', 'tar',
+ '-X', src_root + '/.hg[a-z]*', tarname])
output_names = []
- if dist_scripts:
- mlog.warning('dist scripts are not supported in Mercurial projects')
if 'xztar' in archives:
import lzma
with lzma.open(xzname, 'wb') as xf, open(tarname, 'rb') as tf:
@@ -166,66 +220,71 @@
output_names.append(zipname)
return output_names
+def run_dist_steps(meson_command, unpacked_src_dir, builddir, installdir, ninja_args):
+ if subprocess.call(meson_command + ['--backend=ninja', unpacked_src_dir, builddir]) != 0:
+ print('Running Meson on distribution package failed')
+ return 1
+ if subprocess.call(ninja_args, cwd=builddir) != 0:
+ print('Compiling the distribution package failed')
+ return 1
+ if subprocess.call(ninja_args + ['test'], cwd=builddir) != 0:
+ print('Running unit tests on the distribution package failed')
+ return 1
+ myenv = os.environ.copy()
+ myenv['DESTDIR'] = installdir
+ if subprocess.call(ninja_args + ['install'], cwd=builddir, env=myenv) != 0:
+ print('Installing the distribution package failed')
+ return 1
+ return 0
def check_dist(packagename, meson_command, extra_meson_args, bld_root, privdir):
- print('Testing distribution package %s' % packagename)
+ print(f'Testing distribution package {packagename}')
unpackdir = os.path.join(privdir, 'dist-unpack')
builddir = os.path.join(privdir, 'dist-build')
installdir = os.path.join(privdir, 'dist-install')
for p in (unpackdir, builddir, installdir):
if os.path.exists(p):
- shutil.rmtree(p)
+ windows_proof_rmtree(p)
os.mkdir(p)
- ninja_bin = detect_ninja()
- try:
- shutil.unpack_archive(packagename, unpackdir)
- unpacked_files = glob(os.path.join(unpackdir, '*'))
- assert(len(unpacked_files) == 1)
- unpacked_src_dir = unpacked_files[0]
- with open(os.path.join(bld_root, 'meson-info', 'intro-buildoptions.json')) as boptions:
- meson_command += ['-D{name}={value}'.format(**o) for o in json.load(boptions)
- if o['name'] not in ['backend', 'install_umask']]
- meson_command += extra_meson_args
- if subprocess.call(meson_command + ['--backend=ninja', unpacked_src_dir, builddir]) != 0:
- print('Running Meson on distribution package failed')
- return 1
- if subprocess.call([ninja_bin], cwd=builddir) != 0:
- print('Compiling the distribution package failed')
- return 1
- if subprocess.call([ninja_bin, 'test'], cwd=builddir) != 0:
- print('Running unit tests on the distribution package failed')
- return 1
- myenv = os.environ.copy()
- myenv['DESTDIR'] = installdir
- if subprocess.call([ninja_bin, 'install'], cwd=builddir, env=myenv) != 0:
- print('Installing the distribution package failed')
- return 1
- finally:
- shutil.rmtree(unpackdir)
- shutil.rmtree(builddir)
- shutil.rmtree(installdir)
- print('Distribution package %s tested' % packagename)
- return 0
+ ninja_args = detect_ninja()
+ shutil.unpack_archive(packagename, unpackdir)
+ unpacked_files = glob(os.path.join(unpackdir, '*'))
+ assert len(unpacked_files) == 1
+ unpacked_src_dir = unpacked_files[0]
+ with open(os.path.join(bld_root, 'meson-info', 'intro-buildoptions.json'), encoding='utf-8') as boptions:
+ meson_command += ['-D{name}={value}'.format(**o) for o in json.load(boptions)
+ if o['name'] not in ['backend', 'install_umask', 'buildtype']]
+ meson_command += extra_meson_args
+
+ ret = run_dist_steps(meson_command, unpacked_src_dir, builddir, installdir, ninja_args)
+ if ret > 0:
+ print(f'Dist check build directory was {builddir}')
+ else:
+ windows_proof_rmtree(unpackdir)
+ windows_proof_rmtree(builddir)
+ windows_proof_rmtree(installdir)
+ print(f'Distribution package {packagename} tested')
+ return ret
def determine_archives_to_generate(options):
result = []
for i in options.formats.split(','):
if i not in archive_choices:
- sys.exit('Value "{}" not one of permitted values {}.'.format(i, archive_choices))
+ sys.exit(f'Value "{i}" not one of permitted values {archive_choices}.')
result.append(i)
if len(i) == 0:
sys.exit('No archive types specified.')
return result
def run(options):
- options.wd = os.path.abspath(options.wd)
buildfile = Path(options.wd) / 'meson-private' / 'build.dat'
if not buildfile.is_file():
- raise MesonException('Directory {!r} does not seem to be a Meson build directory.'.format(options.wd))
+ raise MesonException(f'Directory {options.wd!r} does not seem to be a Meson build directory.')
b = build.load(options.wd)
+ setup_vsenv(b.need_vsenv)
# This import must be load delayed, otherwise it will get the default
# value of None.
- from mesonbuild.mesonlib import meson_command
+ from mesonbuild.mesonlib import get_meson_command
src_root = b.environment.source_dir
bld_root = b.environment.build_dir
priv_dir = os.path.join(bld_root, 'meson-private')
@@ -235,13 +294,13 @@
archives = determine_archives_to_generate(options)
- subprojects = []
+ subprojects = {}
extra_meson_args = []
if options.include_subprojects:
subproject_dir = os.path.join(src_root, b.subproject_dir)
for sub in b.subprojects:
- _, directory = wrap.get_directory(subproject_dir, sub)
- subprojects.append(os.path.join(b.subproject_dir, directory))
+ directory = wrap.get_directory(subproject_dir, sub)
+ subprojects[sub] = os.path.join(b.subproject_dir, directory)
extra_meson_args.append('-Dwrap_mode=nodownload')
if is_git(src_root):
@@ -256,9 +315,12 @@
return 1
if names is None:
return 1
- # Check only one.
- rc = check_dist(names[0], meson_command, extra_meson_args, bld_root, priv_dir)
+ rc = 0
+ if not options.no_tests:
+ # Check only one.
+ rc = check_dist(names[0], get_meson_command(), extra_meson_args, bld_root, priv_dir)
if rc == 0:
for name in names:
create_hash(name)
+ print('Created', name)
return rc
diff -Nru meson-0.53.2/mesonbuild/mesondata.py meson-0.61.2/mesonbuild/mesondata.py
--- meson-0.53.2/mesonbuild/mesondata.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesondata.py 2022-01-17 10:50:45.000000000 +0000
@@ -0,0 +1,394 @@
+# Copyright 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.
+
+
+####
+#### WARNING: This is an automatically generated file! Do not edit!
+#### Generated by tools/gen_data.py
+####
+
+
+# TODO: Remember to remove this also from tools/gen_data.py
+from pathlib import Path
+import typing as T
+
+if T.TYPE_CHECKING:
+ from .environment import Environment
+
+######################
+# BEGIN Data section #
+######################
+
+file_0_data_preload_cmake = '''\
+if(MESON_PS_LOADED)
+ return()
+endif()
+
+set(MESON_PS_LOADED ON)
+
+cmake_policy(PUSH)
+cmake_policy(SET CMP0054 NEW) # https://cmake.org/cmake/help/latest/policy/CMP0054.html
+
+# Dummy macros that have a special meaning in the meson code
+macro(meson_ps_execute_delayed_calls)
+endmacro()
+
+macro(meson_ps_reload_vars)
+endmacro()
+
+macro(meson_ps_disabled_function)
+ message(WARNING "The function '${ARGV0}' is disabled in the context of CMake subprojects.\n"
+ "This should not be an issue but may lead to compilation errors.")
+endmacro()
+
+# Helper macro to inspect the current CMake state
+macro(meson_ps_inspect_vars)
+ set(MESON_PS_CMAKE_CURRENT_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+ set(MESON_PS_CMAKE_CURRENT_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+ meson_ps_execute_delayed_calls()
+endmacro()
+
+
+# Override some system functions with custom code and forward the args
+# to the original function
+macro(add_custom_command)
+ meson_ps_inspect_vars()
+ _add_custom_command(${ARGV})
+endmacro()
+
+macro(add_custom_target)
+ meson_ps_inspect_vars()
+ _add_custom_target(${ARGV})
+endmacro()
+
+macro(set_property)
+ meson_ps_inspect_vars()
+ _set_property(${ARGV})
+endmacro()
+
+function(set_source_files_properties)
+ set(FILES)
+ set(I 0)
+ set(PROPERTIES OFF)
+
+ while(I LESS ARGC)
+ if(NOT PROPERTIES)
+ if("${ARGV${I}}" STREQUAL "PROPERTIES")
+ set(PROPERTIES ON)
+ else()
+ list(APPEND FILES "${ARGV${I}}")
+ endif()
+
+ math(EXPR I "${I} + 1")
+ else()
+ set(ID_IDX ${I})
+ math(EXPR PROP_IDX "${ID_IDX} + 1")
+
+ set(ID "${ARGV${ID_IDX}}")
+ set(PROP "${ARGV${PROP_IDX}}")
+
+ set_property(SOURCE ${FILES} PROPERTY "${ID}" "${PROP}")
+ math(EXPR I "${I} + 2")
+ endif()
+ endwhile()
+endfunction()
+
+# Disable some functions that would mess up the CMake meson integration
+macro(target_precompile_headers)
+ meson_ps_disabled_function(target_precompile_headers)
+endmacro()
+
+set(MESON_PS_DELAYED_CALLS add_custom_command;add_custom_target;set_property)
+meson_ps_reload_vars()
+
+cmake_policy(POP)
+'''
+
+file_1_data_CMakeLists_txt = '''\
+# fail noisily if attempt to use this file without setting:
+# cmake_minimum_required(VERSION ${CMAKE_VERSION})
+# project(... LANGUAGES ...)
+
+cmake_policy(SET CMP0000 NEW)
+
+set(PACKAGE_FOUND FALSE)
+set(_packageName "${NAME}")
+string(TOUPPER "${_packageName}" PACKAGE_NAME)
+
+while(TRUE)
+ if ("${VERSION}" STREQUAL "")
+ find_package("${NAME}" QUIET COMPONENTS ${COMPS})
+ else()
+ find_package("${NAME}" "${VERSION}" QUIET COMPONENTS ${COMPS})
+ endif()
+
+ # ARCHS has to be set via the CMD interface
+ if(${_packageName}_FOUND OR ${PACKAGE_NAME}_FOUND OR "${ARCHS}" STREQUAL "")
+ break()
+ endif()
+
+ list(GET ARCHS 0 CMAKE_LIBRARY_ARCHITECTURE)
+ list(REMOVE_AT ARCHS 0)
+endwhile()
+
+if(${_packageName}_FOUND OR ${PACKAGE_NAME}_FOUND)
+ set(PACKAGE_FOUND TRUE)
+
+ # Check the following variables:
+ # FOO_VERSION
+ # Foo_VERSION
+ # FOO_VERSION_STRING
+ # Foo_VERSION_STRING
+ if(NOT DEFINED PACKAGE_VERSION)
+ if(DEFINED ${_packageName}_VERSION)
+ set(PACKAGE_VERSION "${${_packageName}_VERSION}")
+ elseif(DEFINED ${PACKAGE_NAME}_VERSION)
+ set(PACKAGE_VERSION "${${PACKAGE_NAME}_VERSION}")
+ elseif(DEFINED ${_packageName}_VERSION_STRING)
+ set(PACKAGE_VERSION "${${_packageName}_VERSION_STRING}")
+ elseif(DEFINED ${PACKAGE_NAME}_VERSION_STRING)
+ set(PACKAGE_VERSION "${${PACKAGE_NAME}_VERSION_STRING}")
+ endif()
+ endif()
+
+ # Check the following variables:
+ # FOO_LIBRARIES
+ # Foo_LIBRARIES
+ # FOO_LIBS
+ # Foo_LIBS
+ set(libs)
+ if(DEFINED ${_packageName}_LIBRARIES)
+ set(libs ${_packageName}_LIBRARIES)
+ elseif(DEFINED ${PACKAGE_NAME}_LIBRARIES)
+ set(libs ${PACKAGE_NAME}_LIBRARIES)
+ elseif(DEFINED ${_packageName}_LIBS)
+ set(libs ${_packageName}_LIBS)
+ elseif(DEFINED ${PACKAGE_NAME}_LIBS)
+ set(libs ${PACKAGE_NAME}_LIBS)
+ endif()
+
+ # Check the following variables:
+ # FOO_INCLUDE_DIRS
+ # Foo_INCLUDE_DIRS
+ # FOO_INCLUDES
+ # Foo_INCLUDES
+ # FOO_INCLUDE_DIR
+ # Foo_INCLUDE_DIR
+ set(includes)
+ if(DEFINED ${_packageName}_INCLUDE_DIRS)
+ set(includes ${_packageName}_INCLUDE_DIRS)
+ elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIRS)
+ set(includes ${PACKAGE_NAME}_INCLUDE_DIRS)
+ elseif(DEFINED ${_packageName}_INCLUDES)
+ set(includes ${_packageName}_INCLUDES)
+ elseif(DEFINED ${PACKAGE_NAME}_INCLUDES)
+ set(includes ${PACKAGE_NAME}_INCLUDES)
+ elseif(DEFINED ${_packageName}_INCLUDE_DIR)
+ set(includes ${_packageName}_INCLUDE_DIR)
+ elseif(DEFINED ${PACKAGE_NAME}_INCLUDE_DIR)
+ set(includes ${PACKAGE_NAME}_INCLUDE_DIR)
+ endif()
+
+ # Check the following variables:
+ # FOO_DEFINITIONS
+ # Foo_DEFINITIONS
+ set(definitions)
+ if(DEFINED ${_packageName}_DEFINITIONS)
+ set(definitions ${_packageName}_DEFINITIONS)
+ elseif(DEFINED ${PACKAGE_NAME}_DEFINITIONS)
+ set(definitions ${PACKAGE_NAME}_DEFINITIONS)
+ endif()
+
+ set(PACKAGE_INCLUDE_DIRS "${${includes}}")
+ set(PACKAGE_DEFINITIONS "${${definitions}}")
+ set(PACKAGE_LIBRARIES "${${libs}}")
+endif()
+'''
+
+file_2_data_CMakeListsLLVM_txt = '''\
+cmake_minimum_required(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION} )
+
+set(PACKAGE_FOUND FALSE)
+
+while(TRUE)
+ find_package(LLVM REQUIRED CONFIG QUIET)
+
+ # ARCHS has to be set via the CMD interface
+ if(LLVM_FOUND OR "${ARCHS}" STREQUAL "")
+ break()
+ endif()
+
+ list(GET ARCHS 0 CMAKE_LIBRARY_ARCHITECTURE)
+ list(REMOVE_AT ARCHS 0)
+endwhile()
+
+if(LLVM_FOUND)
+ set(PACKAGE_FOUND TRUE)
+
+ foreach(mod IN LISTS LLVM_MESON_MODULES)
+ # Reset variables
+ set(out_mods)
+ set(real_mods)
+
+ # Generate a lower and upper case version
+ string(TOLOWER "${mod}" mod_L)
+ string(TOUPPER "${mod}" mod_U)
+
+ # Get the mapped components
+ llvm_map_components_to_libnames(out_mods ${mod} ${mod_L} ${mod_U})
+ list(SORT out_mods)
+ list(REMOVE_DUPLICATES out_mods)
+
+ # Make sure that the modules exist
+ foreach(i IN LISTS out_mods)
+ if(TARGET ${i})
+ list(APPEND real_mods ${i})
+ endif()
+ endforeach()
+
+ # Set the output variables
+ set(MESON_LLVM_TARGETS_${mod} ${real_mods})
+ foreach(i IN LISTS real_mods)
+ set(MESON_TARGET_TO_LLVM_${i} ${mod})
+ endforeach()
+ endforeach()
+
+ # Check the following variables:
+ # LLVM_PACKAGE_VERSION
+ # LLVM_VERSION
+ # LLVM_VERSION_STRING
+ if(NOT DEFINED PACKAGE_VERSION)
+ if(DEFINED LLVM_PACKAGE_VERSION)
+ set(PACKAGE_VERSION "${LLVM_PACKAGE_VERSION}")
+ elseif(DEFINED LLVM_VERSION)
+ set(PACKAGE_VERSION "${LLVM_VERSION}")
+ elseif(DEFINED LLVM_VERSION_STRING)
+ set(PACKAGE_VERSION "${LLVM_VERSION_STRING}")
+ endif()
+ endif()
+
+ # Check the following variables:
+ # LLVM_LIBRARIES
+ # LLVM_LIBS
+ set(libs)
+ if(DEFINED LLVM_LIBRARIES)
+ set(libs LLVM_LIBRARIES)
+ elseif(DEFINED LLVM_LIBS)
+ set(libs LLVM_LIBS)
+ endif()
+
+ # Check the following variables:
+ # LLVM_INCLUDE_DIRS
+ # LLVM_INCLUDES
+ # LLVM_INCLUDE_DIR
+ set(includes)
+ if(DEFINED LLVM_INCLUDE_DIRS)
+ set(includes LLVM_INCLUDE_DIRS)
+ elseif(DEFINED LLVM_INCLUDES)
+ set(includes LLVM_INCLUDES)
+ elseif(DEFINED LLVM_INCLUDE_DIR)
+ set(includes LLVM_INCLUDE_DIR)
+ endif()
+
+ # Check the following variables:
+ # LLVM_DEFINITIONS
+ set(definitions)
+ if(DEFINED LLVM_DEFINITIONS)
+ set(definitions LLVM_DEFINITIONS)
+ endif()
+
+ set(PACKAGE_INCLUDE_DIRS "${${includes}}")
+ set(PACKAGE_DEFINITIONS "${${definitions}}")
+ set(PACKAGE_LIBRARIES "${${libs}}")
+endif()
+'''
+
+file_3_data_CMakePathInfo_txt = '''\
+cmake_minimum_required(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}.${CMAKE_PATCH_VERSION})
+
+set(TMP_PATHS_LIST)
+list(APPEND TMP_PATHS_LIST ${CMAKE_PREFIX_PATH})
+list(APPEND TMP_PATHS_LIST ${CMAKE_FRAMEWORK_PATH})
+list(APPEND TMP_PATHS_LIST ${CMAKE_APPBUNDLE_PATH})
+list(APPEND TMP_PATHS_LIST $ENV{CMAKE_PREFIX_PATH})
+list(APPEND TMP_PATHS_LIST $ENV{CMAKE_FRAMEWORK_PATH})
+list(APPEND TMP_PATHS_LIST $ENV{CMAKE_APPBUNDLE_PATH})
+list(APPEND TMP_PATHS_LIST ${CMAKE_SYSTEM_PREFIX_PATH})
+list(APPEND TMP_PATHS_LIST ${CMAKE_SYSTEM_FRAMEWORK_PATH})
+list(APPEND TMP_PATHS_LIST ${CMAKE_SYSTEM_APPBUNDLE_PATH})
+
+set(LIB_ARCH_LIST)
+if(CMAKE_LIBRARY_ARCHITECTURE_REGEX)
+ file(GLOB implicit_dirs RELATIVE /lib /lib/*-linux-gnu* )
+ foreach(dir ${implicit_dirs})
+ if("${dir}" MATCHES "${CMAKE_LIBRARY_ARCHITECTURE_REGEX}")
+ list(APPEND LIB_ARCH_LIST "${dir}")
+ endif()
+ endforeach()
+endif()
+
+# "Export" these variables:
+set(MESON_ARCH_LIST ${LIB_ARCH_LIST})
+set(MESON_PATHS_LIST ${TMP_PATHS_LIST})
+set(MESON_CMAKE_ROOT ${CMAKE_ROOT})
+set(MESON_CMAKE_SYSROOT ${CMAKE_SYSROOT})
+set(MESON_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH})
+
+message(STATUS ${TMP_PATHS_LIST})
+'''
+
+
+####################
+# END Data section #
+####################
+
+class DataFile:
+ def __init__(self, path: Path, sha256sum: str, data: str) -> None:
+ self.path = path
+ self.sha256sum = sha256sum
+ self.data = data
+
+ def write_once(self, path: Path) -> None:
+ if not path.exists():
+ path.write_text(self.data, encoding='utf-8')
+
+ def write_to_private(self, env: 'Environment') -> Path:
+ out_file = Path(env.scratch_dir) / 'data' / self.path.name
+ out_file.parent.mkdir(exist_ok=True)
+ self.write_once(out_file)
+ return out_file
+
+
+mesondata = {
+ 'cmake/data/preload.cmake': DataFile(
+ Path('cmake/data/preload.cmake'),
+ 'ce8f30159aab25b92c26c58a219a427d47838bfa0739475221d6c8993b4946e5',
+ file_0_data_preload_cmake,
+ ),
+ 'dependencies/data/CMakeLists.txt': DataFile(
+ Path('dependencies/data/CMakeLists.txt'),
+ '4dca24afa13e9311f0598a6ac29690490819bd7d82cfdaa0a2fe5eea3c0fa0d5',
+ file_1_data_CMakeLists_txt,
+ ),
+ 'dependencies/data/CMakeListsLLVM.txt': DataFile(
+ Path('dependencies/data/CMakeListsLLVM.txt'),
+ '412cec3315597041a978d018cdaca282dcd47693793540da88ae2f80d0cbd7cd',
+ file_2_data_CMakeListsLLVM_txt,
+ ),
+ 'dependencies/data/CMakePathInfo.txt': DataFile(
+ Path('dependencies/data/CMakePathInfo.txt'),
+ '90da8b443982d9c87139b7dc84228eb58cab4315764949637208f25e2bda7db2',
+ file_3_data_CMakePathInfo_txt,
+ ),
+}
diff -Nru meson-0.53.2/mesonbuild/mesonlib/__init__.py meson-0.61.2/mesonbuild/mesonlib/__init__.py
--- meson-0.53.2/mesonbuild/mesonlib/__init__.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib/__init__.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,31 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# 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.
+
+"""Helper functions and classes."""
+
+import os
+
+from .universal import *
+from .vsenv import setup_vsenv
+
+# Here we import either the posix implementations, the windows implementations,
+# or a generic no-op implementation
+if os.name == 'posix':
+ from .posix import *
+elif os.name == 'nt':
+ from .win32 import *
+else:
+ from .platform import *
diff -Nru meson-0.53.2/mesonbuild/mesonlib/platform.py meson-0.61.2/mesonbuild/mesonlib/platform.py
--- meson-0.53.2/mesonbuild/mesonlib/platform.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib/platform.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,37 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# 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.
+
+"""base classes providing no-op functionality.."""
+
+import os
+import typing as T
+
+from .. import mlog
+
+__all__ = ['BuildDirLock']
+
+# This needs to be inherited by the specific implementations to make type
+# checking happy
+class BuildDirLock:
+
+ def __init__(self, builddir: str) -> None:
+ self.lockfilename = os.path.join(builddir, 'meson-private/meson.lock')
+
+ def __enter__(self) -> None:
+ mlog.debug('Calling the no-op version of BuildDirLock')
+
+ def __exit__(self, *args: T.Any) -> None:
+ pass
diff -Nru meson-0.53.2/mesonbuild/mesonlib/posix.py meson-0.61.2/mesonbuild/mesonlib/posix.py
--- meson-0.53.2/mesonbuild/mesonlib/posix.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib/posix.py 2021-07-20 08:56:20.000000000 +0000
@@ -0,0 +1,39 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# 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.
+
+"""Posix specific implementations of mesonlib functionality."""
+
+import fcntl
+import typing as T
+
+from .universal import MesonException
+from .platform import BuildDirLock as BuildDirLockBase
+
+__all__ = ['BuildDirLock']
+
+class BuildDirLock(BuildDirLockBase):
+
+ def __enter__(self) -> None:
+ self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
+ try:
+ fcntl.flock(self.lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB)
+ except (BlockingIOError, PermissionError):
+ self.lockfile.close()
+ raise MesonException('Some other Meson process is already using this build directory. Exiting.')
+
+ def __exit__(self, *args: T.Any) -> None:
+ fcntl.flock(self.lockfile, fcntl.LOCK_UN)
+ self.lockfile.close()
diff -Nru meson-0.53.2/mesonbuild/mesonlib/universal.py meson-0.61.2/mesonbuild/mesonlib/universal.py
--- meson-0.53.2/mesonbuild/mesonlib/universal.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib/universal.py 2022-02-14 19:03:13.000000000 +0000
@@ -0,0 +1,2216 @@
+# Copyright 2012-2020 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.
+
+"""A library of random helper functionality."""
+from pathlib import Path
+import argparse
+import enum
+import sys
+import stat
+import time
+import abc
+import platform, subprocess, operator, os, shlex, shutil, re
+import collections
+from functools import lru_cache, wraps, total_ordering
+from itertools import tee, filterfalse
+from tempfile import TemporaryDirectory
+import typing as T
+import uuid
+import textwrap
+import copy
+
+from mesonbuild import mlog
+
+if T.TYPE_CHECKING:
+ from .._typing import ImmutableListProtocol
+ from ..build import ConfigurationData
+ from ..coredata import KeyedOptionDictType, UserOption
+ from ..compilers.compilers import Compiler
+
+FileOrString = T.Union['File', str]
+
+_T = T.TypeVar('_T')
+_U = T.TypeVar('_U')
+
+__all__ = [
+ 'GIT',
+ 'python_command',
+ 'project_meson_versions',
+ 'HoldableObject',
+ 'SecondLevelHolder',
+ 'File',
+ 'FileMode',
+ 'GitException',
+ 'LibType',
+ 'MachineChoice',
+ 'MesonException',
+ 'MesonBugException',
+ 'EnvironmentException',
+ 'FileOrString',
+ 'GitException',
+ 'OptionKey',
+ 'dump_conf_header',
+ 'OptionOverrideProxy',
+ 'OptionType',
+ 'OrderedSet',
+ 'PerMachine',
+ 'PerMachineDefaultable',
+ 'PerThreeMachine',
+ 'PerThreeMachineDefaultable',
+ 'ProgressBar',
+ 'RealPathAction',
+ 'TemporaryDirectoryWinProof',
+ 'Version',
+ 'check_direntry_issues',
+ 'classify_unity_sources',
+ 'current_vs_supports_modules',
+ 'darwin_get_object_archs',
+ 'default_libdir',
+ 'default_libexecdir',
+ 'default_prefix',
+ 'detect_subprojects',
+ 'detect_vcs',
+ 'do_conf_file',
+ 'do_conf_str',
+ 'do_replacement',
+ 'exe_exists',
+ 'expand_arguments',
+ 'extract_as_list',
+ 'generate_list',
+ 'get_compiler_for_source',
+ 'get_filenames_templates_dict',
+ 'get_library_dirs',
+ 'get_variable_regex',
+ 'get_wine_shortpath',
+ 'git',
+ 'has_path_sep',
+ 'is_aix',
+ 'is_android',
+ 'is_ascii_string',
+ 'is_cygwin',
+ 'is_debianlike',
+ 'is_dragonflybsd',
+ 'is_freebsd',
+ 'is_haiku',
+ 'is_hurd',
+ 'is_irix',
+ 'is_linux',
+ 'is_netbsd',
+ 'is_openbsd',
+ 'is_osx',
+ 'is_qnx',
+ 'is_sunos',
+ 'is_windows',
+ 'is_wsl',
+ 'iter_regexin_iter',
+ 'join_args',
+ 'listify',
+ 'partition',
+ 'path_is_in_root',
+ 'Popen_safe',
+ 'quiet_git',
+ 'quote_arg',
+ 'relative_to_if_possible',
+ 'relpath',
+ 'replace_if_different',
+ 'run_once',
+ 'get_meson_command',
+ 'set_meson_command',
+ 'split_args',
+ 'stringlistify',
+ 'substitute_values',
+ 'substring_is_in_list',
+ 'typeslistify',
+ 'verbose_git',
+ 'version_compare',
+ 'version_compare_condition_with_min',
+ 'version_compare_many',
+ 'search_version',
+ 'windows_proof_rm',
+ 'windows_proof_rmtree',
+]
+
+
+# TODO: this is such a hack, this really should be either in coredata or in the
+# interpreter
+# {subproject: project_meson_version}
+project_meson_versions = collections.defaultdict(str) # type: T.DefaultDict[str, str]
+
+
+from glob import glob
+
+if os.path.basename(sys.executable) == 'meson.exe':
+ # In Windows and using the MSI installed executable.
+ python_command = [sys.executable, 'runpython']
+else:
+ python_command = [sys.executable]
+_meson_command: T.Optional['ImmutableListProtocol[str]'] = None
+
+class MesonException(Exception):
+ '''Exceptions thrown by Meson'''
+
+ def __init__(self, *args: object, file: T.Optional[str] = None,
+ lineno: T.Optional[int] = None, colno: T.Optional[int] = None):
+ super().__init__(*args)
+ self.file = file
+ self.lineno = lineno
+ self.colno = colno
+
+
+class MesonBugException(MesonException):
+ '''Exceptions thrown when there is a clear Meson bug that should be reported'''
+
+ def __init__(self, msg: str, file: T.Optional[str] = None,
+ lineno: T.Optional[int] = None, colno: T.Optional[int] = None):
+ super().__init__(msg + '\n\n This is a Meson bug and should be reported!',
+ file=file, lineno=lineno, colno=colno)
+
+class EnvironmentException(MesonException):
+ '''Exceptions thrown while processing and creating the build environment'''
+
+class GitException(MesonException):
+ def __init__(self, msg: str, output: T.Optional[str] = None):
+ super().__init__(msg)
+ self.output = output.strip() if output else ''
+
+GIT = shutil.which('git')
+def git(cmd: T.List[str], workingdir: str, check: bool = False, **kwargs: T.Any) -> T.Tuple[subprocess.Popen, str, str]:
+ cmd = [GIT] + cmd
+ p, o, e = Popen_safe(cmd, cwd=workingdir, **kwargs)
+ if check and p.returncode != 0:
+ raise GitException('Git command failed: ' + str(cmd), e)
+ return p, o, e
+
+def quiet_git(cmd: T.List[str], workingdir: str, check: bool = False) -> T.Tuple[bool, str]:
+ if not GIT:
+ m = 'Git program not found.'
+ if check:
+ raise GitException(m)
+ return False, m
+ p, o, e = git(cmd, workingdir, check)
+ if p.returncode != 0:
+ return False, e
+ return True, o
+
+def verbose_git(cmd: T.List[str], workingdir: str, check: bool = False) -> bool:
+ if not GIT:
+ m = 'Git program not found.'
+ if check:
+ raise GitException(m)
+ return False
+ p, _, _ = git(cmd, workingdir, check, stdout=None, stderr=None)
+ return p.returncode == 0
+
+def set_meson_command(mainfile: str) -> None:
+ global python_command
+ global _meson_command
+ # On UNIX-like systems `meson` is a Python script
+ # On Windows `meson` and `meson.exe` are wrapper exes
+ if not mainfile.endswith('.py'):
+ _meson_command = [mainfile]
+ elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
+ # Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain
+ _meson_command = python_command + ['-m', 'mesonbuild.mesonmain']
+ else:
+ # Either run uninstalled, or full path to meson-script.py
+ _meson_command = python_command + [mainfile]
+ # We print this value for unit tests.
+ if 'MESON_COMMAND_TESTS' in os.environ:
+ mlog.log(f'meson_command is {_meson_command!r}')
+
+
+def get_meson_command() -> T.Optional['ImmutableListProtocol[str]']:
+ return _meson_command
+
+
+def is_ascii_string(astring: T.Union[str, bytes]) -> bool:
+ try:
+ if isinstance(astring, str):
+ astring.encode('ascii')
+ elif isinstance(astring, bytes):
+ astring.decode('ascii')
+ except UnicodeDecodeError:
+ return False
+ return True
+
+
+def check_direntry_issues(direntry_array: T.Union[T.List[T.Union[str, bytes]], str, bytes]) -> None:
+ import locale
+ # Warn if the locale is not UTF-8. This can cause various unfixable issues
+ # such as os.stat not being able to decode filenames with unicode in them.
+ # There is no way to reset both the preferred encoding and the filesystem
+ # encoding, so we can just warn about it.
+ e = locale.getpreferredencoding()
+ if e.upper() != 'UTF-8' and not is_windows():
+ if not isinstance(direntry_array, list):
+ direntry_array = [direntry_array]
+ for de in direntry_array:
+ if is_ascii_string(de):
+ continue
+ mlog.warning(textwrap.dedent(f'''
+ You are using {e!r} which is not a Unicode-compatible
+ locale but you are trying to access a file system entry called {de!r} which is
+ not pure ASCII. This may cause problems.
+ '''), file=sys.stderr)
+
+class HoldableObject(metaclass=abc.ABCMeta):
+ ''' Dummy base class for all objects that can be
+ held by an interpreter.baseobjects.ObjectHolder '''
+
+class SecondLevelHolder(HoldableObject, metaclass=abc.ABCMeta):
+ ''' A second level object holder. The primary purpose
+ of such objects is to hold multiple objects with one
+ default option. '''
+
+ @abc.abstractmethod
+ def get_default_object(self) -> HoldableObject: ...
+
+class FileMode:
+ # The first triad is for owner permissions, the second for group permissions,
+ # and the third for others (everyone else).
+ # For the 1st character:
+ # 'r' means can read
+ # '-' means not allowed
+ # For the 2nd character:
+ # 'w' means can write
+ # '-' means not allowed
+ # For the 3rd character:
+ # 'x' means can execute
+ # 's' means can execute and setuid/setgid is set (owner/group triads only)
+ # 'S' means cannot execute and setuid/setgid is set (owner/group triads only)
+ # 't' means can execute and sticky bit is set ("others" triads only)
+ # 'T' means cannot execute and sticky bit is set ("others" triads only)
+ # '-' means none of these are allowed
+ #
+ # The meanings of 'rwx' perms is not obvious for directories; see:
+ # https://www.hackinglinuxexposed.com/articles/20030424.html
+ #
+ # For information on this notation such as setuid/setgid/sticky bits, see:
+ # https://en.wikipedia.org/wiki/File_system_permissions#Symbolic_notation
+ symbolic_perms_regex = re.compile('[r-][w-][xsS-]' # Owner perms
+ '[r-][w-][xsS-]' # Group perms
+ '[r-][w-][xtT-]') # Others perms
+
+ def __init__(self, perms: T.Optional[str] = None, owner: T.Union[str, int, None] = None,
+ group: T.Union[str, int, None] = None):
+ self.perms_s = perms
+ self.perms = self.perms_s_to_bits(perms)
+ self.owner = owner
+ self.group = group
+
+ def __repr__(self) -> str:
+ ret = ' int:
+ '''
+ Does the opposite of stat.filemode(), converts strings of the form
+ 'rwxr-xr-x' to st_mode enums which can be passed to os.chmod()
+ '''
+ if perms_s is None:
+ # No perms specified, we will not touch the permissions
+ return -1
+ eg = 'rwxr-xr-x'
+ if not isinstance(perms_s, str):
+ raise MesonException(f'Install perms must be a string. For example, {eg!r}')
+ if len(perms_s) != 9 or not cls.symbolic_perms_regex.match(perms_s):
+ raise MesonException(f'File perms {perms_s!r} must be exactly 9 chars. For example, {eg!r}')
+ perms = 0
+ # Owner perms
+ if perms_s[0] == 'r':
+ perms |= stat.S_IRUSR
+ if perms_s[1] == 'w':
+ perms |= stat.S_IWUSR
+ if perms_s[2] == 'x':
+ perms |= stat.S_IXUSR
+ elif perms_s[2] == 'S':
+ perms |= stat.S_ISUID
+ elif perms_s[2] == 's':
+ perms |= stat.S_IXUSR
+ perms |= stat.S_ISUID
+ # Group perms
+ if perms_s[3] == 'r':
+ perms |= stat.S_IRGRP
+ if perms_s[4] == 'w':
+ perms |= stat.S_IWGRP
+ if perms_s[5] == 'x':
+ perms |= stat.S_IXGRP
+ elif perms_s[5] == 'S':
+ perms |= stat.S_ISGID
+ elif perms_s[5] == 's':
+ perms |= stat.S_IXGRP
+ perms |= stat.S_ISGID
+ # Others perms
+ if perms_s[6] == 'r':
+ perms |= stat.S_IROTH
+ if perms_s[7] == 'w':
+ perms |= stat.S_IWOTH
+ if perms_s[8] == 'x':
+ perms |= stat.S_IXOTH
+ elif perms_s[8] == 'T':
+ perms |= stat.S_ISVTX
+ elif perms_s[8] == 't':
+ perms |= stat.S_IXOTH
+ perms |= stat.S_ISVTX
+ return perms
+
+dot_C_dot_H_warning = """You are using .C or .H files in your project. This is deprecated.
+ Currently, Meson treats this as C++ code, but they
+ used to be treated as C code.
+ Note that the situation is a bit more complex if you are using the
+ Visual Studio compiler, as it treats .C files as C code, unless you add
+ the /TP compiler flag, but this is unreliable.
+ See https://github.com/mesonbuild/meson/pull/8747 for the discussions."""
+class File(HoldableObject):
+ def __init__(self, is_built: bool, subdir: str, fname: str):
+ if fname.endswith(".C") or fname.endswith(".H"):
+ mlog.warning(dot_C_dot_H_warning, once=True)
+ self.is_built = is_built
+ self.subdir = subdir
+ self.fname = fname
+ self.hash = hash((is_built, subdir, fname))
+
+ def __str__(self) -> str:
+ return self.relative_name()
+
+ def __repr__(self) -> str:
+ ret = ' 'File':
+ if not os.path.isfile(os.path.join(source_root, subdir, fname)):
+ raise MesonException(f'File {fname} does not exist.')
+ return File(False, subdir, fname)
+
+ @staticmethod
+ def from_built_file(subdir: str, fname: str) -> 'File':
+ return File(True, subdir, fname)
+
+ @staticmethod
+ def from_absolute_file(fname: str) -> 'File':
+ return File(False, '', fname)
+
+ @lru_cache(maxsize=None)
+ def rel_to_builddir(self, build_to_src: str) -> str:
+ if self.is_built:
+ return self.relative_name()
+ else:
+ return os.path.join(build_to_src, self.subdir, self.fname)
+
+ @lru_cache(maxsize=None)
+ def absolute_path(self, srcdir: str, builddir: str) -> str:
+ absdir = srcdir
+ if self.is_built:
+ absdir = builddir
+ return os.path.join(absdir, self.relative_name())
+
+ @property
+ def suffix(self) -> str:
+ return os.path.splitext(self.fname)[1][1:].lower()
+
+ def endswith(self, ending: T.Union[str, T.Tuple[str, ...]]) -> bool:
+ return self.fname.endswith(ending)
+
+ def split(self, s: str, maxsplit: int = -1) -> T.List[str]:
+ return self.fname.split(s, maxsplit=maxsplit)
+
+ def rsplit(self, s: str, maxsplit: int = -1) -> T.List[str]:
+ return self.fname.rsplit(s, maxsplit=maxsplit)
+
+ def __eq__(self, other: object) -> bool:
+ if not isinstance(other, File):
+ return NotImplemented
+ if self.hash != other.hash:
+ return False
+ return (self.fname, self.subdir, self.is_built) == (other.fname, other.subdir, other.is_built)
+
+ def __hash__(self) -> int:
+ return self.hash
+
+ @lru_cache(maxsize=None)
+ def relative_name(self) -> str:
+ return os.path.join(self.subdir, self.fname)
+
+
+def get_compiler_for_source(compilers: T.Iterable['Compiler'], src: 'FileOrString') -> 'Compiler':
+ """Given a set of compilers and a source, find the compiler for that source type."""
+ for comp in compilers:
+ if comp.can_compile(src):
+ return comp
+ raise MesonException(f'No specified compiler can handle file {src!s}')
+
+
+def classify_unity_sources(compilers: T.Iterable['Compiler'], sources: T.Sequence['FileOrString']) -> T.Dict['Compiler', T.List['FileOrString']]:
+ compsrclist: T.Dict['Compiler', T.List['FileOrString']] = {}
+ for src in sources:
+ comp = get_compiler_for_source(compilers, src)
+ if comp not in compsrclist:
+ compsrclist[comp] = [src]
+ else:
+ compsrclist[comp].append(src)
+ return compsrclist
+
+
+class MachineChoice(enum.IntEnum):
+
+ """Enum class representing one of the two abstract machine names used in
+ most places: the build, and host, machines.
+ """
+
+ BUILD = 0
+ HOST = 1
+
+ def get_lower_case_name(self) -> str:
+ return PerMachine('build', 'host')[self]
+
+ def get_prefix(self) -> str:
+ return PerMachine('build.', '')[self]
+
+
+class PerMachine(T.Generic[_T]):
+ def __init__(self, build: _T, host: _T) -> None:
+ self.build = build
+ self.host = host
+
+ def __getitem__(self, machine: MachineChoice) -> _T:
+ return {
+ MachineChoice.BUILD: self.build,
+ MachineChoice.HOST: self.host,
+ }[machine]
+
+ def __setitem__(self, machine: MachineChoice, val: _T) -> None:
+ setattr(self, machine.get_lower_case_name(), val)
+
+ def miss_defaulting(self) -> "PerMachineDefaultable[T.Optional[_T]]":
+ """Unset definition duplicated from their previous to None
+
+ This is the inverse of ''default_missing''. By removing defaulted
+ machines, we can elaborate the original and then redefault them and thus
+ avoid repeating the elaboration explicitly.
+ """
+ unfreeze = PerMachineDefaultable() # type: PerMachineDefaultable[T.Optional[_T]]
+ unfreeze.build = self.build
+ unfreeze.host = self.host
+ if unfreeze.host == unfreeze.build:
+ unfreeze.host = None
+ return unfreeze
+
+ def __repr__(self) -> str:
+ return f'PerMachine({self.build!r}, {self.host!r})'
+
+
+class PerThreeMachine(PerMachine[_T]):
+ """Like `PerMachine` but includes `target` too.
+
+ It turns out just one thing do we need track the target machine. There's no
+ need to computer the `target` field so we don't bother overriding the
+ `__getitem__`/`__setitem__` methods.
+ """
+ def __init__(self, build: _T, host: _T, target: _T) -> None:
+ super().__init__(build, host)
+ self.target = target
+
+ def miss_defaulting(self) -> "PerThreeMachineDefaultable[T.Optional[_T]]":
+ """Unset definition duplicated from their previous to None
+
+ This is the inverse of ''default_missing''. By removing defaulted
+ machines, we can elaborate the original and then redefault them and thus
+ avoid repeating the elaboration explicitly.
+ """
+ unfreeze = PerThreeMachineDefaultable() # type: PerThreeMachineDefaultable[T.Optional[_T]]
+ unfreeze.build = self.build
+ unfreeze.host = self.host
+ unfreeze.target = self.target
+ if unfreeze.target == unfreeze.host:
+ unfreeze.target = None
+ if unfreeze.host == unfreeze.build:
+ unfreeze.host = None
+ return unfreeze
+
+ def matches_build_machine(self, machine: MachineChoice) -> bool:
+ return self.build == self[machine]
+
+ def __repr__(self) -> str:
+ return f'PerThreeMachine({self.build!r}, {self.host!r}, {self.target!r})'
+
+
+class PerMachineDefaultable(PerMachine[T.Optional[_T]]):
+ """Extends `PerMachine` with the ability to default from `None`s.
+ """
+ def __init__(self, build: T.Optional[_T] = None, host: T.Optional[_T] = None) -> None:
+ super().__init__(build, host)
+
+ def default_missing(self) -> "PerMachine[_T]":
+ """Default host to build
+
+ This allows just specifying nothing in the native case, and just host in the
+ cross non-compiler case.
+ """
+ freeze = PerMachine(self.build, self.host)
+ if freeze.host is None:
+ freeze.host = freeze.build
+ return freeze
+
+ def __repr__(self) -> str:
+ return f'PerMachineDefaultable({self.build!r}, {self.host!r})'
+
+ @classmethod
+ def default(cls, is_cross: bool, build: _T, host: _T) -> PerMachine[_T]:
+ """Easy way to get a defaulted value
+
+ This allows simplifying the case where you can control whether host and
+ build are separate or not with a boolean. If the is_cross value is set
+ to true then the optional host value will be used, otherwise the host
+ will be set to the build value.
+ """
+ m = cls(build)
+ if is_cross:
+ m.host = host
+ return m.default_missing()
+
+
+class PerThreeMachineDefaultable(PerMachineDefaultable, PerThreeMachine[T.Optional[_T]]):
+ """Extends `PerThreeMachine` with the ability to default from `None`s.
+ """
+ def __init__(self) -> None:
+ PerThreeMachine.__init__(self, None, None, None)
+
+ def default_missing(self) -> "PerThreeMachine[T.Optional[_T]]":
+ """Default host to build and target to host.
+
+ This allows just specifying nothing in the native case, just host in the
+ cross non-compiler case, and just target in the native-built
+ cross-compiler case.
+ """
+ freeze = PerThreeMachine(self.build, self.host, self.target)
+ if freeze.host is None:
+ freeze.host = freeze.build
+ if freeze.target is None:
+ freeze.target = freeze.host
+ return freeze
+
+ def __repr__(self) -> str:
+ return f'PerThreeMachineDefaultable({self.build!r}, {self.host!r}, {self.target!r})'
+
+
+def is_sunos() -> bool:
+ return platform.system().lower() == 'sunos'
+
+
+def is_osx() -> bool:
+ return platform.system().lower() == 'darwin'
+
+
+def is_linux() -> bool:
+ return platform.system().lower() == 'linux'
+
+
+def is_android() -> bool:
+ return platform.system().lower() == 'android'
+
+
+def is_haiku() -> bool:
+ return platform.system().lower() == 'haiku'
+
+
+def is_openbsd() -> bool:
+ return platform.system().lower() == 'openbsd'
+
+
+def is_windows() -> bool:
+ platname = platform.system().lower()
+ return platname == 'windows'
+
+def is_wsl() -> bool:
+ return is_linux() and 'microsoft' in platform.release().lower()
+
+def is_cygwin() -> bool:
+ return sys.platform == 'cygwin'
+
+
+def is_debianlike() -> bool:
+ return os.path.isfile('/etc/debian_version')
+
+
+def is_dragonflybsd() -> bool:
+ return platform.system().lower() == 'dragonfly'
+
+
+def is_netbsd() -> bool:
+ return platform.system().lower() == 'netbsd'
+
+
+def is_freebsd() -> bool:
+ return platform.system().lower() == 'freebsd'
+
+def is_irix() -> bool:
+ return platform.system().startswith('irix')
+
+def is_hurd() -> bool:
+ return platform.system().lower() == 'gnu'
+
+def is_qnx() -> bool:
+ return platform.system().lower() == 'qnx'
+
+def is_aix() -> bool:
+ return platform.system().lower() == 'aix'
+
+def exe_exists(arglist: T.List[str]) -> bool:
+ try:
+ if subprocess.run(arglist, timeout=10).returncode == 0:
+ return True
+ except (FileNotFoundError, subprocess.TimeoutExpired):
+ pass
+ return False
+
+
+@lru_cache(maxsize=None)
+def darwin_get_object_archs(objpath: str) -> 'ImmutableListProtocol[str]':
+ '''
+ For a specific object (executable, static library, dylib, etc), run `lipo`
+ to fetch the list of archs supported by it. Supports both thin objects and
+ 'fat' objects.
+ '''
+ _, stdo, stderr = Popen_safe(['lipo', '-info', objpath])
+ if not stdo:
+ mlog.debug(f'lipo {objpath}: {stderr}')
+ return None
+ stdo = stdo.rsplit(': ', 1)[1]
+ # Convert from lipo-style archs to meson-style CPUs
+ stdo = stdo.replace('i386', 'x86')
+ stdo = stdo.replace('arm64', 'aarch64')
+ # Add generic name for armv7 and armv7s
+ if 'armv7' in stdo:
+ stdo += ' arm'
+ return stdo.split()
+
+
+def detect_vcs(source_dir: T.Union[str, Path]) -> T.Optional[T.Dict[str, str]]:
+ vcs_systems = [
+ dict(name = 'git', cmd = 'git', repo_dir = '.git', get_rev = 'git describe --dirty=+', rev_regex = '(.*)', dep = '.git/logs/HEAD'),
+ dict(name = 'mercurial', cmd = 'hg', repo_dir = '.hg', get_rev = 'hg id -i', rev_regex = '(.*)', dep = '.hg/dirstate'),
+ dict(name = 'subversion', cmd = 'svn', repo_dir = '.svn', get_rev = 'svn info', rev_regex = 'Revision: (.*)', dep = '.svn/wc.db'),
+ dict(name = 'bazaar', cmd = 'bzr', repo_dir = '.bzr', get_rev = 'bzr revno', rev_regex = '(.*)', dep = '.bzr'),
+ ]
+ if isinstance(source_dir, str):
+ source_dir = Path(source_dir)
+
+ parent_paths_and_self = collections.deque(source_dir.parents)
+ # Prepend the source directory to the front so we can check it;
+ # source_dir.parents doesn't include source_dir
+ parent_paths_and_self.appendleft(source_dir)
+ for curdir in parent_paths_and_self:
+ for vcs in vcs_systems:
+ if Path.is_dir(curdir.joinpath(vcs['repo_dir'])) and shutil.which(vcs['cmd']):
+ vcs['wc_dir'] = str(curdir)
+ return vcs
+ return None
+
+def current_vs_supports_modules() -> bool:
+ vsver = os.environ.get('VSCMD_VER', '')
+ nums = vsver.split('.', 2)
+ major = int(nums[0])
+ if major >= 17:
+ return True
+ if major == 16 and int(nums[1]) >= 10:
+ return True
+ return vsver.startswith('16.9.0') and '-pre.' in vsver
+
+# a helper class which implements the same version ordering as RPM
+class Version:
+ def __init__(self, s: str) -> None:
+ self._s = s
+
+ # split into numeric, alphabetic and non-alphanumeric sequences
+ sequences1 = re.finditer(r'(\d+|[a-zA-Z]+|[^a-zA-Z\d]+)', s)
+
+ # non-alphanumeric separators are discarded
+ sequences2 = [m for m in sequences1 if not re.match(r'[^a-zA-Z\d]+', m.group(1))]
+
+ # numeric sequences are converted from strings to ints
+ sequences3 = [int(m.group(1)) if m.group(1).isdigit() else m.group(1) for m in sequences2]
+
+ self._v = sequences3
+
+ def __str__(self) -> str:
+ return '{} (V={})'.format(self._s, str(self._v))
+
+ def __repr__(self) -> str:
+ return f''
+
+ def __lt__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.lt)
+ return NotImplemented
+
+ def __gt__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.gt)
+ return NotImplemented
+
+ def __le__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.le)
+ return NotImplemented
+
+ def __ge__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self.__cmp(other, operator.ge)
+ return NotImplemented
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self._v == other._v
+ return NotImplemented
+
+ def __ne__(self, other: object) -> bool:
+ if isinstance(other, Version):
+ return self._v != other._v
+ return NotImplemented
+
+ def __cmp(self, other: 'Version', comparator: T.Callable[[T.Any, T.Any], bool]) -> bool:
+ # compare each sequence in order
+ for ours, theirs in zip(self._v, other._v):
+ # sort a non-digit sequence before a digit sequence
+ ours_is_int = isinstance(ours, int)
+ theirs_is_int = isinstance(theirs, int)
+ if ours_is_int != theirs_is_int:
+ return comparator(ours_is_int, theirs_is_int)
+
+ if ours != theirs:
+ return comparator(ours, theirs)
+
+ # if equal length, all components have matched, so equal
+ # otherwise, the version with a suffix remaining is greater
+ return comparator(len(self._v), len(other._v))
+
+
+def _version_extract_cmpop(vstr2: str) -> T.Tuple[T.Callable[[T.Any, T.Any], bool], str]:
+ if vstr2.startswith('>='):
+ cmpop = operator.ge
+ vstr2 = vstr2[2:]
+ elif vstr2.startswith('<='):
+ cmpop = operator.le
+ vstr2 = vstr2[2:]
+ elif vstr2.startswith('!='):
+ cmpop = operator.ne
+ vstr2 = vstr2[2:]
+ elif vstr2.startswith('=='):
+ cmpop = operator.eq
+ vstr2 = vstr2[2:]
+ elif vstr2.startswith('='):
+ cmpop = operator.eq
+ vstr2 = vstr2[1:]
+ elif vstr2.startswith('>'):
+ cmpop = operator.gt
+ vstr2 = vstr2[1:]
+ elif vstr2.startswith('<'):
+ cmpop = operator.lt
+ vstr2 = vstr2[1:]
+ else:
+ cmpop = operator.eq
+
+ return (cmpop, vstr2)
+
+
+def version_compare(vstr1: str, vstr2: str) -> bool:
+ (cmpop, vstr2) = _version_extract_cmpop(vstr2)
+ return cmpop(Version(vstr1), Version(vstr2))
+
+
+def version_compare_many(vstr1: str, conditions: T.Union[str, T.Iterable[str]]) -> T.Tuple[bool, T.List[str], T.List[str]]:
+ if isinstance(conditions, str):
+ conditions = [conditions]
+ found = []
+ not_found = []
+ for req in conditions:
+ if not version_compare(vstr1, req):
+ not_found.append(req)
+ else:
+ found.append(req)
+ return not_found == [], not_found, found
+
+
+# determine if the minimum version satisfying the condition |condition| exceeds
+# the minimum version for a feature |minimum|
+def version_compare_condition_with_min(condition: str, minimum: str) -> bool:
+ if condition.startswith('>='):
+ cmpop = operator.le
+ condition = condition[2:]
+ elif condition.startswith('<='):
+ return False
+ elif condition.startswith('!='):
+ return False
+ elif condition.startswith('=='):
+ cmpop = operator.le
+ condition = condition[2:]
+ elif condition.startswith('='):
+ cmpop = operator.le
+ condition = condition[1:]
+ elif condition.startswith('>'):
+ cmpop = operator.lt
+ condition = condition[1:]
+ elif condition.startswith('<'):
+ return False
+ else:
+ cmpop = operator.le
+
+ # Declaring a project(meson_version: '>=0.46') and then using features in
+ # 0.46.0 is valid, because (knowing the meson versioning scheme) '0.46.0' is
+ # the lowest version which satisfies the constraint '>=0.46'.
+ #
+ # But this will fail here, because the minimum version required by the
+ # version constraint ('0.46') is strictly less (in our version comparison)
+ # than the minimum version needed for the feature ('0.46.0').
+ #
+ # Map versions in the constraint of the form '0.46' to '0.46.0', to embed
+ # this knowledge of the meson versioning scheme.
+ condition = condition.strip()
+ if re.match(r'^\d+.\d+$', condition):
+ condition += '.0'
+
+ return T.cast(bool, cmpop(Version(minimum), Version(condition)))
+
+def search_version(text: str) -> str:
+ # Usually of the type 4.1.4 but compiler output may contain
+ # stuff like this:
+ # (Sourcery CodeBench Lite 2014.05-29) 4.8.3 20140320 (prerelease)
+ # Limiting major version number to two digits seems to work
+ # thus far. When we get to GCC 100, this will break, but
+ # if we are still relevant when that happens, it can be
+ # considered an achievement in itself.
+ #
+ # This regex is reaching magic levels. If it ever needs
+ # to be updated, do not complexify but convert to something
+ # saner instead.
+ # We'll demystify it a bit with a verbose definition.
+ version_regex = re.compile(r"""
+ (? str:
+ if is_debianlike():
+ try:
+ pc = subprocess.Popen(['dpkg-architecture', '-qDEB_HOST_MULTIARCH'],
+ stdout=subprocess.PIPE,
+ stderr=subprocess.DEVNULL)
+ (stdo, _) = pc.communicate()
+ if pc.returncode == 0:
+ archpath = stdo.decode().strip()
+ return 'lib/' + archpath
+ except Exception:
+ pass
+ if is_freebsd() or is_irix():
+ return 'lib'
+ if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
+ return 'lib64'
+ return 'lib'
+
+
+def default_libexecdir() -> str:
+ # There is no way to auto-detect this, so it must be set at build time
+ return 'libexec'
+
+
+def default_prefix() -> str:
+ return 'c:/' if is_windows() else '/usr/local'
+
+
+def get_library_dirs() -> T.List[str]:
+ if is_windows():
+ return ['C:/mingw/lib'] # TODO: get programmatically
+ if is_osx():
+ return ['/usr/lib'] # TODO: get programmatically
+ # The following is probably Debian/Ubuntu specific.
+ # /usr/local/lib is first because it contains stuff
+ # installed by the sysadmin and is probably more up-to-date
+ # than /usr/lib. If you feel that this search order is
+ # problematic, please raise the issue on the mailing list.
+ unixdirs = ['/usr/local/lib', '/usr/lib', '/lib']
+
+ if is_freebsd():
+ return unixdirs
+ # FIXME: this needs to be further genericized for aarch64 etc.
+ machine = platform.machine()
+ if machine in ('i386', 'i486', 'i586', 'i686'):
+ plat = 'i386'
+ elif machine.startswith('arm'):
+ plat = 'arm'
+ else:
+ plat = ''
+
+ # Solaris puts 32-bit libraries in the main /lib & /usr/lib directories
+ # and 64-bit libraries in platform specific subdirectories.
+ if is_sunos():
+ if machine == 'i86pc':
+ plat = 'amd64'
+ elif machine.startswith('sun4'):
+ plat = 'sparcv9'
+
+ usr_platdir = Path('/usr/lib/') / plat
+ if usr_platdir.is_dir():
+ unixdirs += [str(x) for x in (usr_platdir).iterdir() if x.is_dir()]
+ if os.path.exists('/usr/lib64'):
+ unixdirs.append('/usr/lib64')
+
+ lib_platdir = Path('/lib/') / plat
+ if lib_platdir.is_dir():
+ unixdirs += [str(x) for x in (lib_platdir).iterdir() if x.is_dir()]
+ if os.path.exists('/lib64'):
+ unixdirs.append('/lib64')
+
+ return unixdirs
+
+
+def has_path_sep(name: str, sep: str = '/\\') -> bool:
+ 'Checks if any of the specified @sep path separators are in @name'
+ for each in sep:
+ if each in name:
+ return True
+ return False
+
+
+if is_windows():
+ # shlex.split is not suitable for splitting command line on Window (https://bugs.python.org/issue1724822);
+ # shlex.quote is similarly problematic. Below are "proper" implementations of these functions according to
+ # https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments and
+ # https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
+
+ _whitespace = ' \t\n\r'
+ _find_unsafe_char = re.compile(fr'[{_whitespace}"]').search
+
+ def quote_arg(arg: str) -> str:
+ if arg and not _find_unsafe_char(arg):
+ return arg
+
+ result = '"'
+ num_backslashes = 0
+ for c in arg:
+ if c == '\\':
+ num_backslashes += 1
+ else:
+ if c == '"':
+ # Escape all backslashes and the following double quotation mark
+ num_backslashes = num_backslashes * 2 + 1
+
+ result += num_backslashes * '\\' + c
+ num_backslashes = 0
+
+ # Escape all backslashes, but let the terminating double quotation
+ # mark we add below be interpreted as a metacharacter
+ result += (num_backslashes * 2) * '\\' + '"'
+ return result
+
+ def split_args(cmd: str) -> T.List[str]:
+ result = []
+ arg = ''
+ num_backslashes = 0
+ num_quotes = 0
+ in_quotes = False
+ for c in cmd:
+ if c == '\\':
+ num_backslashes += 1
+ else:
+ if c == '"' and not num_backslashes % 2:
+ # unescaped quote, eat it
+ arg += (num_backslashes // 2) * '\\'
+ num_quotes += 1
+ in_quotes = not in_quotes
+ elif c in _whitespace and not in_quotes:
+ if arg or num_quotes:
+ # reached the end of the argument
+ result.append(arg)
+ arg = ''
+ num_quotes = 0
+ else:
+ if c == '"':
+ # escaped quote
+ num_backslashes = (num_backslashes - 1) // 2
+
+ arg += num_backslashes * '\\' + c
+
+ num_backslashes = 0
+
+ if arg or num_quotes:
+ result.append(arg)
+
+ return result
+else:
+ def quote_arg(arg: str) -> str:
+ return shlex.quote(arg)
+
+ def split_args(cmd: str) -> T.List[str]:
+ return shlex.split(cmd)
+
+
+def join_args(args: T.Iterable[str]) -> str:
+ return ' '.join([quote_arg(x) for x in args])
+
+
+def do_replacement(regex: T.Pattern[str], line: str, variable_format: str,
+ confdata: T.Union[T.Dict[str, T.Tuple[str, T.Optional[str]]], 'ConfigurationData']) -> T.Tuple[str, T.Set[str]]:
+ missing_variables = set() # type: T.Set[str]
+ if variable_format == 'cmake':
+ start_tag = '${'
+ backslash_tag = '\\${'
+ else:
+ assert variable_format in ['meson', 'cmake@']
+ start_tag = '@'
+ backslash_tag = '\\@'
+
+ def variable_replace(match: T.Match[str]) -> str:
+ # Pairs of escape characters before '@' or '\@'
+ if match.group(0).endswith('\\'):
+ num_escapes = match.end(0) - match.start(0)
+ return '\\' * (num_escapes // 2)
+ # Single escape character and '@'
+ elif match.group(0) == backslash_tag:
+ return start_tag
+ # Template variable to be replaced
+ else:
+ varname = match.group(1)
+ var_str = ''
+ if varname in confdata:
+ var, _ = confdata.get(varname)
+ if isinstance(var, str):
+ var_str = var
+ elif isinstance(var, int):
+ var_str = str(var)
+ else:
+ msg = f'Tried to replace variable {varname!r} value with ' \
+ f'something other than a string or int: {var!r}'
+ raise MesonException(msg)
+ else:
+ missing_variables.add(varname)
+ return var_str
+ return re.sub(regex, variable_replace, line), missing_variables
+
+def do_define(regex: T.Pattern[str], line: str, confdata: 'ConfigurationData', variable_format: str) -> str:
+ def get_cmake_define(line: str, confdata: 'ConfigurationData') -> str:
+ arr = line.split()
+ define_value = []
+ for token in arr[2:]:
+ try:
+ (v, desc) = confdata.get(token)
+ define_value += [str(v)]
+ except KeyError:
+ define_value += [token]
+ return ' '.join(define_value)
+
+ arr = line.split()
+ if variable_format == 'meson' and len(arr) != 2:
+ raise MesonException('#mesondefine does not contain exactly two tokens: %s' % line.strip())
+
+ varname = arr[1]
+ try:
+ (v, desc) = confdata.get(varname)
+ except KeyError:
+ return '/* #undef %s */\n' % varname
+ if isinstance(v, bool):
+ if v:
+ return '#define %s\n' % varname
+ else:
+ return '#undef %s\n' % varname
+ elif isinstance(v, int):
+ return '#define %s %d\n' % (varname, v)
+ elif isinstance(v, str):
+ if variable_format == 'meson':
+ result = v
+ else:
+ result = get_cmake_define(line, confdata)
+ result = f'#define {varname} {result}\n'
+ (result, missing_variable) = do_replacement(regex, result, variable_format, confdata)
+ return result
+ else:
+ raise MesonException('#mesondefine argument "%s" is of unknown type.' % varname)
+
+def get_variable_regex(variable_format: str = 'meson') -> T.Pattern[str]:
+ # Only allow (a-z, A-Z, 0-9, _, -) as valid characters for a define
+ # Also allow escaping '@' with '\@'
+ if variable_format in ['meson', 'cmake@']:
+ regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@([-a-zA-Z0-9_]+)@')
+ elif variable_format == 'cmake':
+ regex = re.compile(r'(?:\\\\)+(?=\\?\$)|\\\${|\${([-a-zA-Z0-9_]+)}')
+ else:
+ raise MesonException(f'Format "{variable_format}" not handled')
+ return regex
+
+def do_conf_str(src: str, data: list, confdata: 'ConfigurationData', variable_format: str,
+ encoding: str = 'utf-8') -> T.Tuple[T.List[str], T.Set[str], bool]:
+ def line_is_valid(line: str, variable_format: str) -> bool:
+ if variable_format == 'meson':
+ if '#cmakedefine' in line:
+ return False
+ else: # cmake format
+ if '#mesondefine' in line:
+ return False
+ return True
+
+ regex = get_variable_regex(variable_format)
+
+ search_token = '#mesondefine'
+ if variable_format != 'meson':
+ search_token = '#cmakedefine'
+
+ result = []
+ missing_variables = set()
+ # Detect when the configuration data is empty and no tokens were found
+ # during substitution so we can warn the user to use the `copy:` kwarg.
+ confdata_useless = not confdata.keys()
+ for line in data:
+ if line.startswith(search_token):
+ confdata_useless = False
+ line = do_define(regex, line, confdata, variable_format)
+ else:
+ if not line_is_valid(line, variable_format):
+ raise MesonException(f'Format error in {src}: saw "{line.strip()}" when format set to "{variable_format}"')
+ line, missing = do_replacement(regex, line, variable_format, confdata)
+ missing_variables.update(missing)
+ if missing:
+ confdata_useless = False
+ result.append(line)
+
+ return result, missing_variables, confdata_useless
+
+def do_conf_file(src: str, dst: str, confdata: 'ConfigurationData', variable_format: str,
+ encoding: str = 'utf-8') -> T.Tuple[T.Set[str], bool]:
+ try:
+ with open(src, encoding=encoding, newline='') as f:
+ data = f.readlines()
+ except Exception as e:
+ raise MesonException(f'Could not read input file {src}: {e!s}')
+
+ (result, missing_variables, confdata_useless) = do_conf_str(src, data, confdata, variable_format, encoding)
+ dst_tmp = dst + '~'
+ try:
+ with open(dst_tmp, 'w', encoding=encoding, newline='') as f:
+ f.writelines(result)
+ except Exception as e:
+ raise MesonException(f'Could not write output file {dst}: {e!s}')
+ shutil.copymode(src, dst_tmp)
+ replace_if_different(dst, dst_tmp)
+ return missing_variables, confdata_useless
+
+CONF_C_PRELUDE = '''/*
+ * Autogenerated by the Meson build system.
+ * Do not edit, your changes will be lost.
+ */
+
+#pragma once
+
+'''
+
+CONF_NASM_PRELUDE = '''; Autogenerated by the Meson build system.
+; Do not edit, your changes will be lost.
+
+'''
+
+def dump_conf_header(ofilename: str, cdata: 'ConfigurationData', output_format: str) -> None:
+ if output_format == 'c':
+ prelude = CONF_C_PRELUDE
+ prefix = '#'
+ elif output_format == 'nasm':
+ prelude = CONF_NASM_PRELUDE
+ prefix = '%'
+ else:
+ raise MesonBugException(f'Undefined output_format: "{output_format}"')
+
+ ofilename_tmp = ofilename + '~'
+ with open(ofilename_tmp, 'w', encoding='utf-8') as ofile:
+ ofile.write(prelude)
+ for k in sorted(cdata.keys()):
+ (v, desc) = cdata.get(k)
+ if desc:
+ if output_format == 'c':
+ ofile.write('/* %s */\n' % desc)
+ elif output_format == 'nasm':
+ for line in desc.split('\n'):
+ ofile.write('; %s\n' % line)
+ if isinstance(v, bool):
+ if v:
+ ofile.write(f'{prefix}define {k}\n\n')
+ else:
+ ofile.write(f'{prefix}undef {k}\n\n')
+ elif isinstance(v, (int, str)):
+ ofile.write(f'{prefix}define {k} {v}\n\n')
+ else:
+ raise MesonException('Unknown data type in configuration file entry: ' + k)
+ replace_if_different(ofilename, ofilename_tmp)
+
+
+def replace_if_different(dst: str, dst_tmp: str) -> None:
+ # If contents are identical, don't touch the file to prevent
+ # unnecessary rebuilds.
+ different = True
+ try:
+ with open(dst, 'rb') as f1, open(dst_tmp, 'rb') as f2:
+ if f1.read() == f2.read():
+ different = False
+ except FileNotFoundError:
+ pass
+ if different:
+ os.replace(dst_tmp, dst)
+ else:
+ os.unlink(dst_tmp)
+
+
+def listify(item: T.Any, flatten: bool = True) -> T.List[T.Any]:
+ '''
+ Returns a list with all args embedded in a list if they are not a list.
+ This function preserves order.
+ @flatten: Convert lists of lists to a flat list
+ '''
+ if not isinstance(item, list):
+ return [item]
+ result = [] # type: T.List[T.Any]
+ for i in item:
+ if flatten and isinstance(i, list):
+ result += listify(i, flatten=True)
+ else:
+ result.append(i)
+ return result
+
+
+def extract_as_list(dict_object: T.Dict[_T, _U], key: _T, pop: bool = False) -> T.List[_U]:
+ '''
+ Extracts all values from given dict_object and listifies them.
+ '''
+ fetch: T.Callable[[_T], _U] = dict_object.get
+ if pop:
+ fetch = dict_object.pop
+ # If there's only one key, we don't return a list with one element
+ return listify(fetch(key) or [], flatten=True)
+
+
+def typeslistify(item: 'T.Union[_T, T.Sequence[_T]]',
+ types: 'T.Union[T.Type[_T], T.Tuple[T.Type[_T]]]') -> T.List[_T]:
+ '''
+ Ensure that type(@item) is one of @types or a
+ list of items all of which are of type @types
+ '''
+ if isinstance(item, types):
+ item = T.cast(T.List[_T], [item])
+ if not isinstance(item, list):
+ raise MesonException('Item must be a list or one of {!r}, not {!r}'.format(types, type(item)))
+ for i in item:
+ if i is not None and not isinstance(i, types):
+ raise MesonException('List item must be one of {!r}, not {!r}'.format(types, type(i)))
+ return item
+
+
+def stringlistify(item: T.Union[T.Any, T.Sequence[T.Any]]) -> T.List[str]:
+ return typeslistify(item, str)
+
+
+def expand_arguments(args: T.Iterable[str]) -> T.Optional[T.List[str]]:
+ expended_args = [] # type: T.List[str]
+ for arg in args:
+ if not arg.startswith('@'):
+ expended_args.append(arg)
+ continue
+
+ args_file = arg[1:]
+ try:
+ with open(args_file, encoding='utf-8') as f:
+ extended_args = f.read().split()
+ expended_args += extended_args
+ except Exception as e:
+ mlog.error('Expanding command line arguments:', args_file, 'not found')
+ mlog.exception(e)
+ return None
+ return expended_args
+
+
+def partition(pred: T.Callable[[_T], object], iterable: T.Iterable[_T]) -> T.Tuple[T.Iterator[_T], T.Iterator[_T]]:
+ """Use a predicate to partition entries into false entries and true
+ entries.
+
+ >>> x, y = partition(is_odd, range(10))
+ >>> (list(x), list(y))
+ ([0, 2, 4, 6, 8], [1, 3, 5, 7, 9])
+ """
+ t1, t2 = tee(iterable)
+ return filterfalse(pred, t1), filter(pred, t2)
+
+
+def Popen_safe(args: T.List[str], write: T.Optional[str] = None,
+ stdout: T.Union[T.TextIO, T.BinaryIO, int] = subprocess.PIPE,
+ stderr: T.Union[T.TextIO, T.BinaryIO, int] = subprocess.PIPE,
+ **kwargs: T.Any) -> T.Tuple['subprocess.Popen[str]', str, str]:
+ import locale
+ encoding = locale.getpreferredencoding()
+ # Redirect stdin to DEVNULL otherwise the command run by us here might mess
+ # up the console and ANSI colors will stop working on Windows.
+ if 'stdin' not in kwargs:
+ kwargs['stdin'] = subprocess.DEVNULL
+ if not sys.stdout.encoding or encoding.upper() != 'UTF-8':
+ p, o, e = Popen_safe_legacy(args, write=write, stdout=stdout, stderr=stderr, **kwargs)
+ else:
+ p = subprocess.Popen(args, universal_newlines=True, close_fds=False,
+ stdout=stdout, stderr=stderr, **kwargs)
+ o, e = p.communicate(write)
+ # Sometimes the command that we run will call another command which will be
+ # without the above stdin workaround, so set the console mode again just in
+ # case.
+ mlog.setup_console()
+ return p, o, e
+
+
+def Popen_safe_legacy(args: T.List[str], write: T.Optional[str] = None,
+ stdout: T.Union[T.TextIO, T.BinaryIO, int] = subprocess.PIPE,
+ stderr: T.Union[T.TextIO, T.BinaryIO, int] = subprocess.PIPE,
+ **kwargs: T.Any) -> T.Tuple['subprocess.Popen[str]', str, str]:
+ p = subprocess.Popen(args, universal_newlines=False, close_fds=False,
+ stdout=stdout, stderr=stderr, **kwargs)
+ input_ = None # type: T.Optional[bytes]
+ if write is not None:
+ input_ = write.encode('utf-8')
+ o, e = p.communicate(input_)
+ if o is not None:
+ if sys.stdout.encoding:
+ o = o.decode(encoding=sys.stdout.encoding, errors='replace').replace('\r\n', '\n')
+ else:
+ o = o.decode(errors='replace').replace('\r\n', '\n')
+ if e is not None:
+ if sys.stderr is not None and sys.stderr.encoding:
+ e = e.decode(encoding=sys.stderr.encoding, errors='replace').replace('\r\n', '\n')
+ else:
+ e = e.decode(errors='replace').replace('\r\n', '\n')
+ return p, o, e
+
+
+def iter_regexin_iter(regexiter: T.Iterable[str], initer: T.Iterable[str]) -> T.Optional[str]:
+ '''
+ Takes each regular expression in @regexiter and tries to search for it in
+ every item in @initer. If there is a match, returns that match.
+ Else returns False.
+ '''
+ for regex in regexiter:
+ for ii in initer:
+ if not isinstance(ii, str):
+ continue
+ match = re.search(regex, ii)
+ if match:
+ return match.group()
+ return None
+
+
+def _substitute_values_check_errors(command: T.List[str], values: T.Dict[str, T.Union[str, T.List[str]]]) -> None:
+ # Error checking
+ inregex = ['@INPUT([0-9]+)?@', '@PLAINNAME@', '@BASENAME@'] # type: T.List[str]
+ outregex = ['@OUTPUT([0-9]+)?@', '@OUTDIR@'] # type: T.List[str]
+ if '@INPUT@' not in values:
+ # Error out if any input-derived templates are present in the command
+ match = iter_regexin_iter(inregex, command)
+ if match:
+ raise MesonException(f'Command cannot have {match!r}, since no input files were specified')
+ else:
+ if len(values['@INPUT@']) > 1:
+ # Error out if @PLAINNAME@ or @BASENAME@ is present in the command
+ match = iter_regexin_iter(inregex[1:], command)
+ if match:
+ raise MesonException(f'Command cannot have {match!r} when there is '
+ 'more than one input file')
+ # Error out if an invalid @INPUTnn@ template was specified
+ for each in command:
+ if not isinstance(each, str):
+ continue
+ match2 = re.search(inregex[0], each)
+ if match2 and match2.group() not in values:
+ m = 'Command cannot have {!r} since there are only {!r} inputs'
+ raise MesonException(m.format(match2.group(), len(values['@INPUT@'])))
+ if '@OUTPUT@' not in values:
+ # Error out if any output-derived templates are present in the command
+ match = iter_regexin_iter(outregex, command)
+ if match:
+ raise MesonException(f'Command cannot have {match!r} since there are no outputs')
+ else:
+ # Error out if an invalid @OUTPUTnn@ template was specified
+ for each in command:
+ if not isinstance(each, str):
+ continue
+ match2 = re.search(outregex[0], each)
+ if match2 and match2.group() not in values:
+ m = 'Command cannot have {!r} since there are only {!r} outputs'
+ raise MesonException(m.format(match2.group(), len(values['@OUTPUT@'])))
+
+
+def substitute_values(command: T.List[str], values: T.Dict[str, T.Union[str, T.List[str]]]) -> T.List[str]:
+ '''
+ Substitute the template strings in the @values dict into the list of
+ strings @command and return a new list. For a full list of the templates,
+ see get_filenames_templates_dict()
+
+ If multiple inputs/outputs are given in the @values dictionary, we
+ substitute @INPUT@ and @OUTPUT@ only if they are the entire string, not
+ just a part of it, and in that case we substitute *all* of them.
+
+ The typing of this function is difficult, as only @OUTPUT@ and @INPUT@ can
+ be lists, everything else is a string. However, TypeDict cannot represent
+ this, as you can have optional keys, but not extra keys. We end up just
+ having to us asserts to convince type checkers that this is okay.
+
+ https://github.com/python/mypy/issues/4617
+ '''
+
+ def replace(m: T.Match[str]) -> str:
+ v = values[m.group(0)]
+ assert isinstance(v, str), 'for mypy'
+ return v
+
+ # Error checking
+ _substitute_values_check_errors(command, values)
+
+ # Substitution
+ outcmd = [] # type: T.List[str]
+ rx_keys = [re.escape(key) for key in values if key not in ('@INPUT@', '@OUTPUT@')]
+ value_rx = re.compile('|'.join(rx_keys)) if rx_keys else None
+ for vv in command:
+ more: T.Optional[str] = None
+ if not isinstance(vv, str):
+ outcmd.append(vv)
+ elif '@INPUT@' in vv:
+ inputs = values['@INPUT@']
+ if vv == '@INPUT@':
+ outcmd += inputs
+ elif len(inputs) == 1:
+ outcmd.append(vv.replace('@INPUT@', inputs[0]))
+ else:
+ raise MesonException("Command has '@INPUT@' as part of a "
+ "string and more than one input file")
+ elif '@OUTPUT@' in vv:
+ outputs = values['@OUTPUT@']
+ if vv == '@OUTPUT@':
+ outcmd += outputs
+ elif len(outputs) == 1:
+ outcmd.append(vv.replace('@OUTPUT@', outputs[0]))
+ else:
+ raise MesonException("Command has '@OUTPUT@' as part of a "
+ "string and more than one output file")
+
+ # Append values that are exactly a template string.
+ # This is faster than a string replace.
+ elif vv in values:
+ o = values[vv]
+ assert isinstance(o, str), 'for mypy'
+ more = o
+ # Substitute everything else with replacement
+ elif value_rx:
+ more = value_rx.sub(replace, vv)
+ else:
+ more = vv
+
+ if more is not None:
+ outcmd.append(more)
+
+ return outcmd
+
+
+def get_filenames_templates_dict(inputs: T.List[str], outputs: T.List[str]) -> T.Dict[str, T.Union[str, T.List[str]]]:
+ '''
+ Create a dictionary with template strings as keys and values as values for
+ the following templates:
+
+ @INPUT@ - the full path to one or more input files, from @inputs
+ @OUTPUT@ - the full path to one or more output files, from @outputs
+ @OUTDIR@ - the full path to the directory containing the output files
+
+ If there is only one input file, the following keys are also created:
+
+ @PLAINNAME@ - the filename of the input file
+ @BASENAME@ - the filename of the input file with the extension removed
+
+ If there is more than one input file, the following keys are also created:
+
+ @INPUT0@, @INPUT1@, ... one for each input file
+
+ If there is more than one output file, the following keys are also created:
+
+ @OUTPUT0@, @OUTPUT1@, ... one for each output file
+ '''
+ values = {} # type: T.Dict[str, T.Union[str, T.List[str]]]
+ # Gather values derived from the input
+ if inputs:
+ # We want to substitute all the inputs.
+ values['@INPUT@'] = inputs
+ for (ii, vv) in enumerate(inputs):
+ # Write out @INPUT0@, @INPUT1@, ...
+ values[f'@INPUT{ii}@'] = vv
+ if len(inputs) == 1:
+ # Just one value, substitute @PLAINNAME@ and @BASENAME@
+ values['@PLAINNAME@'] = plain = os.path.basename(inputs[0])
+ values['@BASENAME@'] = os.path.splitext(plain)[0]
+ if outputs:
+ # Gather values derived from the outputs, similar to above.
+ values['@OUTPUT@'] = outputs
+ for (ii, vv) in enumerate(outputs):
+ values[f'@OUTPUT{ii}@'] = vv
+ # Outdir should be the same for all outputs
+ values['@OUTDIR@'] = os.path.dirname(outputs[0])
+ # Many external programs fail on empty arguments.
+ if values['@OUTDIR@'] == '':
+ values['@OUTDIR@'] = '.'
+ return values
+
+
+def _make_tree_writable(topdir: str) -> None:
+ # Ensure all files and directories under topdir are writable
+ # (and readable) by owner.
+ for d, _, files in os.walk(topdir):
+ os.chmod(d, os.stat(d).st_mode | stat.S_IWRITE | stat.S_IREAD)
+ for fname in files:
+ fpath = os.path.join(d, fname)
+ if os.path.isfile(fpath):
+ os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
+
+
+def windows_proof_rmtree(f: str) -> None:
+ # On Windows if anyone is holding a file open you can't
+ # delete it. As an example an anti virus scanner might
+ # be scanning files you are trying to delete. The only
+ # way to fix this is to try again and again.
+ delays = [0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2]
+ writable = False
+ for d in delays:
+ try:
+ # Start by making the tree writable.
+ if not writable:
+ _make_tree_writable(f)
+ writable = True
+ except PermissionError:
+ time.sleep(d)
+ continue
+ try:
+ shutil.rmtree(f)
+ return
+ except FileNotFoundError:
+ return
+ except OSError:
+ time.sleep(d)
+ # Try one last time and throw if it fails.
+ shutil.rmtree(f)
+
+
+def windows_proof_rm(fpath: str) -> None:
+ """Like windows_proof_rmtree, but for a single file."""
+ if os.path.isfile(fpath):
+ os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
+ delays = [0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2]
+ for d in delays:
+ try:
+ os.unlink(fpath)
+ return
+ except FileNotFoundError:
+ return
+ except OSError:
+ time.sleep(d)
+ os.unlink(fpath)
+
+
+class TemporaryDirectoryWinProof(TemporaryDirectory):
+ """
+ Like TemporaryDirectory, but cleans things up using
+ windows_proof_rmtree()
+ """
+
+ def __exit__(self, exc: T.Any, value: T.Any, tb: T.Any) -> None:
+ try:
+ super().__exit__(exc, value, tb)
+ except OSError:
+ windows_proof_rmtree(self.name)
+
+ def cleanup(self) -> None:
+ try:
+ super().cleanup()
+ except OSError:
+ windows_proof_rmtree(self.name)
+
+
+def detect_subprojects(spdir_name: str, current_dir: str = '',
+ result: T.Optional[T.Dict[str, T.List[str]]] = None) -> T.Dict[str, T.List[str]]:
+ if result is None:
+ result = {}
+ spdir = os.path.join(current_dir, spdir_name)
+ if not os.path.exists(spdir):
+ return result
+ for trial in glob(os.path.join(spdir, '*')):
+ basename = os.path.basename(trial)
+ if trial == 'packagecache':
+ continue
+ append_this = True
+ if os.path.isdir(trial):
+ detect_subprojects(spdir_name, trial, result)
+ elif trial.endswith('.wrap') and os.path.isfile(trial):
+ basename = os.path.splitext(basename)[0]
+ else:
+ append_this = False
+ if append_this:
+ if basename in result:
+ result[basename].append(trial)
+ else:
+ result[basename] = [trial]
+ return result
+
+
+def substring_is_in_list(substr: str, strlist: T.List[str]) -> bool:
+ for s in strlist:
+ if substr in s:
+ return True
+ return False
+
+
+class OrderedSet(T.MutableSet[_T]):
+ """A set that preserves the order in which items are added, by first
+ insertion.
+ """
+ def __init__(self, iterable: T.Optional[T.Iterable[_T]] = None):
+ # typing.OrderedDict is new in 3.7.2, so we can't use that, but we can
+ # use MutableMapping, which is fine in this case.
+ self.__container = collections.OrderedDict() # type: T.MutableMapping[_T, None]
+ if iterable:
+ self.update(iterable)
+
+ def __contains__(self, value: object) -> bool:
+ return value in self.__container
+
+ def __iter__(self) -> T.Iterator[_T]:
+ return iter(self.__container.keys())
+
+ def __len__(self) -> int:
+ return len(self.__container)
+
+ def __repr__(self) -> str:
+ # Don't print 'OrderedSet("")' for an empty set.
+ if self.__container:
+ return 'OrderedSet("{}")'.format(
+ '", "'.join(repr(e) for e in self.__container.keys()))
+ return 'OrderedSet()'
+
+ def __reversed__(self) -> T.Iterator[_T]:
+ return reversed(self.__container.keys())
+
+ def add(self, value: _T) -> None:
+ self.__container[value] = None
+
+ def discard(self, value: _T) -> None:
+ if value in self.__container:
+ del self.__container[value]
+
+ def move_to_end(self, value: _T, last: bool = True) -> None:
+ # Mypy does not know about move_to_end, because it is not part of MutableMapping
+ self.__container.move_to_end(value, last) # type: ignore
+
+ def pop(self, last: bool = True) -> _T:
+ # Mypy does not know about the last argument, because it is not part of MutableMapping
+ item, _ = self.__container.popitem(last) # type: ignore
+ return item
+
+ def update(self, iterable: T.Iterable[_T]) -> None:
+ for item in iterable:
+ self.__container[item] = None
+
+ def difference(self, set_: T.Union[T.Set[_T], 'OrderedSet[_T]']) -> 'OrderedSet[_T]':
+ return type(self)(e for e in self if e not in set_)
+
+ def difference_update(self, iterable: T.Iterable[_T]) -> None:
+ for item in iterable:
+ self.discard(item)
+
+def relpath(path: str, start: str) -> str:
+ # On Windows a relative path can't be evaluated for paths on two different
+ # drives (i.e. c:\foo and f:\bar). The only thing left to do is to use the
+ # original absolute path.
+ try:
+ return os.path.relpath(path, start)
+ except (TypeError, ValueError):
+ return path
+
+def path_is_in_root(path: Path, root: Path, resolve: bool = False) -> bool:
+ # Check whether a path is within the root directory root
+ try:
+ if resolve:
+ path.resolve().relative_to(root.resolve())
+ else:
+ path.relative_to(root)
+ except ValueError:
+ return False
+ return True
+
+def relative_to_if_possible(path: Path, root: Path, resolve: bool = False) -> Path:
+ try:
+ if resolve:
+ return path.resolve().relative_to(root.resolve())
+ else:
+ return path.relative_to(root)
+ except ValueError:
+ return path
+
+class LibType(enum.IntEnum):
+
+ """Enumeration for library types."""
+
+ SHARED = 0
+ STATIC = 1
+ PREFER_SHARED = 2
+ PREFER_STATIC = 3
+
+
+class ProgressBarFallback: # lgtm [py/iter-returns-non-self]
+ '''
+ Fallback progress bar implementation when tqdm is not found
+
+ Since this class is not an actual iterator, but only provides a minimal
+ fallback, it is safe to ignore the 'Iterator does not return self from
+ __iter__ method' warning.
+ '''
+ def __init__(self, iterable: T.Optional[T.Iterable[str]] = None, total: T.Optional[int] = None,
+ bar_type: T.Optional[str] = None, desc: T.Optional[str] = None):
+ if iterable is not None:
+ self.iterable = iter(iterable)
+ return
+ self.total = total
+ self.done = 0
+ self.printed_dots = 0
+ if self.total and bar_type == 'download':
+ print('Download size:', self.total)
+ if desc:
+ print(f'{desc}: ', end='')
+
+ # Pretend to be an iterator when called as one and don't print any
+ # progress
+ def __iter__(self) -> T.Iterator[str]:
+ return self.iterable
+
+ def __next__(self) -> str:
+ return next(self.iterable)
+
+ def print_dot(self) -> None:
+ print('.', end='')
+ sys.stdout.flush()
+ self.printed_dots += 1
+
+ def update(self, progress: int) -> None:
+ self.done += progress
+ if not self.total:
+ # Just print one dot per call if we don't have a total length
+ self.print_dot()
+ return
+ ratio = int(self.done / self.total * 10)
+ while self.printed_dots < ratio:
+ self.print_dot()
+
+ def close(self) -> None:
+ print('')
+
+try:
+ from tqdm import tqdm
+except ImportError:
+ # ideally we would use a typing.Protocol here, but it's part of typing_extensions until 3.8
+ ProgressBar = ProgressBarFallback # type: T.Union[T.Type[ProgressBarFallback], T.Type[ProgressBarTqdm]]
+else:
+ class ProgressBarTqdm(tqdm):
+ def __init__(self, *args: T.Any, bar_type: T.Optional[str] = None, **kwargs: T.Any) -> None:
+ if bar_type == 'download':
+ kwargs.update({'unit': 'bytes', 'leave': True})
+ else:
+ kwargs.update({'leave': False})
+ kwargs['ncols'] = 100
+ super().__init__(*args, **kwargs)
+
+ ProgressBar = ProgressBarTqdm
+
+
+class RealPathAction(argparse.Action):
+ def __init__(self, option_strings: T.List[str], dest: str, default: str = '.', **kwargs: T.Any):
+ default = os.path.abspath(os.path.realpath(default))
+ super().__init__(option_strings, dest, nargs=None, default=default, **kwargs)
+
+ def __call__(self, parser: argparse.ArgumentParser, namespace: argparse.Namespace,
+ values: T.Union[str, T.Sequence[T.Any], None], option_string: str = None) -> None:
+ assert isinstance(values, str)
+ setattr(namespace, self.dest, os.path.abspath(os.path.realpath(values)))
+
+
+def get_wine_shortpath(winecmd: T.List[str], wine_paths: T.Sequence[str]) -> str:
+ """Get A short version of @wine_paths to avoid reaching WINEPATH number
+ of char limit.
+ """
+
+ wine_paths = list(OrderedSet(wine_paths))
+
+ getShortPathScript = '%s.bat' % str(uuid.uuid4()).lower()[:5]
+ with open(getShortPathScript, mode='w', encoding='utf-8') as f:
+ f.write("@ECHO OFF\nfor %%x in (%*) do (\n echo|set /p=;%~sx\n)\n")
+ f.flush()
+ try:
+ with open(os.devnull, 'w', encoding='utf-8') as stderr:
+ wine_path = subprocess.check_output(
+ winecmd +
+ ['cmd', '/C', getShortPathScript] + wine_paths,
+ stderr=stderr).decode('utf-8')
+ except subprocess.CalledProcessError as e:
+ print("Could not get short paths: %s" % e)
+ wine_path = ';'.join(wine_paths)
+ finally:
+ os.remove(getShortPathScript)
+ if len(wine_path) > 2048:
+ raise MesonException(
+ 'WINEPATH size {} > 2048'
+ ' this will cause random failure.'.format(
+ len(wine_path)))
+
+ return wine_path.strip(';')
+
+
+def run_once(func: T.Callable[..., _T]) -> T.Callable[..., _T]:
+ ret = [] # type: T.List[_T]
+
+ @wraps(func)
+ def wrapper(*args: T.Any, **kwargs: T.Any) -> _T:
+ if ret:
+ return ret[0]
+
+ val = func(*args, **kwargs)
+ ret.append(val)
+ return val
+
+ return wrapper
+
+
+def generate_list(func: T.Callable[..., T.Generator[_T, None, None]]) -> T.Callable[..., T.List[_T]]:
+ @wraps(func)
+ def wrapper(*args: T.Any, **kwargs: T.Any) -> T.List[_T]:
+ return list(func(*args, **kwargs))
+
+ return wrapper
+
+
+class OptionOverrideProxy(collections.abc.MutableMapping):
+
+ '''Mimic an option list but transparently override selected option
+ values.
+ '''
+
+ # TODO: the typing here could be made more explicit using a TypeDict from
+ # python 3.8 or typing_extensions
+
+ def __init__(self, overrides: T.Dict['OptionKey', T.Any], *options: 'KeyedOptionDictType'):
+ self.overrides = overrides.copy()
+ self.options: T.Dict['OptionKey', UserOption] = {}
+ for o in options:
+ self.options.update(o)
+
+ def __getitem__(self, key: 'OptionKey') -> T.Union['UserOption']:
+ if key in self.options:
+ opt = self.options[key]
+ if key in self.overrides:
+ opt = copy.copy(opt)
+ opt.set_value(self.overrides[key])
+ return opt
+ raise KeyError('Option not found', key)
+
+ def __setitem__(self, key: 'OptionKey', value: T.Union['UserOption']) -> None:
+ self.overrides[key] = value.value
+
+ def __delitem__(self, key: 'OptionKey') -> None:
+ del self.overrides[key]
+
+ def __iter__(self) -> T.Iterator['OptionKey']:
+ return iter(self.options)
+
+ def __len__(self) -> int:
+ return len(self.options)
+
+ def copy(self) -> 'OptionOverrideProxy':
+ return OptionOverrideProxy(self.overrides.copy(), self.options.copy())
+
+
+class OptionType(enum.IntEnum):
+
+ """Enum used to specify what kind of argument a thing is."""
+
+ BUILTIN = 0
+ BACKEND = 1
+ BASE = 2
+ COMPILER = 3
+ PROJECT = 4
+
+# This is copied from coredata. There is no way to share this, because this
+# is used in the OptionKey constructor, and the coredata lists are
+# OptionKeys...
+_BUILTIN_NAMES = {
+ 'prefix',
+ 'bindir',
+ 'datadir',
+ 'includedir',
+ 'infodir',
+ 'libdir',
+ 'libexecdir',
+ 'localedir',
+ 'localstatedir',
+ 'mandir',
+ 'sbindir',
+ 'sharedstatedir',
+ 'sysconfdir',
+ 'auto_features',
+ 'backend',
+ 'buildtype',
+ 'debug',
+ 'default_library',
+ 'errorlogs',
+ 'install_umask',
+ 'layout',
+ 'optimization',
+ 'stdsplit',
+ 'strip',
+ 'unity',
+ 'unity_size',
+ 'warning_level',
+ 'werror',
+ 'wrap_mode',
+ 'force_fallback_for',
+ 'pkg_config_path',
+ 'cmake_prefix_path',
+}
+
+
+def _classify_argument(key: 'OptionKey') -> OptionType:
+ """Classify arguments into groups so we know which dict to assign them to."""
+
+ if key.name.startswith('b_'):
+ return OptionType.BASE
+ elif key.lang is not None:
+ return OptionType.COMPILER
+ elif key.name in _BUILTIN_NAMES or key.module:
+ return OptionType.BUILTIN
+ elif key.name.startswith('backend_'):
+ assert key.machine is MachineChoice.HOST, str(key)
+ return OptionType.BACKEND
+ else:
+ assert key.machine is MachineChoice.HOST, str(key)
+ return OptionType.PROJECT
+
+
+@total_ordering
+class OptionKey:
+
+ """Represents an option key in the various option dictionaries.
+
+ This provides a flexible, powerful way to map option names from their
+ external form (things like subproject:build.option) to something that
+ internally easier to reason about and produce.
+ """
+
+ __slots__ = ['name', 'subproject', 'machine', 'lang', '_hash', 'type', 'module']
+
+ name: str
+ subproject: str
+ machine: MachineChoice
+ lang: T.Optional[str]
+ _hash: int
+ type: OptionType
+ module: T.Optional[str]
+
+ def __init__(self, name: str, subproject: str = '',
+ machine: MachineChoice = MachineChoice.HOST,
+ lang: T.Optional[str] = None,
+ module: T.Optional[str] = None,
+ _type: T.Optional[OptionType] = None):
+ # the _type option to the constructor is kinda private. We want to be
+ # able tos ave the state and avoid the lookup function when
+ # pickling/unpickling, but we need to be able to calculate it when
+ # constructing a new OptionKey
+ object.__setattr__(self, 'name', name)
+ object.__setattr__(self, 'subproject', subproject)
+ object.__setattr__(self, 'machine', machine)
+ object.__setattr__(self, 'lang', lang)
+ object.__setattr__(self, 'module', module)
+ object.__setattr__(self, '_hash', hash((name, subproject, machine, lang, module)))
+ if _type is None:
+ _type = _classify_argument(self)
+ object.__setattr__(self, 'type', _type)
+
+ def __setattr__(self, key: str, value: T.Any) -> None:
+ raise AttributeError('OptionKey instances do not support mutation.')
+
+ def __getstate__(self) -> T.Dict[str, T.Any]:
+ return {
+ 'name': self.name,
+ 'subproject': self.subproject,
+ 'machine': self.machine,
+ 'lang': self.lang,
+ '_type': self.type,
+ 'module': self.module,
+ }
+
+ def __setstate__(self, state: T.Dict[str, T.Any]) -> None:
+ """De-serialize the state of a pickle.
+
+ This is very clever. __init__ is not a constructor, it's an
+ initializer, therefore it's safe to call more than once. We create a
+ state in the custom __getstate__ method, which is valid to pass
+ splatted to the initializer.
+ """
+ # Mypy doesn't like this, because it's so clever.
+ self.__init__(**state) # type: ignore
+
+ def __hash__(self) -> int:
+ return self._hash
+
+ def _to_tuple(self) -> T.Tuple[str, OptionType, str, str, MachineChoice, str]:
+ return (self.subproject, self.type, self.lang or '', self.module or '', self.machine, self.name)
+
+ def __eq__(self, other: object) -> bool:
+ if isinstance(other, OptionKey):
+ return self._to_tuple() == other._to_tuple()
+ return NotImplemented
+
+ def __lt__(self, other: object) -> bool:
+ if isinstance(other, OptionKey):
+ return self._to_tuple() < other._to_tuple()
+ return NotImplemented
+
+ def __str__(self) -> str:
+ out = self.name
+ if self.lang:
+ out = f'{self.lang}_{out}'
+ if self.machine is MachineChoice.BUILD:
+ out = f'build.{out}'
+ if self.module:
+ out = f'{self.module}.{out}'
+ if self.subproject:
+ out = f'{self.subproject}:{out}'
+ return out
+
+ def __repr__(self) -> str:
+ return f'OptionKey({self.name!r}, {self.subproject!r}, {self.machine!r}, {self.lang!r}, {self.module!r}, {self.type!r})'
+
+ @classmethod
+ def from_string(cls, raw: str) -> 'OptionKey':
+ """Parse the raw command line format into a three part tuple.
+
+ This takes strings like `mysubproject:build.myoption` and Creates an
+ OptionKey out of them.
+ """
+ try:
+ subproject, raw2 = raw.split(':')
+ except ValueError:
+ subproject, raw2 = '', raw
+
+ module = None
+ for_machine = MachineChoice.HOST
+ try:
+ prefix, raw3 = raw2.split('.')
+ if prefix == 'build':
+ for_machine = MachineChoice.BUILD
+ else:
+ module = prefix
+ except ValueError:
+ raw3 = raw2
+
+ from ..compilers import all_languages
+ if any(raw3.startswith(f'{l}_') for l in all_languages):
+ lang, opt = raw3.split('_', 1)
+ else:
+ lang, opt = None, raw3
+ assert ':' not in opt
+ assert '.' not in opt
+
+ return cls(opt, subproject, for_machine, lang, module)
+
+ def evolve(self, name: T.Optional[str] = None, subproject: T.Optional[str] = None,
+ machine: T.Optional[MachineChoice] = None, lang: T.Optional[str] = '',
+ module: T.Optional[str] = '') -> 'OptionKey':
+ """Create a new copy of this key, but with alterted members.
+
+ For example:
+ >>> a = OptionKey('foo', '', MachineChoice.Host)
+ >>> b = OptionKey('foo', 'bar', MachineChoice.Host)
+ >>> b == a.evolve(subproject='bar')
+ True
+ """
+ # We have to be a little clever with lang here, because lang is valid
+ # as None, for non-compiler options
+ return OptionKey(
+ name if name is not None else self.name,
+ subproject if subproject is not None else self.subproject,
+ machine if machine is not None else self.machine,
+ lang if lang != '' else self.lang,
+ module if module != '' else self.module
+ )
+
+ def as_root(self) -> 'OptionKey':
+ """Convenience method for key.evolve(subproject='')."""
+ return self.evolve(subproject='')
+
+ def as_build(self) -> 'OptionKey':
+ """Convenience method for key.evolve(machine=MachinceChoice.BUILD)."""
+ return self.evolve(machine=MachineChoice.BUILD)
+
+ def as_host(self) -> 'OptionKey':
+ """Convenience method for key.evolve(machine=MachinceChoice.HOST)."""
+ return self.evolve(machine=MachineChoice.HOST)
+
+ def is_backend(self) -> bool:
+ """Convenience method to check if this is a backend option."""
+ return self.type is OptionType.BACKEND
+
+ def is_builtin(self) -> bool:
+ """Convenience method to check if this is a builtin option."""
+ return self.type is OptionType.BUILTIN
+
+ def is_compiler(self) -> bool:
+ """Convenience method to check if this is a builtin option."""
+ return self.type is OptionType.COMPILER
+
+ def is_project(self) -> bool:
+ """Convenience method to check if this is a project option."""
+ return self.type is OptionType.PROJECT
+
+ def is_base(self) -> bool:
+ """Convenience method to check if this is a base option."""
+ return self.type is OptionType.BASE
diff -Nru meson-0.53.2/mesonbuild/mesonlib/vsenv.py meson-0.61.2/mesonbuild/mesonlib/vsenv.py
--- meson-0.53.2/mesonbuild/mesonlib/vsenv.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib/vsenv.py 2022-01-17 10:50:38.000000000 +0000
@@ -0,0 +1,112 @@
+import os
+import subprocess
+import json
+import pathlib
+import platform
+import shutil
+import tempfile
+
+from .. import mlog
+from .universal import MesonException, is_windows
+
+
+bat_template = '''@ECHO OFF
+
+call "{}"
+
+ECHO {}
+SET
+'''
+
+# If on Windows and VS is installed but not set up in the environment,
+# set it to be runnable. In this way Meson can be directly invoked
+# from any shell, VS Code etc.
+def _setup_vsenv(force: bool) -> bool:
+ if not is_windows():
+ return False
+ if os.environ.get('OSTYPE') == 'cygwin':
+ return False
+ if 'MESON_FORCE_VSENV_FOR_UNITTEST' not in os.environ:
+ if 'Visual Studio' in os.environ['PATH']:
+ return False
+ # VSINSTALL is set when running setvars from a Visual Studio installation
+ # Tested with Visual Studio 2012 and 2017
+ if 'VSINSTALLDIR' in os.environ:
+ return False
+ # Check explicitly for cl when on Windows
+ if shutil.which('cl.exe'):
+ return False
+ if not force:
+ if shutil.which('cc'):
+ return False
+ if shutil.which('gcc'):
+ return False
+ if shutil.which('clang'):
+ return False
+ if shutil.which('clang-cl'):
+ return False
+
+ root = os.environ.get("ProgramFiles(x86)") or os.environ.get("ProgramFiles")
+ bat_locator_bin = pathlib.Path(root, 'Microsoft Visual Studio/Installer/vswhere.exe')
+ if not bat_locator_bin.exists():
+ raise MesonException(f'Could not find {bat_locator_bin}')
+ bat_json = subprocess.check_output(
+ [
+ str(bat_locator_bin),
+ '-latest',
+ '-prerelease',
+ '-requiresAny',
+ '-requires', 'Microsoft.VisualStudio.Component.VC.Tools.x86.x64',
+ '-requires', 'Microsoft.VisualStudio.Workload.WDExpress',
+ '-products', '*',
+ '-utf8',
+ '-format',
+ 'json'
+ ]
+ )
+ bat_info = json.loads(bat_json)
+ if not bat_info:
+ # VS installer instelled but not VS itself maybe?
+ raise MesonException(f'Could not parse vswhere.exe output')
+ bat_root = pathlib.Path(bat_info[0]['installationPath'])
+ if platform.machine() == 'ARM64':
+ bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_arm64.bat'
+ else:
+ bat_path = bat_root / 'VC/Auxiliary/Build/vcvars64.bat'
+ # if VS is not found try VS Express
+ if not bat_path.exists():
+ bat_path = bat_root / 'VC/Auxiliary/Build/vcvarsx86_amd64.bat'
+ if not bat_path.exists():
+ raise MesonException(f'Could not find {bat_path}')
+
+ mlog.log('Activating VS', bat_info[0]['catalog']['productDisplayVersion'])
+ bat_separator = '---SPLIT---'
+ bat_contents = bat_template.format(bat_path, bat_separator)
+ bat_file = tempfile.NamedTemporaryFile('w', suffix='.bat', encoding='utf-8', delete=False)
+ bat_file.write(bat_contents)
+ bat_file.flush()
+ bat_file.close()
+ bat_output = subprocess.check_output(bat_file.name, universal_newlines=True)
+ os.unlink(bat_file.name)
+ bat_lines = bat_output.split('\n')
+ bat_separator_seen = False
+ for bat_line in bat_lines:
+ if bat_line == bat_separator:
+ bat_separator_seen = True
+ continue
+ if not bat_separator_seen:
+ continue
+ if not bat_line:
+ continue
+ k, v = bat_line.split('=', 1)
+ os.environ[k] = v
+ return True
+
+def setup_vsenv(force: bool = False) -> bool:
+ try:
+ return _setup_vsenv(force)
+ except MesonException as e:
+ if force:
+ raise
+ mlog.warning('Failed to activate VS environment:', str(e))
+ return False
diff -Nru meson-0.53.2/mesonbuild/mesonlib/win32.py meson-0.61.2/mesonbuild/mesonlib/win32.py
--- meson-0.53.2/mesonbuild/mesonlib/win32.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib/win32.py 2021-07-20 08:56:20.000000000 +0000
@@ -0,0 +1,39 @@
+# SPDX-license-identifier: Apache-2.0
+# Copyright 2012-2021 The Meson development team
+# Copyright © 2021 Intel Corporation
+
+# 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.
+
+"""Windows specific implementations of mesonlib functionality."""
+
+import msvcrt
+import typing as T
+
+from .universal import MesonException
+from .platform import BuildDirLock as BuildDirLockBase
+
+__all__ = ['BuildDirLock']
+
+class BuildDirLock(BuildDirLockBase):
+
+ def __enter__(self) -> None:
+ self.lockfile = open(self.lockfilename, 'w', encoding='utf-8')
+ try:
+ msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_NBLCK, 1)
+ except (BlockingIOError, PermissionError):
+ self.lockfile.close()
+ raise MesonException('Some other Meson process is already using this build directory. Exiting.')
+
+ def __exit__(self, *args: T.Any) -> None:
+ msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_UNLCK, 1)
+ self.lockfile.close()
diff -Nru meson-0.53.2/mesonbuild/mesonlib.py meson-0.61.2/mesonbuild/mesonlib.py
--- meson-0.53.2/mesonbuild/mesonlib.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonlib.py 1970-01-01 00:00:00.000000000 +0000
@@ -1,1577 +0,0 @@
-# Copyright 2012-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.
-
-"""A library of random helper functionality."""
-from pathlib import Path
-import sys
-import stat
-import time
-import platform, subprocess, operator, os, shlex, shutil, re
-import collections
-from enum import Enum
-from functools import lru_cache, update_wrapper
-from itertools import tee, filterfalse
-import typing as T
-import uuid
-
-from mesonbuild import mlog
-
-_T = T.TypeVar('_T')
-_U = T.TypeVar('_U')
-
-have_fcntl = False
-have_msvcrt = False
-# {subproject: project_meson_version}
-project_meson_versions = {}
-
-try:
- import fcntl
- have_fcntl = True
-except Exception:
- pass
-
-try:
- import msvcrt
- have_msvcrt = True
-except Exception:
- pass
-
-from glob import glob
-
-if os.path.basename(sys.executable) == 'meson.exe':
- # In Windows and using the MSI installed executable.
- python_command = [sys.executable, 'runpython']
-else:
- python_command = [sys.executable]
-meson_command = None
-
-GIT = shutil.which('git')
-def git(cmd: T.List[str], workingdir: str, **kwargs) -> subprocess.CompletedProcess:
- pc = subprocess.run([GIT, '-C', workingdir] + cmd,
- # Redirect stdin to DEVNULL otherwise git messes up the
- # console and ANSI colors stop working on Windows.
- stdin=subprocess.DEVNULL, **kwargs)
- # Sometimes git calls git recursively, such as `git submodule update
- # --recursive` which will be without the above workaround, so set the
- # console mode again just in case.
- mlog.setup_console()
- return pc
-
-
-def set_meson_command(mainfile):
- global python_command
- global meson_command
- # On UNIX-like systems `meson` is a Python script
- # On Windows `meson` and `meson.exe` are wrapper exes
- if not mainfile.endswith('.py'):
- meson_command = [mainfile]
- elif os.path.isabs(mainfile) and mainfile.endswith('mesonmain.py'):
- # Can't actually run meson with an absolute path to mesonmain.py, it must be run as -m mesonbuild.mesonmain
- meson_command = python_command + ['-m', 'mesonbuild.mesonmain']
- else:
- # Either run uninstalled, or full path to meson-script.py
- meson_command = python_command + [mainfile]
- # We print this value for unit tests.
- if 'MESON_COMMAND_TESTS' in os.environ:
- mlog.log('meson_command is {!r}'.format(meson_command))
-
-def is_ascii_string(astring) -> bool:
- try:
- if isinstance(astring, str):
- astring.encode('ascii')
- elif isinstance(astring, bytes):
- astring.decode('ascii')
- except UnicodeDecodeError:
- return False
- return True
-
-def check_direntry_issues(direntry_array):
- import locale
- # Warn if the locale is not UTF-8. This can cause various unfixable issues
- # such as os.stat not being able to decode filenames with unicode in them.
- # There is no way to reset both the preferred encoding and the filesystem
- # encoding, so we can just warn about it.
- e = locale.getpreferredencoding()
- if e.upper() != 'UTF-8' and not is_windows():
- if not isinstance(direntry_array, list):
- direntry_array = [direntry_array]
- for de in direntry_array:
- if is_ascii_string(de):
- continue
- mlog.warning('''You are using {!r} which is not a Unicode-compatible '
-locale but you are trying to access a file system entry called {!r} which is
-not pure ASCII. This may cause problems.
-'''.format(e, de), file=sys.stderr)
-
-# Put this in objects that should not get dumped to pickle files
-# by accident.
-import threading
-an_unpicklable_object = threading.Lock()
-
-class MesonException(Exception):
- '''Exceptions thrown by Meson'''
-
- def get_msg_with_context(self):
- s = ''
- if hasattr(self, 'lineno') and hasattr(self, 'file'):
- s = get_error_location_string(self.file, self.lineno) + ' '
- s += str(self)
- return s
-
-class EnvironmentException(MesonException):
- '''Exceptions thrown while processing and creating the build environment'''
-
-class FileMode:
- # The first triad is for owner permissions, the second for group permissions,
- # and the third for others (everyone else).
- # For the 1st character:
- # 'r' means can read
- # '-' means not allowed
- # For the 2nd character:
- # 'w' means can write
- # '-' means not allowed
- # For the 3rd character:
- # 'x' means can execute
- # 's' means can execute and setuid/setgid is set (owner/group triads only)
- # 'S' means cannot execute and setuid/setgid is set (owner/group triads only)
- # 't' means can execute and sticky bit is set ("others" triads only)
- # 'T' means cannot execute and sticky bit is set ("others" triads only)
- # '-' means none of these are allowed
- #
- # The meanings of 'rwx' perms is not obvious for directories; see:
- # https://www.hackinglinuxexposed.com/articles/20030424.html
- #
- # For information on this notation such as setuid/setgid/sticky bits, see:
- # https://en.wikipedia.org/wiki/File_system_permissions#Symbolic_notation
- symbolic_perms_regex = re.compile('[r-][w-][xsS-]' # Owner perms
- '[r-][w-][xsS-]' # Group perms
- '[r-][w-][xtT-]') # Others perms
-
- def __init__(self, perms=None, owner=None, group=None):
- self.perms_s = perms
- self.perms = self.perms_s_to_bits(perms)
- self.owner = owner
- self.group = group
-
- def __repr__(self):
- ret = ' str:
- return self.relative_name()
-
- def __repr__(self) -> str:
- ret = ' str:
- if self.is_built:
- return self.relative_name()
- else:
- return os.path.join(build_to_src, self.subdir, self.fname)
-
- @lru_cache(maxsize=None)
- def absolute_path(self, srcdir: str, builddir: str) -> str:
- absdir = srcdir
- if self.is_built:
- absdir = builddir
- return os.path.join(absdir, self.relative_name())
-
- def endswith(self, ending: str) -> bool:
- return self.fname.endswith(ending)
-
- def split(self, s: str) -> T.List[str]:
- return self.fname.split(s)
-
- def __eq__(self, other) -> bool:
- return (self.fname, self.subdir, self.is_built) == (other.fname, other.subdir, other.is_built)
-
- def __hash__(self) -> int:
- return hash((self.fname, self.subdir, self.is_built))
-
- @lru_cache(maxsize=None)
- def relative_name(self) -> str:
- return os.path.join(self.subdir, self.fname)
-
-
-def get_compiler_for_source(compilers, src):
- for comp in compilers:
- if comp.can_compile(src):
- return comp
- raise MesonException('No specified compiler can handle file {!s}'.format(src))
-
-def classify_unity_sources(compilers, sources):
- compsrclist = {}
- for src in sources:
- comp = get_compiler_for_source(compilers, src)
- if comp not in compsrclist:
- compsrclist[comp] = [src]
- else:
- compsrclist[comp].append(src)
- return compsrclist
-
-class OrderedEnum(Enum):
- """
- An Enum which additionally offers homogeneous ordered comparison.
- """
- def __ge__(self, other):
- if self.__class__ is other.__class__:
- return self.value >= other.value
- return NotImplemented
-
- def __gt__(self, other):
- if self.__class__ is other.__class__:
- return self.value > other.value
- return NotImplemented
-
- def __le__(self, other):
- if self.__class__ is other.__class__:
- return self.value <= other.value
- return NotImplemented
-
- def __lt__(self, other):
- if self.__class__ is other.__class__:
- return self.value < other.value
- return NotImplemented
-
-
-class MachineChoice(OrderedEnum):
-
- """Enum class representing one of the two abstract machine names used in
- most places: the build, and host, machines.
- """
-
- BUILD = 0
- HOST = 1
-
- def get_lower_case_name(self):
- return PerMachine('build', 'host')[self]
-
- def get_prefix(self):
- return PerMachine('build.', '')[self]
-
-
-class PerMachine(T.Generic[_T]):
- def __init__(self, build: _T, host: _T):
- self.build = build
- self.host = host
-
- def __getitem__(self, machine: MachineChoice) -> _T:
- return {
- MachineChoice.BUILD: self.build,
- MachineChoice.HOST: self.host,
- }[machine]
-
- def __setitem__(self, machine: MachineChoice, val: _T) -> None:
- setattr(self, machine.get_lower_case_name(), val)
-
- def miss_defaulting(self) -> "PerMachineDefaultable[T.Optional[_T]]":
- """Unset definition duplicated from their previous to None
-
- This is the inverse of ''default_missing''. By removing defaulted
- machines, we can elaborate the original and then redefault them and thus
- avoid repeating the elaboration explicitly.
- """
- unfreeze = PerMachineDefaultable() # type: PerMachineDefaultable[T.Optional[_T]]
- unfreeze.build = self.build
- unfreeze.host = self.host
- if unfreeze.host == unfreeze.build:
- unfreeze.host = None
- return unfreeze
-
-
-class PerThreeMachine(PerMachine[_T]):
- """Like `PerMachine` but includes `target` too.
-
- It turns out just one thing do we need track the target machine. There's no
- need to computer the `target` field so we don't bother overriding the
- `__getitem__`/`__setitem__` methods.
- """
- def __init__(self, build: _T, host: _T, target: _T):
- super().__init__(build, host)
- self.target = target
-
- def miss_defaulting(self) -> "PerThreeMachineDefaultable[T.Optional[_T]]":
- """Unset definition duplicated from their previous to None
-
- This is the inverse of ''default_missing''. By removing defaulted
- machines, we can elaborate the original and then redefault them and thus
- avoid repeating the elaboration explicitly.
- """
- unfreeze = PerThreeMachineDefaultable() # type: PerThreeMachineDefaultable[T.Optional[_T]]
- unfreeze.build = self.build
- unfreeze.host = self.host
- unfreeze.target = self.target
- if unfreeze.target == unfreeze.host:
- unfreeze.target = None
- if unfreeze.host == unfreeze.build:
- unfreeze.host = None
- return unfreeze
-
- def matches_build_machine(self, machine: MachineChoice) -> bool:
- return self.build == self[machine]
-
-class PerMachineDefaultable(PerMachine[T.Optional[_T]]):
- """Extends `PerMachine` with the ability to default from `None`s.
- """
- def __init__(self) -> None:
- super().__init__(None, None)
-
- def default_missing(self) -> "PerMachine[T.Optional[_T]]":
- """Default host to build
-
- This allows just specifying nothing in the native case, and just host in the
- cross non-compiler case.
- """
- freeze = PerMachine(self.build, self.host)
- if freeze.host is None:
- freeze.host = freeze.build
- return freeze
-
-
-class PerThreeMachineDefaultable(PerMachineDefaultable, PerThreeMachine[T.Optional[_T]]):
- """Extends `PerThreeMachine` with the ability to default from `None`s.
- """
- def __init__(self) -> None:
- PerThreeMachine.__init__(self, None, None, None)
-
- def default_missing(self) -> "PerThreeMachine[T.Optional[_T]]":
- """Default host to build and target to host.
-
- This allows just specifying nothing in the native case, just host in the
- cross non-compiler case, and just target in the native-built
- cross-compiler case.
- """
- freeze = PerThreeMachine(self.build, self.host, self.target)
- if freeze.host is None:
- freeze.host = freeze.build
- if freeze.target is None:
- freeze.target = freeze.host
- return freeze
-
-
-def is_sunos() -> bool:
- return platform.system().lower() == 'sunos'
-
-def is_osx() -> bool:
- return platform.system().lower() == 'darwin'
-
-def is_linux() -> bool:
- return platform.system().lower() == 'linux'
-
-def is_android() -> bool:
- return platform.system().lower() == 'android'
-
-def is_haiku() -> bool:
- return platform.system().lower() == 'haiku'
-
-def is_openbsd() -> bool:
- return platform.system().lower() == 'openbsd'
-
-def is_windows() -> bool:
- platname = platform.system().lower()
- return platname == 'windows' or 'mingw' in platname
-
-def is_cygwin() -> bool:
- return platform.system().lower().startswith('cygwin')
-
-def is_debianlike() -> bool:
- return os.path.isfile('/etc/debian_version')
-
-def is_dragonflybsd() -> bool:
- return platform.system().lower() == 'dragonfly'
-
-def is_netbsd() -> bool:
- return platform.system().lower() == 'netbsd'
-
-def is_freebsd() -> bool:
- return platform.system().lower() == 'freebsd'
-
-def exe_exists(arglist: T.List[str]) -> bool:
- try:
- if subprocess.run(arglist, timeout=10).returncode == 0:
- return True
- except (FileNotFoundError, subprocess.TimeoutExpired):
- pass
- return False
-
-@lru_cache(maxsize=None)
-def darwin_get_object_archs(objpath):
- '''
- For a specific object (executable, static library, dylib, etc), run `lipo`
- to fetch the list of archs supported by it. Supports both thin objects and
- 'fat' objects.
- '''
- _, stdo, stderr = Popen_safe(['lipo', '-info', objpath])
- if not stdo:
- mlog.debug('lipo {}: {}'.format(objpath, stderr))
- return None
- stdo = stdo.rsplit(': ', 1)[1]
- # Convert from lipo-style archs to meson-style CPUs
- stdo = stdo.replace('i386', 'x86')
- stdo = stdo.replace('arm64', 'aarch64')
- # Add generic name for armv7 and armv7s
- if 'armv7' in stdo:
- stdo += ' arm'
- return stdo.split()
-
-def detect_vcs(source_dir):
- vcs_systems = [
- dict(name = 'git', cmd = 'git', repo_dir = '.git', get_rev = 'git describe --dirty=+', rev_regex = '(.*)', dep = '.git/logs/HEAD'),
- dict(name = 'mercurial', cmd = 'hg', repo_dir = '.hg', get_rev = 'hg id -i', rev_regex = '(.*)', dep = '.hg/dirstate'),
- dict(name = 'subversion', cmd = 'svn', repo_dir = '.svn', get_rev = 'svn info', rev_regex = 'Revision: (.*)', dep = '.svn/wc.db'),
- dict(name = 'bazaar', cmd = 'bzr', repo_dir = '.bzr', get_rev = 'bzr revno', rev_regex = '(.*)', dep = '.bzr'),
- ]
- # FIXME: this is much cleaner with pathlib.Path
- segs = source_dir.replace('\\', '/').split('/')
- for i in range(len(segs), -1, -1):
- curdir = '/'.join(segs[:i])
- for vcs in vcs_systems:
- if os.path.isdir(os.path.join(curdir, vcs['repo_dir'])) and shutil.which(vcs['cmd']):
- vcs['wc_dir'] = curdir
- return vcs
- return None
-
-# a helper class which implements the same version ordering as RPM
-class Version:
- def __init__(self, s):
- self._s = s
-
- # split into numeric, alphabetic and non-alphanumeric sequences
- sequences = re.finditer(r'(\d+|[a-zA-Z]+|[^a-zA-Z\d]+)', s)
- # non-alphanumeric separators are discarded
- sequences = [m for m in sequences if not re.match(r'[^a-zA-Z\d]+', m.group(1))]
- # numeric sequences are converted from strings to ints
- sequences = [int(m.group(1)) if m.group(1).isdigit() else m.group(1) for m in sequences]
-
- self._v = sequences
-
- def __str__(self):
- return '%s (V=%s)' % (self._s, str(self._v))
-
- def __repr__(self):
- return ''.format(self._s)
-
- def __lt__(self, other):
- if isinstance(other, Version):
- return self.__cmp(other, operator.lt)
- return NotImplemented
-
- def __gt__(self, other):
- if isinstance(other, Version):
- return self.__cmp(other, operator.gt)
- return NotImplemented
-
- def __le__(self, other):
- if isinstance(other, Version):
- return self.__cmp(other, operator.le)
- return NotImplemented
-
- def __ge__(self, other):
- if isinstance(other, Version):
- return self.__cmp(other, operator.ge)
- return NotImplemented
-
- def __eq__(self, other):
- if isinstance(other, Version):
- return self._v == other._v
- return NotImplemented
-
- def __ne__(self, other):
- if isinstance(other, Version):
- return self._v != other._v
- return NotImplemented
-
- def __cmp(self, other, comparator):
- # compare each sequence in order
- for ours, theirs in zip(self._v, other._v):
- # sort a non-digit sequence before a digit sequence
- ours_is_int = isinstance(ours, int)
- theirs_is_int = isinstance(theirs, int)
- if ours_is_int != theirs_is_int:
- return comparator(ours_is_int, theirs_is_int)
-
- if ours != theirs:
- return comparator(ours, theirs)
-
- # if equal length, all components have matched, so equal
- # otherwise, the version with a suffix remaining is greater
- return comparator(len(self._v), len(other._v))
-
-def _version_extract_cmpop(vstr2: str) -> T.Tuple[T.Callable[[T.Any, T.Any], bool], str]:
- if vstr2.startswith('>='):
- cmpop = operator.ge
- vstr2 = vstr2[2:]
- elif vstr2.startswith('<='):
- cmpop = operator.le
- vstr2 = vstr2[2:]
- elif vstr2.startswith('!='):
- cmpop = operator.ne
- vstr2 = vstr2[2:]
- elif vstr2.startswith('=='):
- cmpop = operator.eq
- vstr2 = vstr2[2:]
- elif vstr2.startswith('='):
- cmpop = operator.eq
- vstr2 = vstr2[1:]
- elif vstr2.startswith('>'):
- cmpop = operator.gt
- vstr2 = vstr2[1:]
- elif vstr2.startswith('<'):
- cmpop = operator.lt
- vstr2 = vstr2[1:]
- else:
- cmpop = operator.eq
-
- return (cmpop, vstr2)
-
-def version_compare(vstr1: str, vstr2: str) -> bool:
- (cmpop, vstr2) = _version_extract_cmpop(vstr2)
- return cmpop(Version(vstr1), Version(vstr2))
-
-def version_compare_many(vstr1, conditions):
- if not isinstance(conditions, (list, tuple, frozenset)):
- conditions = [conditions]
- found = []
- not_found = []
- for req in conditions:
- if not version_compare(vstr1, req):
- not_found.append(req)
- else:
- found.append(req)
- return not_found == [], not_found, found
-
-# determine if the minimum version satisfying the condition |condition| exceeds
-# the minimum version for a feature |minimum|
-def version_compare_condition_with_min(condition: str, minimum: str) -> bool:
- if condition.startswith('>='):
- cmpop = operator.le
- condition = condition[2:]
- elif condition.startswith('<='):
- return False
- elif condition.startswith('!='):
- return False
- elif condition.startswith('=='):
- cmpop = operator.le
- condition = condition[2:]
- elif condition.startswith('='):
- cmpop = operator.le
- condition = condition[1:]
- elif condition.startswith('>'):
- cmpop = operator.lt
- condition = condition[1:]
- elif condition.startswith('<'):
- return False
- else:
- cmpop = operator.le
-
- # Declaring a project(meson_version: '>=0.46') and then using features in
- # 0.46.0 is valid, because (knowing the meson versioning scheme) '0.46.0' is
- # the lowest version which satisfies the constraint '>=0.46'.
- #
- # But this will fail here, because the minimum version required by the
- # version constraint ('0.46') is strictly less (in our version comparison)
- # than the minimum version needed for the feature ('0.46.0').
- #
- # Map versions in the constraint of the form '0.46' to '0.46.0', to embed
- # this knowledge of the meson versioning scheme.
- condition = condition.strip()
- if re.match(r'^\d+.\d+$', condition):
- condition += '.0'
-
- return cmpop(Version(minimum), Version(condition))
-
-def default_libdir():
- if is_debianlike():
- try:
- pc = subprocess.Popen(['dpkg-architecture', '-qDEB_HOST_MULTIARCH'],
- stdout=subprocess.PIPE,
- stderr=subprocess.DEVNULL)
- (stdo, _) = pc.communicate()
- if pc.returncode == 0:
- archpath = stdo.decode().strip()
- return 'lib/' + archpath
- except Exception:
- pass
- if is_freebsd():
- return 'lib'
- if os.path.isdir('/usr/lib64') and not os.path.islink('/usr/lib64'):
- return 'lib64'
- return 'lib'
-
-def default_libexecdir():
- # There is no way to auto-detect this, so it must be set at build time
- return 'libexec'
-
-def default_prefix():
- return 'c:/' if is_windows() else '/usr/local'
-
-def get_library_dirs() -> T.List[str]:
- if is_windows():
- return ['C:/mingw/lib'] # TODO: get programmatically
- if is_osx():
- return ['/usr/lib'] # TODO: get programmatically
- # The following is probably Debian/Ubuntu specific.
- # /usr/local/lib is first because it contains stuff
- # installed by the sysadmin and is probably more up-to-date
- # than /usr/lib. If you feel that this search order is
- # problematic, please raise the issue on the mailing list.
- unixdirs = ['/usr/local/lib', '/usr/lib', '/lib']
-
- if is_freebsd():
- return unixdirs
- # FIXME: this needs to be further genericized for aarch64 etc.
- machine = platform.machine()
- if machine in ('i386', 'i486', 'i586', 'i686'):
- plat = 'i386'
- elif machine.startswith('arm'):
- plat = 'arm'
- else:
- plat = ''
-
- # Solaris puts 32-bit libraries in the main /lib & /usr/lib directories
- # and 64-bit libraries in platform specific subdirectories.
- if is_sunos():
- if machine == 'i86pc':
- plat = 'amd64'
- elif machine.startswith('sun4'):
- plat = 'sparcv9'
-
- usr_platdir = Path('/usr/lib/') / plat
- if usr_platdir.is_dir():
- unixdirs += [str(x) for x in (usr_platdir).iterdir() if x.is_dir()]
- if os.path.exists('/usr/lib64'):
- unixdirs.append('/usr/lib64')
-
- lib_platdir = Path('/lib/') / plat
- if lib_platdir.is_dir():
- unixdirs += [str(x) for x in (lib_platdir).iterdir() if x.is_dir()]
- if os.path.exists('/lib64'):
- unixdirs.append('/lib64')
-
- return unixdirs
-
-def has_path_sep(name, sep='/\\'):
- 'Checks if any of the specified @sep path separators are in @name'
- for each in sep:
- if each in name:
- return True
- return False
-
-
-if is_windows():
- # shlex.split is not suitable for splitting command line on Window (https://bugs.python.org/issue1724822);
- # shlex.quote is similarly problematic. Below are "proper" implementations of these functions according to
- # https://docs.microsoft.com/en-us/cpp/c-language/parsing-c-command-line-arguments and
- # https://blogs.msdn.microsoft.com/twistylittlepassagesallalike/2011/04/23/everyone-quotes-command-line-arguments-the-wrong-way/
-
- _whitespace = ' \t\n\r'
- _find_unsafe_char = re.compile(r'[{}"]'.format(_whitespace)).search
-
- def quote_arg(arg):
- if arg and not _find_unsafe_char(arg):
- return arg
-
- result = '"'
- num_backslashes = 0
- for c in arg:
- if c == '\\':
- num_backslashes += 1
- else:
- if c == '"':
- # Escape all backslashes and the following double quotation mark
- num_backslashes = num_backslashes * 2 + 1
-
- result += num_backslashes * '\\' + c
- num_backslashes = 0
-
- # Escape all backslashes, but let the terminating double quotation
- # mark we add below be interpreted as a metacharacter
- result += (num_backslashes * 2) * '\\' + '"'
- return result
-
- def split_args(cmd: T.Sequence[str]) -> T.List[str]:
- result = []
- arg = ''
- num_backslashes = 0
- num_quotes = 0
- in_quotes = False
- for c in cmd:
- if c == '\\':
- num_backslashes += 1
- else:
- if c == '"' and not (num_backslashes % 2):
- # unescaped quote, eat it
- arg += (num_backslashes // 2) * '\\'
- num_quotes += 1
- in_quotes = not in_quotes
- elif c in _whitespace and not in_quotes:
- if arg or num_quotes:
- # reached the end of the argument
- result.append(arg)
- arg = ''
- num_quotes = 0
- else:
- if c == '"':
- # escaped quote
- num_backslashes = (num_backslashes - 1) // 2
-
- arg += num_backslashes * '\\' + c
-
- num_backslashes = 0
-
- if arg or num_quotes:
- result.append(arg)
-
- return result
-else:
- def quote_arg(arg):
- return shlex.quote(arg)
-
- def split_args(cmd):
- return shlex.split(cmd)
-
-
-def join_args(args):
- return ' '.join([quote_arg(x) for x in args])
-
-
-def do_replacement(regex, line, variable_format, confdata):
- missing_variables = set()
- start_tag = '@'
- backslash_tag = '\\@'
- if variable_format == 'cmake':
- start_tag = '${'
- backslash_tag = '\\${'
-
- def variable_replace(match):
- # Pairs of escape characters before '@' or '\@'
- if match.group(0).endswith('\\'):
- num_escapes = match.end(0) - match.start(0)
- return '\\' * (num_escapes // 2)
- # Single escape character and '@'
- elif match.group(0) == backslash_tag:
- return start_tag
- # Template variable to be replaced
- else:
- varname = match.group(1)
- if varname in confdata:
- (var, desc) = confdata.get(varname)
- if isinstance(var, str):
- pass
- elif isinstance(var, int):
- var = str(var)
- else:
- msg = 'Tried to replace variable {!r} value with ' \
- 'something other than a string or int: {!r}'
- raise MesonException(msg.format(varname, var))
- else:
- missing_variables.add(varname)
- var = ''
- return var
- return re.sub(regex, variable_replace, line), missing_variables
-
-def do_mesondefine(line, confdata):
- arr = line.split()
- if len(arr) != 2:
- raise MesonException('#mesondefine does not contain exactly two tokens: %s' % line.strip())
- varname = arr[1]
- try:
- (v, desc) = confdata.get(varname)
- except KeyError:
- return '/* #undef %s */\n' % varname
- if isinstance(v, bool):
- if v:
- return '#define %s\n' % varname
- else:
- return '#undef %s\n' % varname
- elif isinstance(v, int):
- return '#define %s %d\n' % (varname, v)
- elif isinstance(v, str):
- return '#define %s %s\n' % (varname, v)
- else:
- raise MesonException('#mesondefine argument "%s" is of unknown type.' % varname)
-
-
-def do_conf_file(src, dst, confdata, variable_format, encoding='utf-8'):
- try:
- with open(src, encoding=encoding, newline='') as f:
- data = f.readlines()
- except Exception as e:
- raise MesonException('Could not read input file %s: %s' % (src, str(e)))
- # Only allow (a-z, A-Z, 0-9, _, -) as valid characters for a define
- # Also allow escaping '@' with '\@'
- if variable_format in ['meson', 'cmake@']:
- regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@([-a-zA-Z0-9_]+)@')
- elif variable_format == 'cmake':
- regex = re.compile(r'(?:\\\\)+(?=\\?\$)|\\\${|\${([-a-zA-Z0-9_]+)}')
- else:
- raise MesonException('Format "{}" not handled'.format(variable_format))
-
- search_token = '#mesondefine'
- if variable_format != 'meson':
- search_token = '#cmakedefine'
-
- result = []
- missing_variables = set()
- # Detect when the configuration data is empty and no tokens were found
- # during substitution so we can warn the user to use the `copy:` kwarg.
- confdata_useless = not confdata.keys()
- for line in data:
- if line.startswith(search_token):
- confdata_useless = False
- line = do_mesondefine(line, confdata)
- else:
- line, missing = do_replacement(regex, line, variable_format, confdata)
- missing_variables.update(missing)
- if missing:
- confdata_useless = False
- result.append(line)
- dst_tmp = dst + '~'
- try:
- with open(dst_tmp, 'w', encoding=encoding, newline='') as f:
- f.writelines(result)
- except Exception as e:
- raise MesonException('Could not write output file %s: %s' % (dst, str(e)))
- shutil.copymode(src, dst_tmp)
- replace_if_different(dst, dst_tmp)
- return missing_variables, confdata_useless
-
-CONF_C_PRELUDE = '''/*
- * Autogenerated by the Meson build system.
- * Do not edit, your changes will be lost.
- */
-
-#pragma once
-
-'''
-
-CONF_NASM_PRELUDE = '''; Autogenerated by the Meson build system.
-; Do not edit, your changes will be lost.
-
-'''
-
-def dump_conf_header(ofilename, cdata, output_format):
- if output_format == 'c':
- prelude = CONF_C_PRELUDE
- prefix = '#'
- elif output_format == 'nasm':
- prelude = CONF_NASM_PRELUDE
- prefix = '%'
-
- ofilename_tmp = ofilename + '~'
- with open(ofilename_tmp, 'w', encoding='utf-8') as ofile:
- ofile.write(prelude)
- for k in sorted(cdata.keys()):
- (v, desc) = cdata.get(k)
- if desc:
- if output_format == 'c':
- ofile.write('/* %s */\n' % desc)
- elif output_format == 'nasm':
- for line in desc.split('\n'):
- ofile.write('; %s\n' % line)
- if isinstance(v, bool):
- if v:
- ofile.write('%sdefine %s\n\n' % (prefix, k))
- else:
- ofile.write('%sundef %s\n\n' % (prefix, k))
- elif isinstance(v, (int, str)):
- ofile.write('%sdefine %s %s\n\n' % (prefix, k, v))
- else:
- raise MesonException('Unknown data type in configuration file entry: ' + k)
- replace_if_different(ofilename, ofilename_tmp)
-
-def replace_if_different(dst, dst_tmp):
- # If contents are identical, don't touch the file to prevent
- # unnecessary rebuilds.
- different = True
- try:
- with open(dst, 'rb') as f1, open(dst_tmp, 'rb') as f2:
- if f1.read() == f2.read():
- different = False
- except FileNotFoundError:
- pass
- if different:
- os.replace(dst_tmp, dst)
- else:
- os.unlink(dst_tmp)
-
-def listify(item: T.Any,
- flatten: bool = True,
- unholder: bool = False) -> T.List[T.Any]:
- '''
- Returns a list with all args embedded in a list if they are not a list.
- This function preserves order.
- @flatten: Convert lists of lists to a flat list
- @unholder: Replace each item with the object it holds, if required
-
- Note: unholding only works recursively when flattening
- '''
- if not isinstance(item, list):
- if unholder and hasattr(item, 'held_object'):
- item = item.held_object
- return [item]
- result = []
- for i in item:
- if unholder and hasattr(i, 'held_object'):
- i = i.held_object
- if flatten and isinstance(i, list):
- result += listify(i, flatten=True, unholder=unholder)
- else:
- result.append(i)
- return result
-
-
-def extract_as_list(dict_object, *keys, pop=False, **kwargs):
- '''
- Extracts all values from given dict_object and listifies them.
- '''
- result = []
- fetch = dict_object.get
- if pop:
- fetch = dict_object.pop
- # If there's only one key, we don't return a list with one element
- if len(keys) == 1:
- return listify(fetch(keys[0], []), **kwargs)
- # Return a list of values corresponding to *keys
- for key in keys:
- result.append(listify(fetch(key, []), **kwargs))
- return result
-
-def typeslistify(item: 'T.Union[_T, T.List[_T]]',
- types: 'T.Union[T.Type[_T], T.Tuple[T.Type[_T]]]') -> T.List[_T]:
- '''
- Ensure that type(@item) is one of @types or a
- list of items all of which are of type @types
- '''
- if isinstance(item, types):
- item = T.cast(T.List[_T], [item])
- if not isinstance(item, list):
- raise MesonException('Item must be a list or one of {!r}'.format(types))
- for i in item:
- if i is not None and not isinstance(i, types):
- raise MesonException('List item must be one of {!r}'.format(types))
- return item
-
-def stringlistify(item: T.Union[str, T.List[str]]) -> T.List[str]:
- return typeslistify(item, str)
-
-def expand_arguments(args):
- expended_args = []
- for arg in args:
- if not arg.startswith('@'):
- expended_args.append(arg)
- continue
-
- args_file = arg[1:]
- try:
- with open(args_file) as f:
- extended_args = f.read().split()
- expended_args += extended_args
- except Exception as e:
- print('Error expanding command line arguments, %s not found' % args_file)
- print(e)
- return None
- return expended_args
-
-def partition(pred, iterable):
- 'Use a predicate to partition entries into false entries and true entries'
- # partition(is_odd, range(10)) --> 0 2 4 6 8 and 1 3 5 7 9
- t1, t2 = tee(iterable)
- return filterfalse(pred, t1), filter(pred, t2)
-
-def Popen_safe(args: T.List[str], write: T.Optional[str] = None,
- stdout: T.Union[T.BinaryIO, int] = subprocess.PIPE,
- stderr: T.Union[T.BinaryIO, int] = subprocess.PIPE,
- **kwargs: T.Any) -> T.Tuple[subprocess.Popen, str, str]:
- import locale
- encoding = locale.getpreferredencoding()
- # Redirect stdin to DEVNULL otherwise the command run by us here might mess
- # up the console and ANSI colors will stop working on Windows.
- if 'stdin' not in kwargs:
- kwargs['stdin'] = subprocess.DEVNULL
- if sys.version_info < (3, 6) or not sys.stdout.encoding or encoding.upper() != 'UTF-8':
- p, o, e = Popen_safe_legacy(args, write=write, stdout=stdout, stderr=stderr, **kwargs)
- else:
- p = subprocess.Popen(args, universal_newlines=True, close_fds=False,
- stdout=stdout, stderr=stderr, **kwargs)
- o, e = p.communicate(write)
- # Sometimes the command that we run will call another command which will be
- # without the above stdin workaround, so set the console mode again just in
- # case.
- mlog.setup_console()
- return p, o, e
-
-def Popen_safe_legacy(args: T.List[str], write: T.Optional[str] = None,
- stdout: T.Union[T.BinaryIO, int] = subprocess.PIPE,
- stderr: T.Union[T.BinaryIO, int] = subprocess.PIPE,
- **kwargs: T.Any) -> T.Tuple[subprocess.Popen, str, str]:
- p = subprocess.Popen(args, universal_newlines=False, close_fds=False,
- stdout=stdout, stderr=stderr, **kwargs)
- input_ = None # type: T.Optional[bytes]
- if write is not None:
- input_ = write.encode('utf-8')
- o, e = p.communicate(input_)
- if o is not None:
- if sys.stdout.encoding:
- o = o.decode(encoding=sys.stdout.encoding, errors='replace').replace('\r\n', '\n')
- else:
- o = o.decode(errors='replace').replace('\r\n', '\n')
- if e is not None:
- if sys.stderr.encoding:
- e = e.decode(encoding=sys.stderr.encoding, errors='replace').replace('\r\n', '\n')
- else:
- e = e.decode(errors='replace').replace('\r\n', '\n')
- return p, o, e
-
-def iter_regexin_iter(regexiter, initer):
- '''
- Takes each regular expression in @regexiter and tries to search for it in
- every item in @initer. If there is a match, returns that match.
- Else returns False.
- '''
- for regex in regexiter:
- for ii in initer:
- if not isinstance(ii, str):
- continue
- match = re.search(regex, ii)
- if match:
- return match.group()
- return False
-
-def _substitute_values_check_errors(command, values):
- # Error checking
- inregex = ('@INPUT([0-9]+)?@', '@PLAINNAME@', '@BASENAME@')
- outregex = ('@OUTPUT([0-9]+)?@', '@OUTDIR@')
- if '@INPUT@' not in values:
- # Error out if any input-derived templates are present in the command
- match = iter_regexin_iter(inregex, command)
- if match:
- m = 'Command cannot have {!r}, since no input files were specified'
- raise MesonException(m.format(match))
- else:
- if len(values['@INPUT@']) > 1:
- # Error out if @PLAINNAME@ or @BASENAME@ is present in the command
- match = iter_regexin_iter(inregex[1:], command)
- if match:
- raise MesonException('Command cannot have {!r} when there is '
- 'more than one input file'.format(match))
- # Error out if an invalid @INPUTnn@ template was specified
- for each in command:
- if not isinstance(each, str):
- continue
- match = re.search(inregex[0], each)
- if match and match.group() not in values:
- m = 'Command cannot have {!r} since there are only {!r} inputs'
- raise MesonException(m.format(match.group(), len(values['@INPUT@'])))
- if '@OUTPUT@' not in values:
- # Error out if any output-derived templates are present in the command
- match = iter_regexin_iter(outregex, command)
- if match:
- m = 'Command cannot have {!r} since there are no outputs'
- raise MesonException(m.format(match))
- else:
- # Error out if an invalid @OUTPUTnn@ template was specified
- for each in command:
- if not isinstance(each, str):
- continue
- match = re.search(outregex[0], each)
- if match and match.group() not in values:
- m = 'Command cannot have {!r} since there are only {!r} outputs'
- raise MesonException(m.format(match.group(), len(values['@OUTPUT@'])))
-
-def substitute_values(command, values):
- '''
- Substitute the template strings in the @values dict into the list of
- strings @command and return a new list. For a full list of the templates,
- see get_filenames_templates_dict()
-
- If multiple inputs/outputs are given in the @values dictionary, we
- substitute @INPUT@ and @OUTPUT@ only if they are the entire string, not
- just a part of it, and in that case we substitute *all* of them.
- '''
- # Error checking
- _substitute_values_check_errors(command, values)
- # Substitution
- outcmd = []
- rx_keys = [re.escape(key) for key in values if key not in ('@INPUT@', '@OUTPUT@')]
- value_rx = re.compile('|'.join(rx_keys)) if rx_keys else None
- for vv in command:
- if not isinstance(vv, str):
- outcmd.append(vv)
- elif '@INPUT@' in vv:
- inputs = values['@INPUT@']
- if vv == '@INPUT@':
- outcmd += inputs
- elif len(inputs) == 1:
- outcmd.append(vv.replace('@INPUT@', inputs[0]))
- else:
- raise MesonException("Command has '@INPUT@' as part of a "
- "string and more than one input file")
- elif '@OUTPUT@' in vv:
- outputs = values['@OUTPUT@']
- if vv == '@OUTPUT@':
- outcmd += outputs
- elif len(outputs) == 1:
- outcmd.append(vv.replace('@OUTPUT@', outputs[0]))
- else:
- raise MesonException("Command has '@OUTPUT@' as part of a "
- "string and more than one output file")
- # Append values that are exactly a template string.
- # This is faster than a string replace.
- elif vv in values:
- outcmd.append(values[vv])
- # Substitute everything else with replacement
- elif value_rx:
- outcmd.append(value_rx.sub(lambda m: values[m.group(0)], vv))
- else:
- outcmd.append(vv)
- return outcmd
-
-def get_filenames_templates_dict(inputs, outputs):
- '''
- Create a dictionary with template strings as keys and values as values for
- the following templates:
-
- @INPUT@ - the full path to one or more input files, from @inputs
- @OUTPUT@ - the full path to one or more output files, from @outputs
- @OUTDIR@ - the full path to the directory containing the output files
-
- If there is only one input file, the following keys are also created:
-
- @PLAINNAME@ - the filename of the input file
- @BASENAME@ - the filename of the input file with the extension removed
-
- If there is more than one input file, the following keys are also created:
-
- @INPUT0@, @INPUT1@, ... one for each input file
-
- If there is more than one output file, the following keys are also created:
-
- @OUTPUT0@, @OUTPUT1@, ... one for each output file
- '''
- values = {}
- # Gather values derived from the input
- if inputs:
- # We want to substitute all the inputs.
- values['@INPUT@'] = inputs
- for (ii, vv) in enumerate(inputs):
- # Write out @INPUT0@, @INPUT1@, ...
- values['@INPUT{}@'.format(ii)] = vv
- if len(inputs) == 1:
- # Just one value, substitute @PLAINNAME@ and @BASENAME@
- values['@PLAINNAME@'] = plain = os.path.basename(inputs[0])
- values['@BASENAME@'] = os.path.splitext(plain)[0]
- if outputs:
- # Gather values derived from the outputs, similar to above.
- values['@OUTPUT@'] = outputs
- for (ii, vv) in enumerate(outputs):
- values['@OUTPUT{}@'.format(ii)] = vv
- # Outdir should be the same for all outputs
- values['@OUTDIR@'] = os.path.dirname(outputs[0])
- # Many external programs fail on empty arguments.
- if values['@OUTDIR@'] == '':
- values['@OUTDIR@'] = '.'
- return values
-
-
-def _make_tree_writable(topdir):
- # Ensure all files and directories under topdir are writable
- # (and readable) by owner.
- for d, _, files in os.walk(topdir):
- os.chmod(d, os.stat(d).st_mode | stat.S_IWRITE | stat.S_IREAD)
- for fname in files:
- fpath = os.path.join(d, fname)
- if os.path.isfile(fpath):
- os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
-
-
-def windows_proof_rmtree(f):
- # On Windows if anyone is holding a file open you can't
- # delete it. As an example an anti virus scanner might
- # be scanning files you are trying to delete. The only
- # way to fix this is to try again and again.
- delays = [0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2]
- # Start by making the tree wriable.
- _make_tree_writable(f)
- for d in delays:
- try:
- shutil.rmtree(f)
- return
- except FileNotFoundError:
- return
- except OSError:
- time.sleep(d)
- # Try one last time and throw if it fails.
- shutil.rmtree(f)
-
-
-def windows_proof_rm(fpath):
- """Like windows_proof_rmtree, but for a single file."""
- if os.path.isfile(fpath):
- os.chmod(fpath, os.stat(fpath).st_mode | stat.S_IWRITE | stat.S_IREAD)
- delays = [0.1, 0.1, 0.2, 0.2, 0.2, 0.5, 0.5, 1, 1, 1, 1, 2]
- for d in delays:
- try:
- os.unlink(fpath)
- return
- except FileNotFoundError:
- return
- except OSError:
- time.sleep(d)
- os.unlink(fpath)
-
-
-def detect_subprojects(spdir_name, current_dir='', result=None):
- if result is None:
- result = {}
- spdir = os.path.join(current_dir, spdir_name)
- if not os.path.exists(spdir):
- return result
- for trial in glob(os.path.join(spdir, '*')):
- basename = os.path.basename(trial)
- if trial == 'packagecache':
- continue
- append_this = True
- if os.path.isdir(trial):
- detect_subprojects(spdir_name, trial, result)
- elif trial.endswith('.wrap') and os.path.isfile(trial):
- basename = os.path.splitext(basename)[0]
- else:
- append_this = False
- if append_this:
- if basename in result:
- result[basename].append(trial)
- else:
- result[basename] = [trial]
- return result
-
-# This isn't strictly correct. What we really want here is something like:
-# class StringProtocol(typing_extensions.Protocol):
-#
-# def __str__(self) -> str: ...
-#
-# This would more accurately embody what this funcitonc an handle, but we
-# don't have that yet, so instead we'll do some casting to work around it
-def get_error_location_string(fname: str, lineno: str) -> str:
- return '{}:{}:'.format(fname, lineno)
-
-def substring_is_in_list(substr: str, strlist: T.List[str]) -> bool:
- for s in strlist:
- if substr in s:
- return True
- return False
-
-class OrderedSet(collections.abc.MutableSet):
- """A set that preserves the order in which items are added, by first
- insertion.
- """
- def __init__(self, iterable=None):
- self.__container = collections.OrderedDict()
- if iterable:
- self.update(iterable)
-
- def __contains__(self, value):
- return value in self.__container
-
- def __iter__(self):
- return iter(self.__container.keys())
-
- def __len__(self):
- return len(self.__container)
-
- def __repr__(self):
- # Don't print 'OrderedSet("")' for an empty set.
- if self.__container:
- return 'OrderedSet("{}")'.format(
- '", "'.join(repr(e) for e in self.__container.keys()))
- return 'OrderedSet()'
-
- def __reversed__(self):
- return reversed(self.__container)
-
- def add(self, value):
- self.__container[value] = None
-
- def discard(self, value):
- if value in self.__container:
- del self.__container[value]
-
- def update(self, iterable):
- for item in iterable:
- self.__container[item] = None
-
- def difference(self, set_):
- return type(self)(e for e in self if e not in set_)
-
-class BuildDirLock:
-
- def __init__(self, builddir):
- self.lockfilename = os.path.join(builddir, 'meson-private/meson.lock')
-
- def __enter__(self):
- self.lockfile = open(self.lockfilename, 'w')
- try:
- if have_fcntl:
- fcntl.flock(self.lockfile, fcntl.LOCK_EX | fcntl.LOCK_NB)
- elif have_msvcrt:
- msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_NBLCK, 1)
- except (BlockingIOError, PermissionError):
- self.lockfile.close()
- raise MesonException('Some other Meson process is already using this build directory. Exiting.')
-
- def __exit__(self, *args):
- if have_fcntl:
- fcntl.flock(self.lockfile, fcntl.LOCK_UN)
- elif have_msvcrt:
- msvcrt.locking(self.lockfile.fileno(), msvcrt.LK_UNLCK, 1)
- self.lockfile.close()
-
-def relpath(path: str, start: str) -> str:
- # On Windows a relative path can't be evaluated for paths on two different
- # drives (i.e. c:\foo and f:\bar). The only thing left to do is to use the
- # original absolute path.
- try:
- return os.path.relpath(path, start)
- except (TypeError, ValueError):
- return path
-
-
-class LibType(Enum):
-
- """Enumeration for library types."""
-
- SHARED = 0
- STATIC = 1
- PREFER_SHARED = 2
- PREFER_STATIC = 3
-
-
-class ProgressBarFallback: # lgtm [py/iter-returns-non-self]
- '''
- Fallback progress bar implementation when tqdm is not found
-
- Since this class is not an actual iterator, but only provides a minimal
- fallback, it is safe to ignore the 'Iterator does not return self from
- __iter__ method' warning.
- '''
- def __init__(self, iterable=None, total=None, bar_type=None, desc=None):
- if iterable is not None:
- self.iterable = iter(iterable)
- return
- self.total = total
- self.done = 0
- self.printed_dots = 0
- if self.total and bar_type == 'download':
- print('Download size:', self.total)
- if desc:
- print('{}: '.format(desc), end='')
-
- # Pretend to be an iterator when called as one and don't print any
- # progress
- def __iter__(self):
- return self.iterable
-
- def __next__(self):
- return next(self.iterable)
-
- def print_dot(self):
- print('.', end='')
- sys.stdout.flush()
- self.printed_dots += 1
-
- def update(self, progress):
- self.done += progress
- if not self.total:
- # Just print one dot per call if we don't have a total length
- self.print_dot()
- return
- ratio = int(self.done / self.total * 10)
- while self.printed_dots < ratio:
- self.print_dot()
-
- def close(self):
- print('')
-
-try:
- from tqdm import tqdm
-
- class ProgressBar(tqdm):
- def __init__(self, *args, bar_type=None, **kwargs):
- if bar_type == 'download':
- kwargs.update({'unit': 'bytes', 'leave': True})
- else:
- kwargs.update({'leave': False})
- kwargs['ncols'] = 100
- super().__init__(*args, **kwargs)
-except ImportError:
- ProgressBar = ProgressBarFallback
-
-
-def get_wine_shortpath(winecmd, wine_paths):
-
- """ Get A short version of @wine_paths to avoid
- reaching WINEPATH number of char limit.
- """
-
- seen = set()
- wine_paths = [p for p in wine_paths if not (p in seen or seen.add(p))]
-
- getShortPathScript = '%s.bat' % str(uuid.uuid4()).lower()[:5]
- with open(getShortPathScript, mode='w') as f:
- f.write("@ECHO OFF\nfor %%x in (%*) do (\n echo|set /p=;%~sx\n)\n")
- f.flush()
- try:
- with open(os.devnull, 'w') as stderr:
- wine_path = subprocess.check_output(
- winecmd +
- ['cmd', '/C', getShortPathScript] + wine_paths,
- stderr=stderr).decode('utf-8')
- except subprocess.CalledProcessError as e:
- print("Could not get short paths: %s" % e)
- wine_path = ';'.join(wine_paths)
- finally:
- os.remove(getShortPathScript)
- if len(wine_path) > 2048:
- raise MesonException(
- 'WINEPATH size {} > 2048'
- ' this will cause random failure.'.format(
- len(wine_path)))
-
- return wine_path.strip(';')
-
-def run_once(func):
- ret = []
-
- def wrapper(*args, **kwargs):
- if ret:
- return ret[0]
-
- val = func(*args, **kwargs)
- ret.append(val)
- return val
-
- return update_wrapper(wrapper, func)
-
-
-class OptionProxy:
- def __init__(self, value):
- self.value = value
-
-class OptionOverrideProxy:
- '''Mimic an option list but transparently override
- selected option values.'''
- def __init__(self, overrides, *options):
- self.overrides = overrides
- self.options = options
-
- def __getitem__(self, option_name):
- for opts in self.options:
- if option_name in opts:
- return self._get_override(option_name, opts[option_name])
- raise KeyError('Option not found', option_name)
-
- def _get_override(self, option_name, base_opt):
- if option_name in self.overrides:
- return OptionProxy(base_opt.validate_value(self.overrides[option_name]))
- return base_opt
-
- def copy(self):
- result = {}
- for opts in self.options:
- for option_name in opts:
- result[option_name] = self._get_override(option_name, opts[option_name])
- return result
diff -Nru meson-0.53.2/mesonbuild/mesonmain.py meson-0.61.2/mesonbuild/mesonmain.py
--- meson-0.53.2/mesonbuild/mesonmain.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/mesonmain.py 2022-02-14 19:03:13.000000000 +0000
@@ -1,4 +1,4 @@
-# Copyright 2012-2016 The Meson development team
+# Copyright 2012-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.
@@ -12,7 +12,11 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+# Work around some pathlib bugs...
+from . import _pathlib
import sys
+sys.modules['pathlib'] = _pathlib
+
import os.path
import importlib
import traceback
@@ -22,8 +26,8 @@
from . import mesonlib
from . import mlog
-from . import mconf, mdist, minit, minstall, mintro, msetup, mtest, rewriter, msubprojects, munstable_coredata
-from .mesonlib import MesonException
+from . import mconf, mdist, minit, minstall, mintro, msetup, mtest, rewriter, msubprojects, munstable_coredata, mcompile, mdevenv
+from .mesonlib import MesonException, MesonBugException
from .environment import detect_msys2_arch
from .wrap import wraptool
@@ -38,7 +42,7 @@
self.commands = {}
self.hidden_commands = []
self.parser = argparse.ArgumentParser(prog='meson', formatter_class=self.formatter)
- self.subparsers = self.parser.add_subparsers(title='Commands',
+ self.subparsers = self.parser.add_subparsers(title='Commands', dest='command',
description='If no command is specified it defaults to setup command.')
self.add_command('setup', msetup.add_arguments, msetup.run,
help_msg='Configure the project')
@@ -62,6 +66,10 @@
help_msg='Print help of a subcommand')
self.add_command('rewrite', lambda parser: rewriter.add_arguments(parser, self.formatter), rewriter.run,
help_msg='Modify the project definition')
+ self.add_command('compile', mcompile.add_arguments, mcompile.run,
+ help_msg='Build the project')
+ self.add_command('devenv', mdevenv.add_arguments, mdevenv.run,
+ help_msg='Run commands in developer environment')
# Hidden commands
self.add_command('runpython', self.add_runpython_arguments, self.run_runpython_command,
@@ -109,6 +117,7 @@
return 0
def run(self, args):
+ pending_python_deprecation_notice = False
# If first arg is not a known command, assume user wants to run the setup
# command.
known_commands = list(self.commands.keys()) + ['-h', '--help']
@@ -117,14 +126,22 @@
# Hidden commands have their own parser instead of using the global one
if args[0] in self.hidden_commands:
- parser = self.commands[args[0]]
+ command = args[0]
+ parser = self.commands[command]
args = args[1:]
else:
parser = self.parser
+ command = None
args = mesonlib.expand_arguments(args)
options = parser.parse_args(args)
+ if command is None:
+ command = options.command
+
+ if command in ('setup', 'compile', 'test', 'install') and sys.version_info < (3, 7):
+ pending_python_deprecation_notice = True
+
try:
return options.run_func(options)
except MesonException as e:
@@ -135,12 +152,26 @@
if os.environ.get('MESON_FORCE_BACKTRACE'):
raise
return 1
- except Exception:
+ except PermissionError:
+ if os.environ.get('MESON_FORCE_BACKTRACE'):
+ raise
+ traceback.print_exc()
+ return 2
+ except Exception as e:
if os.environ.get('MESON_FORCE_BACKTRACE'):
raise
traceback.print_exc()
+ msg = 'Unhandled python exception'
+ if all(getattr(e, a, None) is not None for a in ['file', 'lineno', 'colno']):
+ e = MesonBugException(msg, e.file, e.lineno, e.colno) # type: ignore
+ else:
+ e = MesonBugException(msg)
+ mlog.exception(e)
return 2
finally:
+ if pending_python_deprecation_notice:
+ mlog.notice('You are using Python 3.6 which is EOL. Starting with v0.62.0, '
+ 'Meson will require Python 3.7 or newer', fatal=False)
mlog.shutdown()
def run_script_command(script_name, script_args):
@@ -162,7 +193,7 @@
try:
return module.run(script_args)
except MesonException as e:
- mlog.error('Error in {} helper script:'.format(script_name))
+ mlog.error(f'Error in {script_name} helper script:')
mlog.exception(e)
return 1
@@ -178,9 +209,9 @@
sys.stdout.buffer = sys.stdout.raw if hasattr(sys.stdout, 'raw') else sys.stdout
def run(original_args, mainfile):
- if sys.version_info < (3, 5):
- print('Meson works correctly only with python 3.5+.')
- print('You have python %s.' % sys.version)
+ if sys.version_info < (3, 6):
+ print('Meson works correctly only with python 3.6+.')
+ print(f'You have python {sys.version}.')
print('Please update your environment')
return 1
@@ -219,7 +250,7 @@
def main():
# Always resolve the command path so Ninja can find it for regen, tests, etc.
if 'meson.exe' in sys.executable:
- assert(os.path.isabs(sys.executable))
+ assert os.path.isabs(sys.executable)
launcher = sys.executable
else:
launcher = os.path.realpath(sys.argv[0])
diff -Nru meson-0.53.2/mesonbuild/minit.py meson-0.61.2/mesonbuild/minit.py
--- meson-0.53.2/mesonbuild/minit.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/minit.py 2021-12-26 16:24:25.000000000 +0000
@@ -15,93 +15,79 @@
"""Code that creates simple startup projects."""
from pathlib import Path
-import re, shutil, subprocess
+from enum import Enum
+import subprocess
+import shutil
+import sys
+import os
+import re
from glob import glob
from mesonbuild import mesonlib
from mesonbuild.environment import detect_ninja
+from mesonbuild.templates.samplefactory import sameple_generator
+import typing as T
-from mesonbuild.templates.ctemplates import (create_exe_c_sample, create_lib_c_sample)
-from mesonbuild.templates.cpptemplates import (create_exe_cpp_sample, create_lib_cpp_sample)
-from mesonbuild.templates.objctemplates import (create_exe_objc_sample, create_lib_objc_sample)
-from mesonbuild.templates.dlangtemplates import (create_exe_d_sample, create_lib_d_sample)
-from mesonbuild.templates.fortrantemplates import (create_exe_fortran_sample, create_lib_fortran_sample)
-from mesonbuild.templates.rusttemplates import (create_exe_rust_sample, create_lib_rust_sample)
+if T.TYPE_CHECKING:
+ import argparse
-FORTRAN_SUFFIXES = ['.f', '.for', '.F', '.f90', '.F90']
+'''
+we currently have one meson template at this time.
+'''
+from mesonbuild.templates.mesontemplates import create_meson_build
-info_message = '''Sample project created. To build it run the
+FORTRAN_SUFFIXES = {'.f', '.for', '.F', '.f90', '.F90'}
+LANG_SUFFIXES = {'.c', '.cc', '.cpp', '.cs', '.cu', '.d', '.m', '.mm', '.rs', '.java', '.vala'} | FORTRAN_SUFFIXES
+LANG_SUPPORTED = {'c', 'cpp', 'cs', 'cuda', 'd', 'fortran', 'java', 'rust', 'objc', 'objcpp', 'vala'}
+
+DEFAULT_PROJECT = 'executable'
+DEFAULT_VERSION = '0.1'
+class DEFAULT_TYPES(Enum):
+ EXE = 'executable'
+ LIB = 'library'
+
+INFO_MESSAGE = '''Sample project created. To build it run the
following commands:
-meson builddir
-ninja -C builddir
+meson setup builddir
+meson compile -C builddir
'''
-def create_sample(options):
- if options.language == 'c':
- if options.type == 'executable':
- create_exe_c_sample(options.name, options.version)
- elif options.type == 'library':
- create_lib_c_sample(options.name, options.version)
- else:
- raise RuntimeError('Unreachable code')
- elif options.language == 'cpp':
- if options.type == 'executable':
- create_exe_cpp_sample(options.name, options.version)
- elif options.type == 'library':
- create_lib_cpp_sample(options.name, options.version)
- else:
- raise RuntimeError('Unreachable code')
- elif options.language == 'd':
- if options.type == 'executable':
- create_exe_d_sample(options.name, options.version)
- elif options.type == 'library':
- create_lib_d_sample(options.name, options.version)
- else:
- raise RuntimeError('Unreachable code')
- elif options.language == 'fortran':
- if options.type == 'executable':
- create_exe_fortran_sample(options.name, options.version)
- elif options.type == 'library':
- create_lib_fortran_sample(options.name, options.version)
- else:
- raise RuntimeError('Unreachable code')
- elif options.language == 'rust':
- if options.type == 'executable':
- create_exe_rust_sample(options.name, options.version)
- elif options.type == 'library':
- create_lib_rust_sample(options.name, options.version)
- else:
- raise RuntimeError('Unreachable code')
- elif options.language == 'objc':
- if options.type == 'executable':
- create_exe_objc_sample(options.name, options.version)
- elif options.type == 'library':
- create_lib_objc_sample(options.name, options.version)
- else:
- raise RuntimeError('Unreachable code')
+
+def create_sample(options: 'argparse.Namespace') -> None:
+ '''
+ Based on what arguments are passed we check for a match in language
+ then check for project type and create new Meson samples project.
+ '''
+ sample_gen = sameple_generator(options)
+ if options.type == DEFAULT_TYPES['EXE'].value:
+ sample_gen.create_executable()
+ elif options.type == DEFAULT_TYPES['LIB'].value:
+ sample_gen.create_library()
else:
raise RuntimeError('Unreachable code')
- print(info_message)
+ print(INFO_MESSAGE)
-def autodetect_options(options, sample: bool = False):
+def autodetect_options(options: 'argparse.Namespace', sample: bool = False) -> None:
+ '''
+ Here we autodetect options for args not passed in so don't have to
+ think about it.
+ '''
if not options.name:
options.name = Path().resolve().stem
if not re.match('[a-zA-Z_][a-zA-Z0-9]*', options.name) and sample:
- raise SystemExit('Name of current directory "{}" is not usable as a sample project name.\n'
- 'Specify a project name with --name.'.format(options.name))
- print('Using "{}" (name of current directory) as project name.'
- .format(options.name))
+ raise SystemExit(f'Name of current directory "{options.name}" is not usable as a sample project name.\n'
+ 'Specify a project name with --name.')
+ print(f'Using "{options.name}" (name of current directory) as project name.')
if not options.executable:
options.executable = options.name
- print('Using "{}" (project name) as name of executable to build.'
- .format(options.executable))
+ print(f'Using "{options.executable}" (project name) as name of executable to build.')
if sample:
# The rest of the autodetection is not applicable to generating sample projects.
return
if not options.srcfiles:
srcfiles = []
for f in (f for f in Path().iterdir() if f.is_file()):
- if f.suffix in (['.cc', '.cpp', '.c', '.d', '.m', '.rs'] + FORTRAN_SUFFIXES):
+ if f.suffix in LANG_SUFFIXES:
srcfiles.append(f)
if not srcfiles:
raise SystemExit('No recognizable source files found.\n'
@@ -111,11 +97,17 @@
options.srcfiles = [Path(f) for f in options.srcfiles]
if not options.language:
for f in options.srcfiles:
+ if f.suffix == '.c':
+ options.language = 'c'
+ break
if f.suffix in ('.cc', '.cpp'):
options.language = 'cpp'
break
- if f.suffix == '.c':
- options.language = 'c'
+ if f.suffix == '.cs':
+ options.language = 'cs'
+ break
+ if f.suffix == '.cu':
+ options.language = 'cuda'
break
if f.suffix == '.d':
options.language = 'd'
@@ -129,66 +121,45 @@
if f.suffix == '.m':
options.language = 'objc'
break
+ if f.suffix == '.mm':
+ options.language = 'objcpp'
+ break
+ if f.suffix == '.java':
+ options.language = 'java'
+ break
+ if f.suffix == '.vala':
+ options.language = 'vala'
+ break
if not options.language:
raise SystemExit("Can't autodetect language, please specify it with -l.")
print("Detected language: " + options.language)
-
-meson_executable_template = '''project('{project_name}', '{language}',
- version : '{version}',
- default_options : [{default_options}])
-
-executable('{executable}',
- {sourcespec},{depspec}
- install : true)
-'''
-
-def create_meson_build(options):
- if options.type != 'executable':
- raise SystemExit('\nGenerating a meson.build file from existing sources is\n'
- 'supported only for project type "executable".\n'
- 'Run meson init in an empty directory to create a sample project.')
- default_options = ['warning_level=3']
- if options.language == 'cpp':
- # This shows how to set this very common option.
- default_options += ['cpp_std=c++14']
- # If we get a meson.build autoformatter one day, this code could
- # be simplified quite a bit.
- formatted_default_options = ', '.join("'{}'".format(x) for x in default_options)
- sourcespec = ',\n '.join("'{}'".format(x) for x in options.srcfiles)
- depspec = ''
- if options.deps:
- depspec = '\n dependencies : [\n '
- depspec += ',\n '.join("dependency('{}')".format(x)
- for x in options.deps.split(','))
- depspec += '],'
- content = meson_executable_template.format(project_name=options.name,
- language=options.language,
- version=options.version,
- executable=options.executable,
- sourcespec=sourcespec,
- depspec=depspec,
- default_options=formatted_default_options)
- open('meson.build', 'w').write(content)
- print('Generated meson.build file:\n\n' + content)
-
-def add_arguments(parser):
- parser.add_argument("srcfiles", metavar="sourcefile", nargs="*",
- help="source files. default: all recognized files in current directory")
+def add_arguments(parser: 'argparse.ArgumentParser') -> None:
+ '''
+ Here we add args for that the user can passed when making a new
+ Meson project.
+ '''
+ parser.add_argument("srcfiles", metavar="sourcefile", nargs="*", help="source files. default: all recognized files in current directory")
+ parser.add_argument('-C', dest='wd', action=mesonlib.RealPathAction,
+ help='directory to cd into before running')
parser.add_argument("-n", "--name", help="project name. default: name of current directory")
parser.add_argument("-e", "--executable", help="executable name. default: project name")
parser.add_argument("-d", "--deps", help="dependencies, comma-separated")
- parser.add_argument("-l", "--language", choices=['c', 'cpp', 'd', 'fortran', 'rust', 'objc'],
- help="project language. default: autodetected based on source files")
- parser.add_argument("-b", "--build", help="build after generation", action='store_true')
- parser.add_argument("--builddir", help="directory for build", default='build')
- parser.add_argument("-f", "--force", action="store_true",
- help="force overwrite of existing files and directories.")
- parser.add_argument('--type', default='executable',
- choices=['executable', 'library'])
- parser.add_argument('--version', default='0.1')
+ parser.add_argument("-l", "--language", choices=sorted(LANG_SUPPORTED), help="project language. default: autodetected based on source files")
+ parser.add_argument("-b", "--build", action='store_true', help="build after generation")
+ parser.add_argument("--builddir", default='build', help="directory for build")
+ parser.add_argument("-f", "--force", action="store_true", help="force overwrite of existing files and directories.")
+ parser.add_argument('--type', default=DEFAULT_PROJECT, choices=('executable', 'library'), help=f"project type. default: {DEFAULT_PROJECT} based project")
+ parser.add_argument('--version', default=DEFAULT_VERSION, help=f"project version. default: {DEFAULT_VERSION}")
+
+def run(options: 'argparse.Namespace') -> int:
+ '''
+ Here we generate the new Meson sample project.
+ '''
+ if not Path(options.wd).exists():
+ sys.exit('Project source root directory not found. Run this command in source directory root.')
+ os.chdir(options.wd)
-def run(options) -> int:
if not glob('*'):
autodetect_options(options, sample=True)
if not options.language:
@@ -205,11 +176,11 @@
print('Build directory already exists, deleting it.')
shutil.rmtree(options.builddir)
print('Building...')
- cmd = mesonlib.meson_command + [options.builddir]
+ cmd = mesonlib.get_meson_command() + [options.builddir]
ret = subprocess.run(cmd)
if ret.returncode:
raise SystemExit
- cmd = [detect_ninja(), '-C', options.builddir]
+ cmd = detect_ninja() + ['-C', options.builddir]
ret = subprocess.run(cmd)
if ret.returncode:
raise SystemExit
diff -Nru meson-0.53.2/mesonbuild/minstall.py meson-0.61.2/mesonbuild/minstall.py
--- meson-0.53.2/mesonbuild/minstall.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/minstall.py 2022-02-14 19:03:13.000000000 +0000
@@ -12,13 +12,30 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import sys, pickle, os, shutil, subprocess, errno
-import shlex
from glob import glob
-from .scripts import depfixer
-from .scripts import destdir_join
-from .mesonlib import is_windows, Popen_safe
-from .mtest import rebuild_all
+from pathlib import Path
+import argparse
+import errno
+import os
+import pickle
+import platform
+import shlex
+import shutil
+import subprocess
+import sys
+import typing as T
+
+from . import build
+from . import environment
+from .backend.backends import (
+ InstallData, InstallDataBase, InstallEmptyDir, InstallSymlinkData,
+ TargetInstallData, ExecutableSerialisation
+)
+from .coredata import major_versions_differ, MesonVersionMismatchException
+from .coredata import version as coredata_version
+from .mesonlib import MesonException, Popen_safe, RealPathAction, is_windows, setup_vsenv
+from .scripts import depfixer, destdir_join
+from .scripts.meson_exe import run_exe
try:
from __main__ import __file__ as main_file
except ImportError:
@@ -26,33 +43,73 @@
# This is only used for pkexec which is not, so this is fine.
main_file = None
+if T.TYPE_CHECKING:
+ from .mesonlib import FileMode
+
+ try:
+ from typing import Protocol
+ except AttributeError:
+ from typing_extensions import Protocol # type: ignore
+
+ class ArgumentType(Protocol):
+ """Typing information for the object returned by argparse."""
+ no_rebuild: bool
+ only_changed: bool
+ profile: bool
+ quiet: bool
+ wd: str
+ destdir: str
+ dry_run: bool
+ skip_subprojects: str
+ tags: str
+
+
symlink_warning = '''Warning: trying to copy a symlink that points to a file. This will copy the file,
but this will be changed in a future version of Meson to copy the symlink as is. Please update your
build definitions so that it will not break when the change happens.'''
-selinux_updates = []
+selinux_updates: T.List[str] = []
-def add_arguments(parser):
- parser.add_argument('-C', default='.', dest='wd',
+def add_arguments(parser: argparse.ArgumentParser) -> None:
+ parser.add_argument('-C', dest='wd', action=RealPathAction,
help='directory to cd into before running')
+ parser.add_argument('--profile-self', action='store_true', dest='profile',
+ help=argparse.SUPPRESS)
parser.add_argument('--no-rebuild', default=False, action='store_true',
help='Do not rebuild before installing.')
parser.add_argument('--only-changed', default=False, action='store_true',
help='Only overwrite files that are older than the copied file.')
+ parser.add_argument('--quiet', default=False, action='store_true',
+ help='Do not print every file that was installed.')
+ parser.add_argument('--destdir', default=None,
+ help='Sets or overrides DESTDIR environment. (Since 0.57.0)')
+ parser.add_argument('--dry-run', '-n', action='store_true',
+ help='Doesn\'t actually install, but print logs. (Since 0.57.0)')
+ parser.add_argument('--skip-subprojects', nargs='?', const='*', default='',
+ help='Do not install files from given subprojects. (Since 0.58.0)')
+ parser.add_argument('--tags', default=None,
+ help='Install only targets having one of the given tags. (Since 0.60.0)')
class DirMaker:
- def __init__(self, lf):
+ def __init__(self, lf: T.TextIO, makedirs: T.Callable[..., None]):
self.lf = lf
- self.dirs = []
+ self.dirs: T.List[str] = []
+ self.all_dirs: T.Set[str] = set()
+ self.makedirs_impl = makedirs
- def makedirs(self, path, exist_ok=False):
+ def makedirs(self, path: str, exist_ok: bool = False) -> None:
dirname = os.path.normpath(path)
+ self.all_dirs.add(dirname)
dirs = []
while dirname != os.path.dirname(dirname):
+ if dirname in self.dirs:
+ # In dry-run mode the directory does not exist but we would have
+ # created it with all its parents otherwise.
+ break
if not os.path.exists(dirname):
dirs.append(dirname)
dirname = os.path.dirname(dirname)
- os.makedirs(path, exist_ok=exist_ok)
+ self.makedirs_impl(path, exist_ok=exist_ok)
# store the directories in creation order, with the parent directory
# before the child directories. Future calls of makedir() will not
@@ -62,25 +119,30 @@
dirs.reverse()
self.dirs += dirs
- def __enter__(self):
+ def __enter__(self) -> 'DirMaker':
return self
- def __exit__(self, exception_type, value, traceback):
+ def __exit__(self, exception_type: T.Type[Exception], value: T.Any, traceback: T.Any) -> None:
self.dirs.reverse()
for d in self.dirs:
append_to_log(self.lf, d)
-def is_executable(path, follow_symlinks=False):
+
+def is_executable(path: str, follow_symlinks: bool = False) -> bool:
'''Checks whether any of the "x" bits are set in the source file mode.'''
return bool(os.stat(path, follow_symlinks=follow_symlinks).st_mode & 0o111)
-def append_to_log(lf, line):
+
+def append_to_log(lf: T.TextIO, line: str) -> None:
lf.write(line)
if not line.endswith('\n'):
lf.write('\n')
lf.flush()
-def set_chown(path, user=None, group=None, dir_fd=None, follow_symlinks=True):
+
+def set_chown(path: str, user: T.Union[str, int, None] = None,
+ group: T.Union[str, int, None] = None,
+ dir_fd: T.Optional[int] = None, follow_symlinks: bool = True) -> None:
# shutil.chown will call os.chown without passing all the parameters
# and particularly follow_symlinks, thus we replace it temporary
# with a lambda with all the parameters so that follow_symlinks will
@@ -88,53 +150,63 @@
# Not nice, but better than actually rewriting shutil.chown until
# this python bug is fixed: https://bugs.python.org/issue18108
real_os_chown = os.chown
+
+ def chown(path: T.Union[int, str, 'os.PathLike[str]', bytes, 'os.PathLike[bytes]'],
+ uid: int, gid: int, *, dir_fd: T.Optional[int] = dir_fd,
+ follow_symlinks: bool = follow_symlinks) -> None:
+ """Override the default behavior of os.chown
+
+ Use a real function rather than a lambda to help mypy out. Also real
+ functions are faster.
+ """
+ real_os_chown(path, uid, gid, dir_fd=dir_fd, follow_symlinks=follow_symlinks)
+
try:
- os.chown = lambda p, u, g: real_os_chown(p, u, g,
- dir_fd=dir_fd,
- follow_symlinks=follow_symlinks)
+ os.chown = chown
shutil.chown(path, user, group)
- except Exception:
- raise
finally:
os.chown = real_os_chown
-def set_chmod(path, mode, dir_fd=None, follow_symlinks=True):
+
+def set_chmod(path: str, mode: int, dir_fd: T.Optional[int] = None,
+ follow_symlinks: bool = True) -> None:
try:
os.chmod(path, mode, dir_fd=dir_fd, follow_symlinks=follow_symlinks)
except (NotImplementedError, OSError, SystemError):
if not os.path.islink(path):
os.chmod(path, mode, dir_fd=dir_fd)
-def sanitize_permissions(path, umask):
+
+def sanitize_permissions(path: str, umask: T.Union[str, int]) -> None:
+ # TODO: with python 3.8 or typing_extensions we could replace this with
+ # `umask: T.Union[T.Literal['preserve'], int]`, which would be more correct
if umask == 'preserve':
return
+ assert isinstance(umask, int), 'umask should only be "preserver" or an integer'
new_perms = 0o777 if is_executable(path, follow_symlinks=False) else 0o666
new_perms &= ~umask
try:
set_chmod(path, new_perms, follow_symlinks=False)
except PermissionError as e:
- msg = '{!r}: Unable to set permissions {!r}: {}, ignoring...'
- print(msg.format(path, new_perms, e.strerror))
+ print(f'{path!r}: Unable to set permissions {new_perms!r}: {e.strerror}, ignoring...')
+
-def set_mode(path, mode, default_umask):
- if mode is None or (mode.perms_s or mode.owner or mode.group) is None:
+def set_mode(path: str, mode: T.Optional['FileMode'], default_umask: T.Union[str, int]) -> None:
+ if mode is None or all(m is None for m in [mode.perms_s, mode.owner, mode.group]):
# Just sanitize permissions with the default umask
sanitize_permissions(path, default_umask)
return
# No chown() on Windows, and must set one of owner/group
- if not is_windows() and (mode.owner or mode.group) is not None:
+ if not is_windows() and (mode.owner is not None or mode.group is not None):
try:
set_chown(path, mode.owner, mode.group, follow_symlinks=False)
except PermissionError as e:
- msg = '{!r}: Unable to set owner {!r} and group {!r}: {}, ignoring...'
- print(msg.format(path, mode.owner, mode.group, e.strerror))
+ print(f'{path!r}: Unable to set owner {mode.owner!r} and group {mode.group!r}: {e.strerror}, ignoring...')
except LookupError:
- msg = '{!r}: Non-existent owner {!r} or group {!r}: ignoring...'
- print(msg.format(path, mode.owner, mode.group))
+ print(f'{path!r}: Non-existent owner {mode.owner!r} or group {mode.group!r}: ignoring...')
except OSError as e:
if e.errno == errno.EINVAL:
- msg = '{!r}: Non-existent numeric owner {!r} or group {!r}: ignoring...'
- print(msg.format(path, mode.owner, mode.group))
+ print(f'{path!r}: Non-existent numeric owner {mode.owner!r} or group {mode.group!r}: ignoring...')
else:
raise
# Must set permissions *after* setting owner/group otherwise the
@@ -144,12 +216,12 @@
try:
set_chmod(path, mode.perms, follow_symlinks=False)
except PermissionError as e:
- msg = '{!r}: Unable to set permissions {!r}: {}, ignoring...'
- print(msg.format(path, mode.perms_s, e.strerror))
+ print('{path!r}: Unable to set permissions {mode.perms_s!r}: {e.strerror}, ignoring...')
else:
sanitize_permissions(path, default_umask)
-def restore_selinux_contexts():
+
+def restore_selinux_contexts() -> None:
'''
Restores the SELinux context for files in @selinux_updates
@@ -166,24 +238,60 @@
# If we don't have restorecon, failure is ignored quietly.
return
- with subprocess.Popen(['restorecon', '-F', '-f-', '-0'],
- stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) as proc:
- out, err = proc.communicate(input=b'\0'.join(os.fsencode(f) for f in selinux_updates) + b'\0')
- if proc.returncode != 0 and not os.environ.get('DESTDIR'):
- print('Failed to restore SELinux context of installed files...',
- 'Standard output:', out.decode(),
- 'Standard error:', err.decode(), sep='\n')
+ if not selinux_updates:
+ # If the list of files is empty, do not try to call restorecon.
+ return
+
+ proc, out, err = Popen_safe(['restorecon', '-F', '-f-', '-0'], ('\0'.join(f for f in selinux_updates) + '\0'))
+ if proc.returncode != 0:
+ print('Failed to restore SELinux context of installed files...',
+ 'Standard output:', out,
+ 'Standard error:', err, sep='\n')
+
+def apply_ldconfig(dm: DirMaker, libdir: str) -> None:
+ '''
+ Apply ldconfig to update the ld.so.cache.
+ '''
+ if not shutil.which('ldconfig'):
+ # If we don't have ldconfig, failure is ignored quietly.
+ return
+
+ platlower = platform.system().lower()
+ if platlower == 'dragonfly' or 'bsd' in platlower:
+ if libdir in dm.all_dirs:
+ proc, out, err = Popen_safe(['ldconfig', '-m', libdir])
+ if proc.returncode != 0:
+ print('Failed to apply ldconfig ...',
+ 'Standard output:', out,
+ 'Standard error:', err, sep='\n')
+ return
+
+ # Try to update ld cache, it could fail if we don't have permission.
+ proc, out, err = Popen_safe(['ldconfig', '-v'])
+ if proc.returncode == 0:
+ return
+ # ldconfig failed, print the error only if we actually installed files in
+ # any of the directories it lookup for libraries. Otherwise quietly ignore
+ # the error.
+ for l in out.splitlines():
+ # Lines that start with a \t are libraries, not directories.
+ if not l or l[0].isspace():
+ continue
+ # Example: `/usr/lib/i386-linux-gnu/i686: (hwcap: 0x0002000000000000)`
+ if l[:l.find(':')] in dm.all_dirs:
+ print(f'Failed to apply ldconfig:\n{err}')
+ break
-def get_destdir_path(d, path):
+def get_destdir_path(destdir: str, fullprefix: str, path: str) -> str:
if os.path.isabs(path):
- output = destdir_join(d.destdir, path)
+ output = destdir_join(destdir, path)
else:
- output = os.path.join(d.fullprefix, path)
+ output = os.path.join(fullprefix, path)
return output
-def check_for_stampfile(fname):
+def check_for_stampfile(fname: str) -> str:
'''Some languages e.g. Rust have output files
whose names are not known at configure time.
Check if this is the case and return the real
@@ -208,14 +316,104 @@
return files[0]
return fname
+
class Installer:
- def __init__(self, options, lf):
+ def __init__(self, options: 'ArgumentType', lf: T.TextIO):
self.did_install_something = False
+ self.printed_symlink_error = False
self.options = options
self.lf = lf
+ self.preserved_file_count = 0
+ self.dry_run = options.dry_run
+ # [''] means skip none,
+ # ['*'] means skip all,
+ # ['sub1', ...] means skip only those.
+ self.skip_subprojects = [i.strip() for i in options.skip_subprojects.split(',')]
+ self.tags = [i.strip() for i in options.tags.split(',')] if options.tags else None
+
+ def remove(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ os.remove(*args, **kwargs)
+
+ def symlink(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ os.symlink(*args, **kwargs)
+
+ def makedirs(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ os.makedirs(*args, **kwargs)
+
+ def copy(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ shutil.copy(*args, **kwargs)
+
+ def copy2(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ shutil.copy2(*args, **kwargs)
+
+ def copyfile(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ shutil.copyfile(*args, **kwargs)
+
+ def copystat(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ shutil.copystat(*args, **kwargs)
+
+ def fix_rpath(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ depfixer.fix_rpath(*args, **kwargs)
+
+ def set_chown(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ set_chown(*args, **kwargs)
+
+ def set_chmod(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ set_chmod(*args, **kwargs)
+
+ def sanitize_permissions(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ sanitize_permissions(*args, **kwargs)
+
+ def set_mode(self, *args: T.Any, **kwargs: T.Any) -> None:
+ if not self.dry_run:
+ set_mode(*args, **kwargs)
+
+ def restore_selinux_contexts(self, destdir: str) -> None:
+ if not self.dry_run and not destdir:
+ restore_selinux_contexts()
+
+ def apply_ldconfig(self, dm: DirMaker, destdir: str, is_cross_build: bool, libdir: str) -> None:
+ if any([self.dry_run, destdir, is_cross_build]):
+ return
+ apply_ldconfig(dm, libdir)
+
+ def Popen_safe(self, *args: T.Any, **kwargs: T.Any) -> T.Tuple[int, str, str]:
+ if not self.dry_run:
+ p, o, e = Popen_safe(*args, **kwargs)
+ return p.returncode, o, e
+ return 0, '', ''
+
+ def run_exe(self, *args: T.Any, **kwargs: T.Any) -> int:
+ if not self.dry_run:
+ return run_exe(*args, **kwargs)
+ return 0
+
+ def should_install(self, d: T.Union[TargetInstallData, InstallEmptyDir,
+ InstallDataBase, InstallSymlinkData,
+ ExecutableSerialisation]) -> bool:
+ if d.subproject and (d.subproject in self.skip_subprojects or '*' in self.skip_subprojects):
+ return False
+ if self.tags and d.tag not in self.tags:
+ return False
+ return True
+
+ def log(self, msg: str) -> None:
+ if not self.options.quiet:
+ print(msg)
- def should_preserve_existing_file(self, from_file, to_file):
+ def should_preserve_existing_file(self, from_file: str, to_file: str) -> bool:
if not self.options.only_changed:
return False
# Always replace danging symlinks
@@ -225,42 +423,69 @@
to_time = os.stat(to_file).st_mtime
return from_time <= to_time
- def do_copyfile(self, from_file, to_file):
+ def do_copyfile(self, from_file: str, to_file: str,
+ makedirs: T.Optional[T.Tuple[T.Any, str]] = None) -> bool:
outdir = os.path.split(to_file)[0]
if not os.path.isfile(from_file) and not os.path.islink(from_file):
- raise RuntimeError('Tried to install something that isn\'t a file:'
- '{!r}'.format(from_file))
+ raise MesonException(f'Tried to install something that isn\'t a file: {from_file!r}')
# copyfile fails if the target file already exists, so remove it to
# allow overwriting a previous install. If the target is not a file, we
# want to give a readable error.
if os.path.exists(to_file):
if not os.path.isfile(to_file):
- raise RuntimeError('Destination {!r} already exists and is not '
- 'a file'.format(to_file))
+ raise MesonException(f'Destination {to_file!r} already exists and is not a file')
if self.should_preserve_existing_file(from_file, to_file):
- append_to_log(self.lf, '# Preserving old file %s\n' % to_file)
- print('Preserving existing file %s' % to_file)
+ append_to_log(self.lf, f'# Preserving old file {to_file}\n')
+ self.preserved_file_count += 1
return False
- os.remove(to_file)
- print('Installing %s to %s' % (from_file, outdir))
+ self.remove(to_file)
+ elif makedirs:
+ # Unpack tuple
+ dirmaker, outdir = makedirs
+ # Create dirs if needed
+ dirmaker.makedirs(outdir, exist_ok=True)
+ self.log(f'Installing {from_file} to {outdir}')
if os.path.islink(from_file):
if not os.path.exists(from_file):
# Dangling symlink. Replicate as is.
- shutil.copy(from_file, outdir, follow_symlinks=False)
+ self.copy(from_file, outdir, follow_symlinks=False)
else:
# Remove this entire branch when changing the behaviour to duplicate
# symlinks rather than copying what they point to.
print(symlink_warning)
- shutil.copyfile(from_file, to_file)
- shutil.copystat(from_file, to_file)
+ self.copy2(from_file, to_file)
else:
- shutil.copyfile(from_file, to_file)
- shutil.copystat(from_file, to_file)
+ self.copy2(from_file, to_file)
selinux_updates.append(to_file)
append_to_log(self.lf, to_file)
return True
- def do_copydir(self, data, src_dir, dst_dir, exclude, install_mode):
+ def do_symlink(self, target: str, link: str, full_dst_dir: str) -> bool:
+ abs_target = target
+ if not os.path.isabs(target):
+ abs_target = os.path.join(full_dst_dir, target)
+ if not os.path.exists(abs_target):
+ raise MesonException(f'Tried to install symlink to missing file {abs_target}')
+ if os.path.exists(link):
+ if not os.path.islink(link):
+ raise MesonException(f'Destination {link!r} already exists and is not a symlink')
+ self.remove(link)
+ if not self.printed_symlink_error:
+ self.log(f'Installing symlink pointing to {target} to {link}')
+ try:
+ self.symlink(target, link, target_is_directory=os.path.isdir(abs_target))
+ except (NotImplementedError, OSError):
+ if not self.printed_symlink_error:
+ print("Symlink creation does not work on this platform. "
+ "Skipping all symlinking.")
+ self.printed_symlink_error = True
+ return False
+ append_to_log(self.lf, link)
+ return True
+
+ def do_copydir(self, data: InstallData, src_dir: str, dst_dir: str,
+ exclude: T.Optional[T.Tuple[T.Set[str], T.Set[str]]],
+ install_mode: 'FileMode', dm: DirMaker) -> None:
'''
Copies the contents of directory @src_dir into @dst_dir.
@@ -284,9 +509,9 @@
each element of the set is a path relative to src_dir.
'''
if not os.path.isabs(src_dir):
- raise ValueError('src_dir must be absolute, got %s' % src_dir)
+ raise ValueError(f'src_dir must be absolute, got {src_dir}')
if not os.path.isabs(dst_dir):
- raise ValueError('dst_dir must be absolute, got %s' % dst_dir)
+ raise ValueError(f'dst_dir must be absolute, got {dst_dir}')
if exclude is not None:
exclude_files, exclude_dirs = exclude
else:
@@ -304,11 +529,11 @@
if os.path.isdir(abs_dst):
continue
if os.path.exists(abs_dst):
- print('Tried to copy directory %s but a file of that name already exists.' % abs_dst)
+ print(f'Tried to copy directory {abs_dst} but a file of that name already exists.')
sys.exit(1)
- data.dirmaker.makedirs(abs_dst)
- shutil.copystat(abs_src, abs_dst)
- sanitize_permissions(abs_dst, data.install_umask)
+ dm.makedirs(abs_dst)
+ self.copystat(abs_src, abs_dst)
+ self.sanitize_permissions(abs_dst, data.install_umask)
for f in files:
abs_src = os.path.join(root, f)
filepart = os.path.relpath(abs_src, start=src_dir)
@@ -316,39 +541,65 @@
continue
abs_dst = os.path.join(dst_dir, filepart)
if os.path.isdir(abs_dst):
- print('Tried to copy file %s but a directory of that name already exists.' % abs_dst)
+ print(f'Tried to copy file {abs_dst} but a directory of that name already exists.')
+ sys.exit(1)
parent_dir = os.path.dirname(abs_dst)
if not os.path.isdir(parent_dir):
- os.mkdir(parent_dir)
- shutil.copystat(os.path.dirname(abs_src), parent_dir)
+ dm.makedirs(parent_dir)
+ self.copystat(os.path.dirname(abs_src), parent_dir)
# FIXME: what about symlinks?
self.do_copyfile(abs_src, abs_dst)
- set_mode(abs_dst, install_mode, data.install_umask)
+ self.set_mode(abs_dst, install_mode, data.install_umask)
- def do_install(self, datafilename):
+ @staticmethod
+ def check_installdata(obj: InstallData) -> InstallData:
+ if not isinstance(obj, InstallData) or not hasattr(obj, 'version'):
+ raise MesonVersionMismatchException('', coredata_version)
+ if major_versions_differ(obj.version, coredata_version):
+ raise MesonVersionMismatchException(obj.version, coredata_version)
+ return obj
+
+ def do_install(self, datafilename: str) -> None:
with open(datafilename, 'rb') as ifile:
- d = pickle.load(ifile)
- d.destdir = os.environ.get('DESTDIR', '')
- d.fullprefix = destdir_join(d.destdir, d.prefix)
+ d = self.check_installdata(pickle.load(ifile))
+
+ destdir = self.options.destdir
+ if destdir is None:
+ destdir = os.environ.get('DESTDIR')
+ if destdir and not os.path.isabs(destdir):
+ destdir = os.path.join(d.build_dir, destdir)
+ # Override in the env because some scripts could use it and require an
+ # absolute path.
+ if destdir is not None:
+ os.environ['DESTDIR'] = destdir
+ destdir = destdir or ''
+ fullprefix = destdir_join(destdir, d.prefix)
+ libdir = os.path.join(d.prefix, d.libdir)
if d.install_umask != 'preserve':
+ assert isinstance(d.install_umask, int)
os.umask(d.install_umask)
self.did_install_something = False
try:
- d.dirmaker = DirMaker(self.lf)
- with d.dirmaker:
- self.install_subdirs(d) # Must be first, because it needs to delete the old subtree.
- self.install_targets(d)
- self.install_headers(d)
- self.install_man(d)
- self.install_data(d)
- restore_selinux_contexts()
- self.run_install_script(d)
+ with DirMaker(self.lf, self.makedirs) as dm:
+ self.install_subdirs(d, dm, destdir, fullprefix) # Must be first, because it needs to delete the old subtree.
+ self.install_targets(d, dm, destdir, fullprefix)
+ self.install_headers(d, dm, destdir, fullprefix)
+ self.install_man(d, dm, destdir, fullprefix)
+ self.install_emptydir(d, dm, destdir, fullprefix)
+ self.install_data(d, dm, destdir, fullprefix)
+ self.install_symlinks(d, dm, destdir, fullprefix)
+ self.restore_selinux_contexts(destdir)
+ self.apply_ldconfig(dm, destdir, d.is_cross_build, libdir)
+ self.run_install_script(d, destdir, fullprefix)
if not self.did_install_something:
- print('Nothing to install.')
+ self.log('Nothing to install.')
+ if not self.options.quiet and self.preserved_file_count > 0:
+ self.log('Preserved {} unchanged files, see {} for the full list'
+ .format(self.preserved_file_count, os.path.normpath(self.lf.name)))
except PermissionError:
- if shutil.which('pkexec') is not None and 'PKEXEC_UID' not in os.environ:
+ if shutil.which('pkexec') is not None and 'PKEXEC_UID' not in os.environ and destdir == '':
print('Installation failed due to insufficient permissions.')
print('Attempting to use polkit to gain elevated privileges...')
os.execlp('pkexec', 'pkexec', sys.executable, main_file, *sys.argv[1:],
@@ -356,85 +607,116 @@
else:
raise
- def install_subdirs(self, d):
- for (src_dir, dst_dir, mode, exclude) in d.install_subdirs:
+ def install_subdirs(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
+ for i in d.install_subdirs:
+ if not self.should_install(i):
+ continue
self.did_install_something = True
- full_dst_dir = get_destdir_path(d, dst_dir)
- print('Installing subdir %s to %s' % (src_dir, full_dst_dir))
- d.dirmaker.makedirs(full_dst_dir, exist_ok=True)
- self.do_copydir(d, src_dir, full_dst_dir, exclude, mode)
+ full_dst_dir = get_destdir_path(destdir, fullprefix, i.install_path)
+ self.log(f'Installing subdir {i.path} to {full_dst_dir}')
+ dm.makedirs(full_dst_dir, exist_ok=True)
+ self.do_copydir(d, i.path, full_dst_dir, i.exclude, i.install_mode, dm)
- def install_data(self, d):
+ def install_data(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
for i in d.data:
- self.did_install_something = True
- fullfilename = i[0]
- outfilename = get_destdir_path(d, i[1])
- mode = i[2]
+ if not self.should_install(i):
+ continue
+ fullfilename = i.path
+ outfilename = get_destdir_path(destdir, fullprefix, i.install_path)
outdir = os.path.dirname(outfilename)
- d.dirmaker.makedirs(outdir, exist_ok=True)
- self.do_copyfile(fullfilename, outfilename)
- set_mode(outfilename, mode, d.install_umask)
+ if self.do_copyfile(fullfilename, outfilename, makedirs=(dm, outdir)):
+ self.did_install_something = True
+ self.set_mode(outfilename, i.install_mode, d.install_umask)
+
+ def install_symlinks(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
+ for s in d.symlinks:
+ if not self.should_install(s):
+ continue
+ full_dst_dir = get_destdir_path(destdir, fullprefix, s.install_path)
+ full_link_name = get_destdir_path(destdir, fullprefix, s.name)
+ dm.makedirs(full_dst_dir, exist_ok=True)
+ if self.do_symlink(s.target, full_link_name, full_dst_dir):
+ self.did_install_something = True
- def install_man(self, d):
+ def install_man(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
for m in d.man:
- self.did_install_something = True
- full_source_filename = m[0]
- outfilename = get_destdir_path(d, m[1])
+ if not self.should_install(m):
+ continue
+ full_source_filename = m.path
+ outfilename = get_destdir_path(destdir, fullprefix, m.install_path)
outdir = os.path.dirname(outfilename)
- d.dirmaker.makedirs(outdir, exist_ok=True)
- install_mode = m[2]
- self.do_copyfile(full_source_filename, outfilename)
- set_mode(outfilename, install_mode, d.install_umask)
+ if self.do_copyfile(full_source_filename, outfilename, makedirs=(dm, outdir)):
+ self.did_install_something = True
+ self.set_mode(outfilename, m.install_mode, d.install_umask)
+
+ def install_emptydir(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
+ for e in d.emptydir:
+ if not self.should_install(e):
+ continue
+ self.did_install_something = True
+ full_dst_dir = get_destdir_path(destdir, fullprefix, e.path)
+ self.log(f'Installing new directory {full_dst_dir}')
+ if os.path.isfile(full_dst_dir):
+ print(f'Tried to create directory {full_dst_dir} but a file of that name already exists.')
+ sys.exit(1)
+ dm.makedirs(full_dst_dir, exist_ok=True)
+ self.set_mode(full_dst_dir, e.install_mode, d.install_umask)
- def install_headers(self, d):
+ def install_headers(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
for t in d.headers:
- self.did_install_something = True
- fullfilename = t[0]
+ if not self.should_install(t):
+ continue
+ fullfilename = t.path
fname = os.path.basename(fullfilename)
- outdir = get_destdir_path(d, t[1])
+ outdir = get_destdir_path(destdir, fullprefix, t.install_path)
outfilename = os.path.join(outdir, fname)
- install_mode = t[2]
- d.dirmaker.makedirs(outdir, exist_ok=True)
- self.do_copyfile(fullfilename, outfilename)
- set_mode(outfilename, install_mode, d.install_umask)
+ if self.do_copyfile(fullfilename, outfilename, makedirs=(dm, outdir)):
+ self.did_install_something = True
+ self.set_mode(outfilename, t.install_mode, d.install_umask)
- def run_install_script(self, d):
+ def run_install_script(self, d: InstallData, destdir: str, fullprefix: str) -> None:
env = {'MESON_SOURCE_ROOT': d.source_dir,
'MESON_BUILD_ROOT': d.build_dir,
'MESON_INSTALL_PREFIX': d.prefix,
- 'MESON_INSTALL_DESTDIR_PREFIX': d.fullprefix,
+ 'MESON_INSTALL_DESTDIR_PREFIX': fullprefix,
'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in d.mesonintrospect]),
}
-
- child_env = os.environ.copy()
- child_env.update(env)
+ if self.options.quiet:
+ env['MESON_INSTALL_QUIET'] = '1'
for i in d.install_scripts:
+ if not self.should_install(i):
+ continue
+ name = ' '.join(i.cmd_args)
+ if i.skip_if_destdir and destdir:
+ self.log(f'Skipping custom install script because DESTDIR is set {name!r}')
+ continue
self.did_install_something = True # Custom script must report itself if it does nothing.
- script = i['exe']
- args = i['args']
- name = ' '.join(script + args)
- print('Running custom install script {!r}'.format(name))
+ self.log(f'Running custom install script {name!r}')
try:
- rc = subprocess.call(script + args, env=child_env)
- if rc != 0:
- sys.exit(rc)
+ rc = self.run_exe(i, env)
except OSError:
- print('Failed to run install script {!r}'.format(name))
- sys.exit(1)
+ print(f'FAILED: install script \'{name}\' could not be run, stopped')
+ # POSIX shells return 127 when a command could not be found
+ sys.exit(127)
+ if rc != 0:
+ print(f'FAILED: install script \'{name}\' exit code {rc}, stopped')
+ sys.exit(rc)
- def install_targets(self, d):
+ def install_targets(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:
for t in d.targets:
- self.did_install_something = True
+ if not self.should_install(t):
+ continue
if not os.path.exists(t.fname):
# For example, import libraries of shared modules are optional
if t.optional:
- print('File {!r} not found, skipping'.format(t.fname))
+ self.log(f'File {t.fname!r} not found, skipping')
continue
else:
- raise RuntimeError('File {!r} could not be found'.format(t.fname))
+ raise MesonException(f'File {t.fname!r} could not be found')
+ file_copied = False # not set when a directory is copied
fname = check_for_stampfile(t.fname)
- outdir = get_destdir_path(d, t.outdir)
+ outdir = get_destdir_path(destdir, fullprefix, t.outdir)
outname = os.path.join(outdir, os.path.basename(fname))
final_path = os.path.join(d.prefix, t.outdir, os.path.basename(fname))
aliases = t.aliases
@@ -442,22 +724,21 @@
install_rpath = t.install_rpath
install_name_mappings = t.install_name_mappings
install_mode = t.install_mode
- d.dirmaker.makedirs(outdir, exist_ok=True)
if not os.path.exists(fname):
- raise RuntimeError('File {!r} could not be found'.format(fname))
+ raise MesonException(f'File {fname!r} could not be found')
elif os.path.isfile(fname):
- self.do_copyfile(fname, outname)
- set_mode(outname, install_mode, d.install_umask)
+ file_copied = self.do_copyfile(fname, outname, makedirs=(dm, outdir))
+ self.set_mode(outname, install_mode, d.install_umask)
if should_strip and d.strip_bin is not None:
if fname.endswith('.jar'):
- print('Not stripping jar target:', os.path.basename(fname))
+ self.log('Not stripping jar target: {}'.format(os.path.basename(fname)))
continue
- print('Stripping target {!r} using {}.'.format(fname, d.strip_bin[0]))
- ps, stdo, stde = Popen_safe(d.strip_bin + [outname])
- if ps.returncode != 0:
+ self.log('Stripping target {!r} using {}.'.format(fname, d.strip_bin[0]))
+ returncode, stdo, stde = self.Popen_safe(d.strip_bin + [outname])
+ if returncode != 0:
print('Could not strip file.\n')
- print('Stdout:\n%s\n' % stdo)
- print('Stderr:\n%s\n' % stde)
+ print(f'Stdout:\n{stdo}\n')
+ print(f'Stderr:\n{stde}\n')
sys.exit(1)
if fname.endswith('.js'):
# Emscripten outputs js files and optionally a wasm file.
@@ -465,51 +746,67 @@
wasm_source = os.path.splitext(fname)[0] + '.wasm'
if os.path.exists(wasm_source):
wasm_output = os.path.splitext(outname)[0] + '.wasm'
- self.do_copyfile(wasm_source, wasm_output)
+ file_copied = self.do_copyfile(wasm_source, wasm_output)
elif os.path.isdir(fname):
fname = os.path.join(d.build_dir, fname.rstrip('/'))
outname = os.path.join(outdir, os.path.basename(fname))
- self.do_copydir(d, fname, outname, None, install_mode)
+ dm.makedirs(outdir, exist_ok=True)
+ self.do_copydir(d, fname, outname, None, install_mode, dm)
else:
- raise RuntimeError('Unknown file type for {!r}'.format(fname))
- printed_symlink_error = False
- for alias, to in aliases.items():
+ raise RuntimeError(f'Unknown file type for {fname!r}')
+ for alias, target in aliases.items():
+ symlinkfilename = os.path.join(outdir, alias)
+ self.do_symlink(target, symlinkfilename, outdir)
+ if file_copied:
+ self.did_install_something = True
try:
- symlinkfilename = os.path.join(outdir, alias)
- try:
- os.remove(symlinkfilename)
- except FileNotFoundError:
- pass
- os.symlink(to, symlinkfilename)
- append_to_log(self.lf, symlinkfilename)
- except (NotImplementedError, OSError):
- if not printed_symlink_error:
- print("Symlink creation does not work on this platform. "
- "Skipping all symlinking.")
- printed_symlink_error = True
- if os.path.isfile(outname):
- try:
- depfixer.fix_rpath(outname, install_rpath, final_path,
- install_name_mappings, verbose=False)
+ self.fix_rpath(outname, t.rpath_dirs_to_remove, install_rpath, final_path,
+ install_name_mappings, verbose=False)
except SystemExit as e:
if isinstance(e.code, int) and e.code == 0:
pass
else:
raise
-def run(opts):
+
+def rebuild_all(wd: str) -> bool:
+ if not (Path(wd) / 'build.ninja').is_file():
+ print('Only ninja backend is supported to rebuild the project before installation.')
+ return True
+
+ ninja = environment.detect_ninja()
+ if not ninja:
+ print("Can't find ninja, can't rebuild test.")
+ return False
+
+ ret = subprocess.run(ninja + ['-C', wd]).returncode
+ if ret != 0:
+ print(f'Could not rebuild {wd}')
+ return False
+
+ return True
+
+
+def run(opts: 'ArgumentType') -> int:
datafilename = 'meson-private/install.dat'
private_dir = os.path.dirname(datafilename)
log_dir = os.path.join(private_dir, '../meson-logs')
if not os.path.exists(os.path.join(opts.wd, datafilename)):
sys.exit('Install data not found. Run this command in build directory root.')
if not opts.no_rebuild:
+ b = build.load(opts.wd)
+ setup_vsenv(b.need_vsenv)
if not rebuild_all(opts.wd):
sys.exit(-1)
os.chdir(opts.wd)
- with open(os.path.join(log_dir, 'install-log.txt'), 'w') as lf:
+ with open(os.path.join(log_dir, 'install-log.txt'), 'w', encoding='utf-8') as lf:
installer = Installer(opts, lf)
append_to_log(lf, '# List of files installed by Meson')
append_to_log(lf, '# Does not contain files installed by custom scripts.')
- installer.do_install(datafilename)
+ if opts.profile:
+ import cProfile as profile
+ fname = os.path.join(private_dir, 'profile-installer.log')
+ profile.runctx('installer.do_install(datafilename)', globals(), locals(), filename=fname)
+ else:
+ installer.do_install(datafilename)
return 0
diff -Nru meson-0.53.2/mesonbuild/mintro.py meson-0.61.2/mesonbuild/mintro.py
--- meson-0.53.2/mesonbuild/mintro.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/mintro.py 2021-11-02 19:58:07.000000000 +0000
@@ -19,16 +19,21 @@
Currently only works for the Ninja backend. Others use generated
project files and don't need this info."""
+import collections
import json
from . import build, coredata as cdata
from . import mesonlib
-from .ast import IntrospectionInterpreter, build_target_functions, AstConditionLevel, AstIDGenerator, AstIndentationGenerator
+from .ast import IntrospectionInterpreter, build_target_functions, AstConditionLevel, AstIDGenerator, AstIndentationGenerator, AstJSONPrinter
from . import mlog
from .backend import backends
-from .mparser import FunctionNode, ArrayNode, ArgumentNode, StringNode
+from .mparser import BaseNode, FunctionNode, ArrayNode, ArgumentNode, StringNode
+from .interpreter import Interpreter
+from pathlib import Path, PurePath
import typing as T
import os
-import pathlib
+import argparse
+
+from .mesonlib import OptionKey
def get_meson_info_file(info_dir: str) -> str:
return os.path.join(info_dir, 'meson-info.json')
@@ -51,33 +56,37 @@
def get_meson_introspection_types(coredata: T.Optional[cdata.CoreData] = None,
builddata: T.Optional[build.Build] = None,
backend: T.Optional[backends.Backend] = None,
- sourcedir: T.Optional[str] = None) -> T.Dict[str, IntroCommand]:
+ sourcedir: T.Optional[str] = None) -> 'T.Mapping[str, IntroCommand]':
if backend and builddata:
benchmarkdata = backend.create_test_serialisation(builddata.get_benchmarks())
testdata = backend.create_test_serialisation(builddata.get_tests())
installdata = backend.create_install_data()
+ interpreter = backend.interpreter
else:
benchmarkdata = testdata = installdata = None
- return {
- 'benchmarks': IntroCommand('T.List all benchmarks', func=lambda: list_benchmarks(benchmarkdata)),
- 'buildoptions': IntroCommand('T.List all build options', func=lambda: list_buildoptions(coredata), no_bd=list_buildoptions_from_source),
- 'buildsystem_files': IntroCommand('T.List files that make up the build system', func=lambda: list_buildsystem_files(builddata)),
- 'dependencies': IntroCommand('T.List external dependencies', func=lambda: list_deps(coredata), no_bd=list_deps_from_source),
- 'scan_dependencies': IntroCommand('Scan for dependencies used in the meson.build file', no_bd=list_deps_from_source),
- 'installed': IntroCommand('T.List all installed files and directories', func=lambda: list_installed(installdata)),
- 'projectinfo': IntroCommand('Information about projects', func=lambda: list_projinfo(builddata), no_bd=list_projinfo_from_source),
- 'targets': IntroCommand('T.List top level targets', func=lambda: list_targets(builddata, installdata, backend), no_bd=list_targets_from_source),
- 'tests': IntroCommand('T.List all unit tests', func=lambda: list_tests(testdata)),
- }
+ # Enforce key order for argparse
+ return collections.OrderedDict([
+ ('ast', IntroCommand('Dump the AST of the meson file', no_bd=dump_ast)),
+ ('benchmarks', IntroCommand('List all benchmarks', func=lambda: list_benchmarks(benchmarkdata))),
+ ('buildoptions', IntroCommand('List all build options', func=lambda: list_buildoptions(coredata), no_bd=list_buildoptions_from_source)),
+ ('buildsystem_files', IntroCommand('List files that make up the build system', func=lambda: list_buildsystem_files(builddata, interpreter))),
+ ('dependencies', IntroCommand('List external dependencies', func=lambda: list_deps(coredata), no_bd=list_deps_from_source)),
+ ('scan_dependencies', IntroCommand('Scan for dependencies used in the meson.build file', no_bd=list_deps_from_source)),
+ ('installed', IntroCommand('List all installed files and directories', func=lambda: list_installed(installdata))),
+ ('install_plan', IntroCommand('List all installed files and directories with their details', func=lambda: list_install_plan(installdata))),
+ ('projectinfo', IntroCommand('Information about projects', func=lambda: list_projinfo(builddata), no_bd=list_projinfo_from_source)),
+ ('targets', IntroCommand('List top level targets', func=lambda: list_targets(builddata, installdata, backend), no_bd=list_targets_from_source)),
+ ('tests', IntroCommand('List all unit tests', func=lambda: list_tests(testdata))),
+ ])
-def add_arguments(parser):
+def add_arguments(parser: argparse.ArgumentParser) -> None:
intro_types = get_meson_introspection_types()
for key, val in intro_types.items():
flag = '--' + key.replace('_', '-')
parser.add_argument(flag, action='store_true', dest=key, default=False, help=val.desc)
- parser.add_argument('--backend', choices=cdata.backendlist, dest='backend', default='ninja',
+ parser.add_argument('--backend', choices=sorted(cdata.backendlist), dest='backend', default='ninja',
help='The backend to use for the --buildoptions introspection.')
parser.add_argument('-a', '--all', action='store_true', dest='all', default=False,
help='Print all available information.')
@@ -87,28 +96,74 @@
help='Always use the new JSON format for multiple entries (even for 0 and 1 introspection commands)')
parser.add_argument('builddir', nargs='?', default='.', help='The build directory')
-def list_installed(installdata):
+def dump_ast(intr: IntrospectionInterpreter) -> T.Dict[str, T.Any]:
+ printer = AstJSONPrinter()
+ intr.ast.accept(printer)
+ return printer.result
+
+def list_installed(installdata: backends.InstallData) -> T.Dict[str, str]:
res = {}
if installdata is not None:
for t in installdata.targets:
res[os.path.join(installdata.build_dir, t.fname)] = \
os.path.join(installdata.prefix, t.outdir, os.path.basename(t.fname))
- for path, installpath, _ in installdata.data:
- res[path] = os.path.join(installdata.prefix, installpath)
- for path, installdir, _ in installdata.headers:
- res[path] = os.path.join(installdata.prefix, installdir, os.path.basename(path))
- for path, installpath, _ in installdata.man:
- res[path] = os.path.join(installdata.prefix, installpath)
- for path, installpath, _, _ in installdata.install_subdirs:
- res[path] = os.path.join(installdata.prefix, installpath)
+ for alias in t.aliases.keys():
+ res[os.path.join(installdata.build_dir, alias)] = \
+ os.path.join(installdata.prefix, t.outdir, os.path.basename(alias))
+ for i in installdata.data:
+ res[i.path] = os.path.join(installdata.prefix, i.install_path)
+ for i in installdata.headers:
+ res[i.path] = os.path.join(installdata.prefix, i.install_path, os.path.basename(i.path))
+ for i in installdata.man:
+ res[i.path] = os.path.join(installdata.prefix, i.install_path)
+ for i in installdata.install_subdirs:
+ res[i.path] = os.path.join(installdata.prefix, i.install_path)
return res
+def list_install_plan(installdata: backends.InstallData) -> T.Dict[str, T.Dict[str, T.Dict[str, T.Optional[str]]]]:
+ plan = {
+ 'targets': {
+ os.path.join(installdata.build_dir, target.fname): {
+ 'destination': target.out_name,
+ 'tag': target.tag or None,
+ }
+ for target in installdata.targets
+ },
+ } # type: T.Dict[str, T.Dict[str, T.Dict[str, T.Optional[str]]]]
+ for key, data_list in {
+ 'data': installdata.data,
+ 'man': installdata.man,
+ 'headers': installdata.headers,
+ }.items():
+ for data in data_list:
+ data_type = data.data_type or key
+ install_path_name = data.install_path_name
+ if key == 'headers': # in the headers, install_path_name is the directory
+ install_path_name = os.path.join(install_path_name, os.path.basename(data.path))
+ elif data_type == 'configure':
+ install_path_name = os.path.join('{prefix}', install_path_name)
+
+ plan[data_type] = plan.get(data_type, {})
+ plan[data_type][data.path] = {
+ 'destination': install_path_name,
+ 'tag': data.tag or None,
+ }
+ return plan
+
+def get_target_dir(coredata: cdata.CoreData, subdir: str) -> str:
+ if coredata.get_option(OptionKey('layout')) == 'flat':
+ return 'meson-out'
+ else:
+ return subdir
+
def list_targets_from_source(intr: IntrospectionInterpreter) -> T.List[T.Dict[str, T.Union[bool, str, T.List[T.Union[str, T.Dict[str, T.Union[str, T.List[str], bool]]]]]]]:
tlist = [] # type: T.List[T.Dict[str, T.Union[bool, str, T.List[T.Union[str, T.Dict[str, T.Union[str, T.List[str], bool]]]]]]]
- for i in intr.targets:
- sources = [] # type: T.List[str]
- for n in i['sources']:
- args = [] # type: T.List[T.Union[str, StringNode]]
+ root_dir = Path(intr.source_root)
+
+ def nodes_to_paths(node_list: T.List[BaseNode]) -> T.List[Path]:
+ res = [] # type: T.List[Path]
+ for n in node_list:
+ args = [] # type: T.List[BaseNode]
if isinstance(n, FunctionNode):
args = list(n.args.arguments)
if n.func_name in build_target_functions:
@@ -119,95 +174,108 @@
args = n.arguments
for j in args:
if isinstance(j, StringNode):
- sources += [j.value]
+ assert isinstance(j.value, str)
+ res += [Path(j.value)]
elif isinstance(j, str):
- sources += [j]
+ res += [Path(j)]
+ res = [root_dir / i['subdir'] / x for x in res]
+ res = [x.resolve() for x in res]
+ return res
+
+ for i in intr.targets:
+ sources = nodes_to_paths(i['sources'])
+ extra_f = nodes_to_paths(i['extra_files'])
+ outdir = get_target_dir(intr.coredata, i['subdir'])
tlist += [{
'name': i['name'],
'id': i['id'],
'type': i['type'],
'defined_in': i['defined_in'],
- 'filename': [os.path.join(i['subdir'], x) for x in i['outputs']],
+ 'filename': [os.path.join(outdir, x) for x in i['outputs']],
'build_by_default': i['build_by_default'],
'target_sources': [{
'language': 'unknown',
'compiler': [],
'parameters': [],
- 'sources': [os.path.normpath(os.path.join(os.path.abspath(intr.source_root), i['subdir'], x)) for x in sources],
+ 'sources': [str(x) for x in sources],
'generated_sources': []
}],
+ 'extra_files': [str(x) for x in extra_f],
'subproject': None, # Subprojects are not supported
'installed': i['installed']
}]
return tlist
-def list_targets(builddata: build.Build, installdata, backend: backends.Backend) -> T.List[T.Dict[str, T.Union[bool, str, T.List[T.Union[str, T.Dict[str, T.Union[str, T.List[str], bool]]]]]]]:
- tlist = [] # type: T.List[T.Dict[str, T.Union[bool, str, T.List[T.Union[str, T.Dict[str, T.Union[str, T.List[str], bool]]]]]]]
+def list_targets(builddata: build.Build, installdata: backends.InstallData, backend: backends.Backend) -> T.List[T.Any]:
+ tlist = [] # type: T.List[T.Any]
build_dir = builddata.environment.get_build_dir()
src_dir = builddata.environment.get_source_dir()
# Fast lookup table for installation files
install_lookuptable = {}
for i in installdata.targets:
- outname = os.path.join(installdata.prefix, i.outdir, os.path.basename(i.fname))
- install_lookuptable[os.path.basename(i.fname)] = str(pathlib.PurePath(outname))
+ out = [os.path.join(installdata.prefix, i.outdir, os.path.basename(i.fname))]
+ out += [os.path.join(installdata.prefix, i.outdir, os.path.basename(x)) for x in i.aliases]
+ install_lookuptable[os.path.basename(i.fname)] = [str(PurePath(x)) for x in out]
for (idname, target) in builddata.get_targets().items():
if not isinstance(target, build.Target):
raise RuntimeError('The target object in `builddata.get_targets()` is not of type `build.Target`. Please file a bug with this error message.')
+ outdir = get_target_dir(builddata.environment.coredata, target.subdir)
t = {
'name': target.get_basename(),
'id': idname,
'type': target.get_typename(),
'defined_in': os.path.normpath(os.path.join(src_dir, target.subdir, 'meson.build')),
- 'filename': [os.path.join(build_dir, target.subdir, x) for x in target.get_outputs()],
+ 'filename': [os.path.join(build_dir, outdir, x) for x in target.get_outputs()],
'build_by_default': target.build_by_default,
'target_sources': backend.get_introspection_data(idname, target),
+ 'extra_files': [os.path.normpath(os.path.join(src_dir, x.subdir, x.fname)) for x in target.extra_files],
'subproject': target.subproject or None
}
if installdata and target.should_install():
t['installed'] = True
- t['install_filename'] = [install_lookuptable.get(x, None) for x in target.get_outputs()]
+ ifn = [install_lookuptable.get(x, [None]) for x in target.get_outputs()]
+ t['install_filename'] = [x for sublist in ifn for x in sublist] # flatten the list
else:
t['installed'] = False
tlist.append(t)
return tlist
def list_buildoptions_from_source(intr: IntrospectionInterpreter) -> T.List[T.Dict[str, T.Union[str, bool, int, T.List[str]]]]:
- return list_buildoptions(intr.coredata)
+ subprojects = [i['name'] for i in intr.project_data['subprojects']]
+ return list_buildoptions(intr.coredata, subprojects)
-def list_buildoptions(coredata: cdata.CoreData) -> T.List[T.Dict[str, T.Union[str, bool, int, T.List[str]]]]:
+def list_buildoptions(coredata: cdata.CoreData, subprojects: T.Optional[T.List[str]] = None) -> T.List[T.Dict[str, T.Union[str, bool, int, T.List[str]]]]:
optlist = [] # type: T.List[T.Dict[str, T.Union[str, bool, int, T.List[str]]]]
+ subprojects = subprojects or []
- dir_option_names = ['bindir',
- 'datadir',
- 'includedir',
- 'infodir',
- 'libdir',
- 'libexecdir',
- 'localedir',
- 'localstatedir',
- 'mandir',
- 'prefix',
- 'sbindir',
- 'sharedstatedir',
- 'sysconfdir']
- test_option_names = ['errorlogs',
- 'stdsplit']
- core_option_names = [k for k in coredata.builtins if k not in dir_option_names + test_option_names]
-
- dir_options = {k: o for k, o in coredata.builtins.items() if k in dir_option_names}
- test_options = {k: o for k, o in coredata.builtins.items() if k in test_option_names}
- core_options = {k: o for k, o in coredata.builtins.items() if k in core_option_names}
-
- def add_keys(options: T.Dict[str, cdata.UserOption], section: str, machine: str = 'any') -> None:
- for key in sorted(options.keys()):
- opt = options[key]
- optdict = {'name': key, 'value': opt.value, 'section': section, 'machine': machine}
+ dir_option_names = set(cdata.BUILTIN_DIR_OPTIONS)
+ test_option_names = {OptionKey('errorlogs'),
+ OptionKey('stdsplit')}
+
+ dir_options: 'cdata.KeyedOptionDictType' = {}
+ test_options: 'cdata.KeyedOptionDictType' = {}
+ core_options: 'cdata.KeyedOptionDictType' = {}
+ for k, v in coredata.options.items():
+ if k in dir_option_names:
+ dir_options[k] = v
+ elif k in test_option_names:
+ test_options[k] = v
+ elif k.is_builtin():
+ core_options[k] = v
+ if not v.yielding:
+ for s in subprojects:
+ core_options[k.evolve(subproject=s)] = v
+
+ def add_keys(options: 'cdata.KeyedOptionDictType', section: str) -> None:
+ for key, opt in sorted(options.items()):
+ optdict = {'name': str(key), 'value': opt.value, 'section': section,
+ 'machine': key.machine.get_lower_case_name() if coredata.is_per_machine_option(key) else 'any'}
if isinstance(opt, cdata.UserStringOption):
typestr = 'string'
elif isinstance(opt, cdata.UserBooleanOption):
@@ -219,6 +287,8 @@
typestr = 'integer'
elif isinstance(opt, cdata.UserArrayOption):
typestr = 'array'
+ if opt.choices:
+ optdict['choices'] = opt.choices
else:
raise RuntimeError("Unknown option type")
optdict['type'] = typestr
@@ -226,26 +296,18 @@
optlist.append(optdict)
add_keys(core_options, 'core')
- add_keys(coredata.builtins_per_machine.host, 'core', machine='host')
- add_keys(
- {'build.' + k: o for k, o in coredata.builtins_per_machine.build.items()},
- 'core',
- machine='build',
- )
- add_keys(coredata.backend_options, 'backend')
- add_keys(coredata.base_options, 'base')
- add_keys(coredata.compiler_options.host, 'compiler', machine='host')
+ add_keys({k: v for k, v in coredata.options.items() if k.is_backend()}, 'backend')
+ add_keys({k: v for k, v in coredata.options.items() if k.is_base()}, 'base')
add_keys(
- {'build.' + k: o for k, o in coredata.compiler_options.build.items()},
+ {k: v for k, v in sorted(coredata.options.items(), key=lambda i: i[0].machine) if k.is_compiler()},
'compiler',
- machine='build',
)
add_keys(dir_options, 'directory')
- add_keys(coredata.user_options, 'user')
+ add_keys({k: v for k, v in coredata.options.items() if k.is_project()}, 'user')
add_keys(test_options, 'test')
return optlist
-def find_buildsystem_files_list(src_dir) -> T.List[str]:
+def find_buildsystem_files_list(src_dir: str) -> T.List[str]:
# I feel dirty about this. But only slightly.
filelist = [] # type: T.List[str]
for root, _, files in os.walk(src_dir):
@@ -254,10 +316,10 @@
filelist.append(os.path.relpath(os.path.join(root, f), src_dir))
return filelist
-def list_buildsystem_files(builddata: build.Build) -> T.List[str]:
+def list_buildsystem_files(builddata: build.Build, interpreter: Interpreter) -> T.List[str]:
src_dir = builddata.environment.get_source_dir()
- filelist = find_buildsystem_files_list(src_dir)
- filelist = [os.path.join(src_dir, x) for x in filelist]
+ filelist = interpreter.get_build_def_files() # type: T.List[str]
+ filelist = [PurePath(src_dir, x).as_posix() for x in filelist]
return filelist
def list_deps_from_source(intr: IntrospectionInterpreter) -> T.List[T.Dict[str, T.Union[str, bool]]]:
@@ -283,10 +345,10 @@
'link_args': d.get_link_args()}]
return result
-def get_test_list(testdata) -> T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]:
+def get_test_list(testdata: T.List[backends.TestSerialisation]) -> T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]:
result = [] # type: T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]
for t in testdata:
- to = {}
+ to = {} # type: T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]
if isinstance(t.fname, str):
fname = [t.fname]
else:
@@ -302,25 +364,26 @@
to['suite'] = t.suite
to['is_parallel'] = t.is_parallel
to['priority'] = t.priority
- to['protocol'] = t.protocol
+ to['protocol'] = str(t.protocol)
+ to['depends'] = t.depends
result.append(to)
return result
-def list_tests(testdata) -> T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]:
+def list_tests(testdata: T.List[backends.TestSerialisation]) -> T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]:
return get_test_list(testdata)
-def list_benchmarks(benchdata) -> T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]:
+def list_benchmarks(benchdata: T.List[backends.TestSerialisation]) -> T.List[T.Dict[str, T.Union[str, int, T.List[str], T.Dict[str, str]]]]:
return get_test_list(benchdata)
def list_projinfo(builddata: build.Build) -> T.Dict[str, T.Union[str, T.List[T.Dict[str, str]]]]:
result = {'version': builddata.project_version,
'descriptive_name': builddata.project_name,
- 'subproject_dir': builddata.subproject_dir}
+ 'subproject_dir': builddata.subproject_dir} # type: T.Dict[str, T.Union[str, T.List[T.Dict[str, str]]]]
subprojects = []
for k, v in builddata.subprojects.items():
c = {'name': k,
'version': v,
- 'descriptive_name': builddata.projects.get(k)}
+ 'descriptive_name': builddata.projects.get(k)} # type: T.Dict[str, str]
subprojects.append(c)
result['subprojects'] = subprojects
return result
@@ -339,7 +402,7 @@
intr.project_data['subproject_dir'] = intr.subproject_dir
return intr.project_data
-def print_results(options, results: T.Sequence[T.Tuple[str, T.Union[dict, T.List[T.Any]]]], indent: int) -> int:
+def print_results(options: argparse.Namespace, results: T.Sequence[T.Tuple[str, T.Union[dict, T.List[T.Any]]]], indent: int) -> int:
if not results and not options.force_dict:
print('No command specified')
return 1
@@ -353,12 +416,25 @@
print(json.dumps(out, indent=indent))
return 0
-def run(options) -> int:
- datadir = 'meson-private'
+def get_infodir(builddir: T.Optional[str] = None) -> str:
infodir = 'meson-info'
+ if builddir is not None:
+ infodir = os.path.join(builddir, infodir)
+ return infodir
+
+def get_info_file(infodir: str, kind: T.Optional[str] = None) -> str:
+ return os.path.join(infodir,
+ 'meson-info.json' if not kind else f'intro-{kind}.json')
+
+def load_info_file(infodir: str, kind: T.Optional[str] = None) -> T.Any:
+ with open(get_info_file(infodir, kind), encoding='utf-8') as fp:
+ return json.load(fp)
+
+def run(options: argparse.Namespace) -> int:
+ datadir = 'meson-private'
+ infodir = get_infodir(options.builddir)
if options.builddir is not None:
datadir = os.path.join(options.builddir, datadir)
- infodir = os.path.join(options.builddir, infodir)
indent = 4 if options.indent else None
results = [] # type: T.List[T.Tuple[str, T.Union[dict, T.List[T.Any]]]]
sourcedir = '.' if options.builddir == 'meson.build' else options.builddir[:-11]
@@ -367,7 +443,8 @@
if 'meson.build' in [os.path.basename(options.builddir), options.builddir]:
# Make sure that log entries in other parts of meson don't interfere with the JSON output
mlog.disable()
- backend = backends.get_backend_from_name(options.backend, None)
+ backend = backends.get_backend_from_name(options.backend)
+ assert backend is not None
intr = IntrospectionInterpreter(sourcedir, '', backend.name, visitors = [AstIDGenerator(), AstIndentationGenerator(), AstConditionLevel()])
intr.analyze()
# Re-enable logging just in case
@@ -378,17 +455,18 @@
results += [(key, val.no_bd(intr))]
return print_results(options, results, indent)
- infofile = get_meson_info_file(infodir)
- if not os.path.isdir(datadir) or not os.path.isdir(infodir) or not os.path.isfile(infofile):
- print('Current directory is not a meson build directory.\n'
- 'Please specify a valid build dir or change the working directory to it.\n'
- 'It is also possible that the build directory was generated with an old\n'
- 'meson version. Please regenerate it in this case.')
- return 1
-
- with open(infofile, 'r') as fp:
- raw = json.load(fp)
+ try:
+ raw = load_info_file(infodir)
intro_vers = raw.get('introspection', {}).get('version', {}).get('full', '0.0.0')
+ except FileNotFoundError:
+ if not os.path.isdir(datadir) or not os.path.isdir(infodir):
+ print('Current directory is not a meson build directory.\n'
+ 'Please specify a valid build dir or change the working directory to it.')
+ else:
+ print('Introspection file {} does not exist.\n'
+ 'It is also possible that the build directory was generated with an old\n'
+ 'meson version. Please regenerate it in this case.'.format(get_info_file(infodir)))
+ return 1
vers_to_check = get_meson_introspection_required_version()
for i in vers_to_check:
@@ -404,12 +482,11 @@
continue
if not options.all and not getattr(options, i, False):
continue
- curr = os.path.join(infodir, 'intro-{}.json'.format(i))
- if not os.path.isfile(curr):
- print('Introspection file {} does not exist.'.format(curr))
+ try:
+ results += [(i, load_info_file(infodir, i))]
+ except FileNotFoundError:
+ print('Introspection file {} does not exist.'.format(get_info_file(infodir, i)))
return 1
- with open(curr, 'r') as fp:
- results += [(i, json.load(fp))]
return print_results(options, results, indent)
@@ -417,14 +494,14 @@
def write_intro_info(intro_info: T.Sequence[T.Tuple[str, T.Union[dict, T.List[T.Any]]]], info_dir: str) -> None:
global updated_introspection_files
- for i in intro_info:
- out_file = os.path.join(info_dir, 'intro-{}.json'.format(i[0]))
+ for kind, data in intro_info:
+ out_file = os.path.join(info_dir, f'intro-{kind}.json')
tmp_file = os.path.join(info_dir, 'tmp_dump.json')
- with open(tmp_file, 'w') as fp:
- json.dump(i[1], fp)
+ with open(tmp_file, 'w', encoding='utf-8') as fp:
+ json.dump(data, fp)
fp.flush() # Not sure if this is needed
os.replace(tmp_file, out_file)
- updated_introspection_files += [i[0]]
+ updated_introspection_files += [kind]
def generate_introspection_file(builddata: build.Build, backend: backends.Backend) -> None:
coredata = builddata.environment.get_coredata()
@@ -438,7 +515,7 @@
write_intro_info(intro_info, builddata.environment.info_dir)
-def update_build_options(coredata: cdata.CoreData, info_dir) -> None:
+def update_build_options(coredata: cdata.CoreData, info_dir: str) -> None:
intro_info = [
('buildoptions', list_buildoptions(coredata))
]
@@ -465,7 +542,7 @@
if not intro_types[i].func:
continue
intro_info[i] = {
- 'file': 'intro-{}.json'.format(i),
+ 'file': f'intro-{i}.json',
'updated': i in updated_introspection_files
}
@@ -491,7 +568,7 @@
# Write the data to disc
tmp_file = os.path.join(info_dir, 'tmp_dump.json')
- with open(tmp_file, 'w') as fp:
+ with open(tmp_file, 'w', encoding='utf-8') as fp:
json.dump(info_data, fp)
fp.flush()
os.replace(tmp_file, info_file)
diff -Nru meson-0.53.2/mesonbuild/mlog.py meson-0.61.2/mesonbuild/mlog.py
--- meson-0.53.2/mesonbuild/mlog.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/mlog.py 2022-01-02 20:12:32.000000000 +0000
@@ -21,6 +21,9 @@
from contextlib import contextmanager
from pathlib import Path
+if T.TYPE_CHECKING:
+ from ._typing import StringProtocol, SizedStringProtocol
+
"""This is (mostly) a standalone module used to write logging
information about Meson runs. Some output goes to screen,
some to logging dir and some goes to both."""
@@ -40,25 +43,43 @@
# original behavior
return bool(kernel.SetConsoleMode(stdout, mode.value | 0x4) or os.environ.get('ANSICON'))
-def setup_console() -> bool:
+def colorize_console() -> bool:
+ _colorize_console = getattr(sys.stdout, 'colorize_console', None) # type: bool
+ if _colorize_console is not None:
+ return _colorize_console
+
try:
if platform.system().lower() == 'windows':
- return os.isatty(sys.stdout.fileno()) and _windows_ansi()
- return os.isatty(sys.stdout.fileno()) and os.environ.get('TERM') != 'dumb'
+ _colorize_console = os.isatty(sys.stdout.fileno()) and _windows_ansi()
+ else:
+ _colorize_console = os.isatty(sys.stdout.fileno()) and os.environ.get('TERM', 'dumb') != 'dumb'
except Exception:
- return False
+ _colorize_console = False
+
+ sys.stdout.colorize_console = _colorize_console # type: ignore[attr-defined]
+ return _colorize_console
+
+def setup_console() -> None:
+ # on Windows, a subprocess might call SetConsoleMode() on the console
+ # connected to stdout and turn off ANSI escape processing. Call this after
+ # running a subprocess to ensure we turn it on again.
+ if platform.system().lower() == 'windows':
+ try:
+ delattr(sys.stdout, 'colorize_console')
+ except AttributeError:
+ pass
-colorize_console = setup_console()
log_dir = None # type: T.Optional[str]
log_file = None # type: T.Optional[T.TextIO]
log_fname = 'meson-log.txt' # type: str
-log_depth = 0 # type: int
+log_depth = [] # type: T.List[str]
log_timestamp_start = None # type: T.Optional[float]
log_fatal_warnings = False # type: bool
log_disable_stdout = False # type: bool
log_errors_only = False # type: bool
_in_ci = 'CI' in os.environ # type: bool
_logged_once = set() # type: T.Set[T.Tuple[str, ...]]
+log_warnings_counter = 0 # type: int
def disable() -> None:
global log_disable_stdout
@@ -79,7 +100,7 @@
def initialize(logdir: str, fatal_warnings: bool = False) -> None:
global log_dir, log_file, log_fatal_warnings
log_dir = logdir
- log_file = open(os.path.join(logdir, log_fname), 'w', encoding='utf8')
+ log_file = open(os.path.join(logdir, log_fname), 'w', encoding='utf-8')
log_fatal_warnings = fatal_warnings
def set_timestamp_start(start: float) -> None:
@@ -106,15 +127,38 @@
def get_text(self, with_codes: bool) -> str:
text = self.text
- if with_codes:
+ if with_codes and self.code:
text = self.code + self.text + AnsiDecorator.plain_code
if self.quoted:
- text = '"{}"'.format(text)
+ text = f'"{text}"'
return text
+ def __len__(self) -> int:
+ return len(self.text)
+
+ def __str__(self) -> str:
+ return self.get_text(colorize_console())
+
+TV_Loggable = T.Union[str, AnsiDecorator, 'StringProtocol']
+TV_LoggableList = T.List[TV_Loggable]
+
+class AnsiText:
+ def __init__(self, *args: 'SizedStringProtocol'):
+ self.args = args
+
+ def __len__(self) -> int:
+ return sum(len(x) for x in self.args)
+
+ def __str__(self) -> str:
+ return ''.join(str(x) for x in self.args)
+
+
def bold(text: str, quoted: bool = False) -> AnsiDecorator:
return AnsiDecorator(text, "\033[1m", quoted=quoted)
+def plain(text: str) -> AnsiDecorator:
+ return AnsiDecorator(text, "")
+
def red(text: str) -> AnsiDecorator:
return AnsiDecorator(text, "\033[1;31m")
@@ -147,7 +191,7 @@
# This really should be AnsiDecorator or anything that implements
# __str__(), but that requires protocols from typing_extensions
-def process_markup(args: T.Sequence[T.Union[AnsiDecorator, str]], keep: bool) -> T.List[str]:
+def process_markup(args: T.Sequence[TV_Loggable], keep: bool) -> T.List[str]:
arr = [] # type: T.List[str]
if log_timestamp_start is not None:
arr = ['[{:.3f}]'.format(time.monotonic() - log_timestamp_start)]
@@ -162,7 +206,7 @@
arr.append(str(arg))
return arr
-def force_print(*args: str, **kwargs: T.Any) -> None:
+def force_print(*args: str, nested: bool, **kwargs: T.Any) -> None:
if log_disable_stdout:
return
iostr = io.StringIO()
@@ -170,9 +214,13 @@
print(*args, **kwargs)
raw = iostr.getvalue()
- if log_depth > 0:
- prepend = '|' * log_depth
- raw = prepend + raw.replace('\n', '\n' + prepend, raw.count('\n') - 1)
+ if log_depth:
+ prepend = log_depth[-1] + '| ' if nested else ''
+ lines = []
+ for l in raw.split('\n'):
+ l = l.strip()
+ lines.append(prepend + l if l else '')
+ raw = '\n'.join(lines)
# _Something_ is going to get printed.
try:
@@ -182,7 +230,7 @@
print(cleaned, end='')
# We really want a heterogeneous dict for this, but that's in typing_extensions
-def debug(*args: T.Union[str, AnsiDecorator], **kwargs: T.Any) -> None:
+def debug(*args: TV_Loggable, **kwargs: T.Any) -> None:
arr = process_markup(args, False)
if log_file is not None:
print(*arr, file=log_file, **kwargs)
@@ -191,46 +239,72 @@
def _debug_log_cmd(cmd: str, args: T.List[str]) -> None:
if not _in_ci:
return
- args = ['"{}"'.format(x) for x in args] # Quote all args, just in case
+ args = [f'"{x}"' for x in args] # Quote all args, just in case
debug('!meson_ci!/{} {}'.format(cmd, ' '.join(args)))
def cmd_ci_include(file: str) -> None:
_debug_log_cmd('ci_include', [file])
-def log(*args: T.Union[str, AnsiDecorator], is_error: bool = False,
- **kwargs: T.Any) -> None:
+
+def log(*args: TV_Loggable, is_error: bool = False,
+ once: bool = False, **kwargs: T.Any) -> None:
+ if once:
+ log_once(*args, is_error=is_error, **kwargs)
+ else:
+ _log(*args, is_error=is_error, **kwargs)
+
+
+def _log(*args: TV_Loggable, is_error: bool = False,
+ **kwargs: T.Any) -> None:
+ nested = kwargs.pop('nested', True)
arr = process_markup(args, False)
if log_file is not None:
print(*arr, file=log_file, **kwargs)
log_file.flush()
- if colorize_console:
+ if colorize_console():
arr = process_markup(args, True)
if not log_errors_only or is_error:
- force_print(*arr, **kwargs)
+ force_print(*arr, nested=nested, **kwargs)
-def log_once(*args: T.Union[str, AnsiDecorator], is_error: bool = False,
+def log_once(*args: TV_Loggable, is_error: bool = False,
**kwargs: T.Any) -> None:
"""Log variant that only prints a given message one time per meson invocation.
- This considers nasi decorated values by the values they wrap without
+ This considers ansi decorated values by the values they wrap without
regard for the AnsiDecorator itself.
"""
- t = tuple(a.text if isinstance(a, AnsiDecorator) else a for a in args)
+ def to_str(x: TV_Loggable) -> str:
+ if isinstance(x, str):
+ return x
+ if isinstance(x, AnsiDecorator):
+ return x.text
+ return str(x)
+ t = tuple(to_str(a) for a in args)
if t in _logged_once:
return
_logged_once.add(t)
- log(*args, is_error=is_error, **kwargs)
+ _log(*args, is_error=is_error, **kwargs)
-def _log_error(severity: str, *rargs: T.Union[str, AnsiDecorator],
- once: bool = False, **kwargs: T.Any) -> None:
- from .mesonlib import get_error_location_string
- from .environment import build_filename
- from .mesonlib import MesonException
+# This isn't strictly correct. What we really want here is something like:
+# class StringProtocol(typing_extensions.Protocol):
+#
+# def __str__(self) -> str: ...
+#
+# This would more accurately embody what this function can handle, but we
+# don't have that yet, so instead we'll do some casting to work around it
+def get_error_location_string(fname: str, lineno: int) -> str:
+ return f'{fname}:{lineno}:'
+
+def _log_error(severity: str, *rargs: TV_Loggable,
+ once: bool = False, fatal: bool = True, **kwargs: T.Any) -> None:
+ from .mesonlib import MesonException, relpath
- # The tping requirements here are non-obvious. Lists are invariant,
+ # The typing requirements here are non-obvious. Lists are invariant,
# therefore T.List[A] and T.List[T.Union[A, B]] are not able to be joined
- if severity == 'warning':
- label = [yellow('WARNING:')] # type: T.List[T.Union[str, AnsiDecorator]]
+ if severity == 'notice':
+ label = [bold('NOTICE:')] # type: TV_LoggableList
+ elif severity == 'warning':
+ label = [yellow('WARNING:')]
elif severity == 'error':
label = [red('ERROR:')]
elif severity == 'deprecation':
@@ -242,29 +316,32 @@
location = kwargs.pop('location', None)
if location is not None:
- location_file = os.path.join(location.subdir, build_filename)
+ location_file = relpath(location.filename, os.getcwd())
location_str = get_error_location_string(location_file, location.lineno)
# Unions are frankly awful, and we have to T.cast here to get mypy
# to understand that the list concatenation is safe
- location_list = T.cast(T.List[T.Union[str, AnsiDecorator]], [location_str])
+ location_list = T.cast(TV_LoggableList, [location_str])
args = location_list + args
- if once:
- log_once(*args, **kwargs)
- else:
- log(*args, **kwargs)
+ log(*args, once=once, **kwargs)
+
+ global log_warnings_counter
+ log_warnings_counter += 1
- if log_fatal_warnings:
+ if log_fatal_warnings and fatal:
raise MesonException("Fatal warnings enabled, aborting")
-def error(*args: T.Union[str, AnsiDecorator], once: bool = False, **kwargs: T.Any) -> None:
- return _log_error('error', *args, **kwargs, is_error=True, once=once)
+def error(*args: TV_Loggable, **kwargs: T.Any) -> None:
+ return _log_error('error', *args, **kwargs, is_error=True)
+
+def warning(*args: TV_Loggable, **kwargs: T.Any) -> None:
+ return _log_error('warning', *args, **kwargs, is_error=True)
-def warning(*args: T.Union[str, AnsiDecorator], once: bool = False, **kwargs: T.Any) -> None:
- return _log_error('warning', *args, **kwargs, is_error=True, once=once)
+def deprecation(*args: TV_Loggable, **kwargs: T.Any) -> None:
+ return _log_error('deprecation', *args, **kwargs, is_error=True)
-def deprecation(*args: T.Union[str, AnsiDecorator], once: bool = False, **kwargs: T.Any) -> None:
- return _log_error('deprecation', *args, **kwargs, is_error=True, once=once)
+def notice(*args: TV_Loggable, **kwargs: T.Any) -> None:
+ return _log_error('notice', *args, **kwargs, is_error=False)
def get_relative_path(target: Path, current: Path) -> Path:
"""Get the path to target from current"""
@@ -286,11 +363,11 @@
prefix = red('ERROR:')
log()
args = [] # type: T.List[T.Union[AnsiDecorator, str]]
- if hasattr(e, 'file') and hasattr(e, 'lineno') and hasattr(e, 'colno'):
- # Mypy can't figure this out, and it's pretty easy to vidual inspect
+ if all(getattr(e, a, None) is not None for a in ['file', 'lineno', 'colno']):
+ # Mypy doesn't follow hasattr, and it's pretty easy to visually inspect
# that this is correct, so we'll just ignore it.
- path = get_relative_path(Path(e.file), Path(os.getcwd()))
- args.append('%s:%d:%d:' % (path, e.lineno, e.colno)) # type: ignore
+ path = get_relative_path(Path(e.file), Path(os.getcwd())) # type: ignore
+ args.append(f'{path}:{e.lineno}:{e.colno}:') # type: ignore
if prefix:
args.append(prefix)
args.append(str(e))
@@ -310,10 +387,10 @@
return ''
@contextmanager
-def nested() -> T.Generator[None, None, None]:
+def nested(name: str = '') -> T.Generator[None, None, None]:
global log_depth
- log_depth += 1
+ log_depth.append(name)
try:
yield
finally:
- log_depth -= 1
+ log_depth.pop()
diff -Nru meson-0.53.2/mesonbuild/modules/cmake.py meson-0.61.2/mesonbuild/modules/cmake.py
--- meson-0.53.2/mesonbuild/modules/cmake.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/cmake.py 2022-01-02 20:12:32.000000000 +0000
@@ -14,12 +14,26 @@
import re
import os, os.path, pathlib
import shutil
+import typing as T
-from . import ExtensionModule, ModuleReturnValue
+from . import ExtensionModule, ModuleReturnValue, ModuleObject
-from .. import build, dependencies, mesonlib, mlog
-from ..interpreterbase import permittedKwargs, FeatureNew, stringArgs, InterpreterObject, ObjectHolder, noPosargs
-from ..interpreter import ConfigurationDataHolder, InterpreterException, SubprojectHolder
+from .. import build, mesonlib, mlog, dependencies
+from ..cmake import SingleTargetOptions, TargetOptions, cmake_defines_to_args
+from ..interpreter import ConfigurationDataObject, SubprojectHolder
+from ..interpreterbase import (
+ FeatureNew,
+ FeatureNewKwargs,
+ FeatureDeprecatedKwargs,
+
+ stringArgs,
+ permittedKwargs,
+ noPosargs,
+ noKwargs,
+
+ InvalidArguments,
+ InterpreterException,
+)
COMPATIBILITIES = ['AnyNewerVersion', 'SameMajorVersion', 'SameMinorVersion', 'ExactVersion']
@@ -54,12 +68,12 @@
####################################################################################
'''
-class CMakeSubprojectHolder(InterpreterObject, ObjectHolder):
+class CMakeSubproject(ModuleObject):
def __init__(self, subp, pv):
- assert(isinstance(subp, SubprojectHolder))
- assert(hasattr(subp, 'cm_interpreter'))
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, subp, pv)
+ assert isinstance(subp, SubprojectHolder)
+ assert hasattr(subp, 'cm_interpreter')
+ super().__init__()
+ self.subp = subp
self.methods.update({'get_variable': self.get_variable,
'dependency': self.dependency,
'include_directories': self.include_directories,
@@ -74,58 +88,139 @@
raise InterpreterException('Exactly one argument is required.')
tgt = args[0]
- res = self.held_object.cm_interpreter.target_info(tgt)
+ res = self.subp.cm_interpreter.target_info(tgt)
if res is None:
- raise InterpreterException('The CMake target {} does not exist'.format(tgt))
+ raise InterpreterException(f'The CMake target {tgt} does not exist\n' +
+ ' Use the following command in your meson.build to list all available targets:\n\n' +
+ ' message(\'CMaket targets:\\n - \' + \'\\n - \'.join(.target_list()))')
# Make sure that all keys are present (if not this is a bug)
- assert(all([x in res for x in ['inc', 'src', 'dep', 'tgt', 'func']]))
+ assert all([x in res for x in ['inc', 'src', 'dep', 'tgt', 'func']])
return res
- @permittedKwargs({})
- def get_variable(self, args, kwargs):
- return self.held_object.get_variable_method(args, kwargs)
+ @noKwargs
+ @stringArgs
+ def get_variable(self, state, args, kwargs):
+ return self.subp.get_variable_method(args, kwargs)
- @permittedKwargs({})
- def dependency(self, args, kwargs):
+ @FeatureNewKwargs('dependency', '0.56.0', ['include_type'])
+ @permittedKwargs({'include_type'})
+ @stringArgs
+ def dependency(self, state, args, kwargs):
info = self._args_to_info(args)
- return self.get_variable([info['dep']], kwargs)
+ if info['func'] == 'executable':
+ raise InvalidArguments(f'{args[0]} is an executable and does not support the dependency() method. Use target() instead.')
+ orig = self.get_variable(state, [info['dep']], {})
+ assert isinstance(orig, dependencies.Dependency)
+ actual = orig.include_type
+ if 'include_type' in kwargs and kwargs['include_type'] != actual:
+ mlog.debug('Current include type is {}. Converting to requested {}'.format(actual, kwargs['include_type']))
+ return orig.generate_system_dependency(kwargs['include_type'])
+ return orig
- @permittedKwargs({})
- def include_directories(self, args, kwargs):
+ @noKwargs
+ @stringArgs
+ def include_directories(self, state, args, kwargs):
info = self._args_to_info(args)
- return self.get_variable([info['inc']], kwargs)
+ return self.get_variable(state, [info['inc']], kwargs)
- @permittedKwargs({})
- def target(self, args, kwargs):
+ @noKwargs
+ @stringArgs
+ def target(self, state, args, kwargs):
info = self._args_to_info(args)
- return self.get_variable([info['tgt']], kwargs)
+ return self.get_variable(state, [info['tgt']], kwargs)
- @permittedKwargs({})
- def target_type(self, args, kwargs):
+ @noKwargs
+ @stringArgs
+ def target_type(self, state, args, kwargs):
info = self._args_to_info(args)
return info['func']
@noPosargs
- @permittedKwargs({})
- def target_list(self, args, kwargs):
- return self.held_object.cm_interpreter.target_list()
+ @noKwargs
+ def target_list(self, state, args, kwargs):
+ return self.subp.cm_interpreter.target_list()
@noPosargs
- @permittedKwargs({})
+ @noKwargs
@FeatureNew('CMakeSubproject.found()', '0.53.2')
- def found_method(self, args, kwargs):
- return self.held_object is not None
+ def found_method(self, state, args, kwargs):
+ return self.subp is not None
+
+
+class CMakeSubprojectOptions(ModuleObject):
+ def __init__(self) -> None:
+ super().__init__()
+ self.cmake_options = [] # type: T.List[str]
+ self.target_options = TargetOptions()
+
+ self.methods.update(
+ {
+ 'add_cmake_defines': self.add_cmake_defines,
+ 'set_override_option': self.set_override_option,
+ 'set_install': self.set_install,
+ 'append_compile_args': self.append_compile_args,
+ 'append_link_args': self.append_link_args,
+ 'clear': self.clear,
+ }
+ )
+
+ def _get_opts(self, kwargs: dict) -> SingleTargetOptions:
+ if 'target' in kwargs:
+ return self.target_options[kwargs['target']]
+ return self.target_options.global_options
+
+ @noKwargs
+ def add_cmake_defines(self, state, args, kwargs) -> None:
+ self.cmake_options += cmake_defines_to_args(args)
+
+ @stringArgs
+ @permittedKwargs({'target'})
+ def set_override_option(self, state, args, kwargs) -> None:
+ if len(args) != 2:
+ raise InvalidArguments('set_override_option takes exactly 2 positional arguments')
+ self._get_opts(kwargs).set_opt(args[0], args[1])
+
+ @permittedKwargs({'target'})
+ def set_install(self, state, args, kwargs) -> None:
+ if len(args) != 1 or not isinstance(args[0], bool):
+ raise InvalidArguments('set_install takes exactly 1 boolean argument')
+ self._get_opts(kwargs).set_install(args[0])
+
+ @stringArgs
+ @permittedKwargs({'target'})
+ def append_compile_args(self, state, args, kwargs) -> None:
+ if len(args) < 2:
+ raise InvalidArguments('append_compile_args takes at least 2 positional arguments')
+ self._get_opts(kwargs).append_args(args[0], args[1:])
+
+ @stringArgs
+ @permittedKwargs({'target'})
+ def append_link_args(self, state, args, kwargs) -> None:
+ if not args:
+ raise InvalidArguments('append_link_args takes at least 1 positional argument')
+ self._get_opts(kwargs).append_link_args(args)
+
+ @noPosargs
+ @noKwargs
+ def clear(self, state, args, kwargs) -> None:
+ self.cmake_options.clear()
+ self.target_options = TargetOptions()
class CmakeModule(ExtensionModule):
cmake_detected = False
cmake_root = None
+ @FeatureNew('CMake Module', '0.50.0')
def __init__(self, interpreter):
super().__init__(interpreter)
- self.snippets.add('configure_package_config_file')
- self.snippets.add('subproject')
+ self.methods.update({
+ 'write_basic_package_version_file': self.write_basic_package_version_file,
+ 'configure_package_config_file': self.configure_package_config_file,
+ 'subproject': self.subproject,
+ 'subproject_options': self.subproject_options,
+ })
def detect_voidp_size(self, env):
compilers = env.coredata.compilers.host
@@ -138,14 +233,17 @@
return compiler.sizeof('void *', '', env)
- def detect_cmake(self):
+ def detect_cmake(self, state):
if self.cmake_detected:
return True
- cmakebin = dependencies.ExternalProgram('cmake', silent=False)
+ cmakebin = state.find_program('cmake', silent=False)
+ if not cmakebin.found():
+ return False
+
p, stdout, stderr = mesonlib.Popen_safe(cmakebin.get_command() + ['--system-information', '-G', 'Ninja'])[0:3]
if p.returncode != 0:
- mlog.log('error retrieving cmake information: returnCode={0} stdout={1} stderr={2}'.format(p.returncode, stdout, stderr))
+ mlog.log(f'error retrieving cmake information: returnCode={p.returncode} stdout={stdout} stderr={stderr}')
return False
match = re.search('\nCMAKE_ROOT \\"([^"]+)"\n', stdout.strip())
@@ -174,20 +272,21 @@
if compatibility not in COMPATIBILITIES:
raise mesonlib.MesonException('compatibility must be either AnyNewerVersion, SameMajorVersion or ExactVersion.')
- if not self.detect_cmake():
+ if not self.detect_cmake(state):
raise mesonlib.MesonException('Unable to find cmake')
- pkgroot = kwargs.get('install_dir', None)
+ pkgroot = pkgroot_name = kwargs.get('install_dir', None)
if pkgroot is None:
- pkgroot = os.path.join(state.environment.coredata.get_builtin_option('libdir'), 'cmake', name)
+ pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name)
+ pkgroot_name = os.path.join('{libdir}', 'cmake', name)
if not isinstance(pkgroot, str):
raise mesonlib.MesonException('Install_dir must be a string.')
- template_file = os.path.join(self.cmake_root, 'Modules', 'BasicConfigVersion-{}.cmake.in'.format(compatibility))
+ template_file = os.path.join(self.cmake_root, 'Modules', f'BasicConfigVersion-{compatibility}.cmake.in')
if not os.path.exists(template_file):
- raise mesonlib.MesonException('your cmake installation doesn\'t support the {} compatibility'.format(compatibility))
+ raise mesonlib.MesonException(f'your cmake installation doesn\'t support the {compatibility} compatibility')
- version_file = os.path.join(state.environment.scratch_dir, '{}ConfigVersion.cmake'.format(name))
+ version_file = os.path.join(state.environment.scratch_dir, f'{name}ConfigVersion.cmake')
conf = {
'CVF_VERSION': (version, ''),
@@ -195,26 +294,26 @@
}
mesonlib.do_conf_file(template_file, version_file, conf, 'meson')
- res = build.Data(mesonlib.File(True, state.environment.get_scratch_dir(), version_file), pkgroot)
+ res = build.Data([mesonlib.File(True, state.environment.get_scratch_dir(), version_file)], pkgroot, pkgroot_name, None, state.subproject)
return ModuleReturnValue(res, [res])
def create_package_file(self, infile, outfile, PACKAGE_RELATIVE_PATH, extra, confdata):
package_init = PACKAGE_INIT_BASE.replace('@PACKAGE_RELATIVE_PATH@', PACKAGE_RELATIVE_PATH)
- package_init = package_init.replace('@inputFileName@', infile)
+ package_init = package_init.replace('@inputFileName@', os.path.basename(infile))
package_init += extra
package_init += PACKAGE_INIT_SET_AND_CHECK
try:
- with open(infile, "r") as fin:
+ with open(infile, encoding='utf-8') as fin:
data = fin.readlines()
except Exception as e:
- raise mesonlib.MesonException('Could not read input file %s: %s' % (infile, str(e)))
+ raise mesonlib.MesonException(f'Could not read input file {infile}: {e!s}')
result = []
- regex = re.compile(r'(?:\\\\)+(?=\\?@)|\\@|@([-a-zA-Z0-9_]+)@')
+ regex = mesonlib.get_variable_regex('cmake@')
for line in data:
line = line.replace('@PACKAGE_INIT@', package_init)
- line, _missing = mesonlib.do_replacement(regex, line, 'meson', confdata)
+ line, _missing = mesonlib.do_replacement(regex, line, 'cmake@', confdata)
result.append(line)
@@ -226,7 +325,7 @@
mesonlib.replace_if_different(outfile, outfile_tmp)
@permittedKwargs({'input', 'name', 'install_dir', 'configuration'})
- def configure_package_config_file(self, interpreter, state, args, kwargs):
+ def configure_package_config_file(self, state, args, kwargs):
if args:
raise mesonlib.MesonException('configure_package_config_file takes only keyword arguments.')
@@ -249,21 +348,20 @@
raise mesonlib.MesonException('"name" not specified.')
name = kwargs['name']
- (ofile_path, ofile_fname) = os.path.split(os.path.join(state.subdir, '{}Config.cmake'.format(name)))
+ (ofile_path, ofile_fname) = os.path.split(os.path.join(state.subdir, f'{name}Config.cmake'))
ofile_abs = os.path.join(state.environment.build_dir, ofile_path, ofile_fname)
- if 'install_dir' not in kwargs:
- install_dir = os.path.join(state.environment.coredata.get_builtin_option('libdir'), 'cmake', name)
+ install_dir = kwargs.get('install_dir', os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name))
if not isinstance(install_dir, str):
raise mesonlib.MesonException('"install_dir" must be a string.')
if 'configuration' not in kwargs:
raise mesonlib.MesonException('"configuration" not specified.')
conf = kwargs['configuration']
- if not isinstance(conf, ConfigurationDataHolder):
+ if not isinstance(conf, ConfigurationDataObject):
raise mesonlib.MesonException('Argument "configuration" is not of type configuration_data')
- prefix = state.environment.coredata.get_builtin_option('prefix')
+ prefix = state.environment.coredata.get_option(mesonlib.OptionKey('prefix'))
abs_install_dir = install_dir
if not os.path.isabs(abs_install_dir):
abs_install_dir = os.path.join(prefix, install_dir)
@@ -274,29 +372,39 @@
extra = PACKAGE_INIT_EXT.replace('@absInstallDir@', abs_install_dir)
extra = extra.replace('@installPrefix@', prefix)
- self.create_package_file(ifile_abs, ofile_abs, PACKAGE_RELATIVE_PATH, extra, conf.held_object)
+ self.create_package_file(ifile_abs, ofile_abs, PACKAGE_RELATIVE_PATH, extra, conf.conf_data)
conf.mark_used()
conffile = os.path.normpath(inputfile.relative_name())
- if conffile not in interpreter.build_def_files:
- interpreter.build_def_files.append(conffile)
+ if conffile not in self.interpreter.build_def_files:
+ self.interpreter.build_def_files.append(conffile)
- res = build.Data(mesonlib.File(True, ofile_path, ofile_fname), install_dir)
- interpreter.build.data.append(res)
+ res = build.Data([mesonlib.File(True, ofile_path, ofile_fname)], install_dir, install_dir, None, state.subproject)
+ self.interpreter.build.data.append(res)
return res
@FeatureNew('subproject', '0.51.0')
- @permittedKwargs({'cmake_options', 'required'})
+ @FeatureNewKwargs('subproject', '0.55.0', ['options'])
+ @FeatureDeprecatedKwargs('subproject', '0.55.0', ['cmake_options'])
+ @permittedKwargs({'cmake_options', 'required', 'options'})
@stringArgs
- def subproject(self, interpreter, state, args, kwargs):
+ def subproject(self, state, args, kwargs):
if len(args) != 1:
raise InterpreterException('Subproject takes exactly one argument')
+ if 'cmake_options' in kwargs and 'options' in kwargs:
+ raise InterpreterException('"options" cannot be used together with "cmake_options"')
dirname = args[0]
- subp = interpreter.do_subproject(dirname, 'cmake', kwargs)
- if not subp.held_object:
+ subp = self.interpreter.do_subproject(dirname, 'cmake', kwargs)
+ if not subp.found():
return subp
- return CMakeSubprojectHolder(subp, dirname)
+ return CMakeSubproject(subp, dirname)
+
+ @FeatureNew('subproject_options', '0.55.0')
+ @noKwargs
+ @noPosargs
+ def subproject_options(self, state, args, kwargs) -> CMakeSubprojectOptions:
+ return CMakeSubprojectOptions()
def initialize(*args, **kwargs):
return CmakeModule(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/dlang.py meson-0.61.2/mesonbuild/modules/dlang.py
--- meson-0.53.2/mesonbuild/modules/dlang.py 2018-10-31 09:31:20.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/dlang.py 2022-01-02 20:12:32.000000000 +0000
@@ -19,36 +19,31 @@
import os
from . import ExtensionModule
-
+from .. import dependencies
from .. import mlog
-
-from ..mesonlib import (
- Popen_safe, MesonException
-)
-
-from ..dependencies.base import (
- ExternalProgram, DubDependency
-)
-
-from ..interpreter import DependencyHolder
+from ..interpreterbase import FeatureNew
+from ..mesonlib import Popen_safe, MesonException
class DlangModule(ExtensionModule):
class_dubbin = None
init_dub = False
+ @FeatureNew('Dlang Module', '0.48.0')
def __init__(self, interpreter):
super().__init__(interpreter)
- self.snippets.add('generate_dub_file')
+ self.methods.update({
+ 'generate_dub_file': self.generate_dub_file,
+ })
- def _init_dub(self):
+ def _init_dub(self, state):
if DlangModule.class_dubbin is None:
- self.dubbin = DubDependency.class_dubbin
+ self.dubbin = dependencies.DubDependency.class_dubbin
DlangModule.class_dubbin = self.dubbin
else:
self.dubbin = DlangModule.class_dubbin
if DlangModule.class_dubbin is None:
- self.dubbin = self.check_dub()
+ self.dubbin = self.check_dub(state)
DlangModule.class_dubbin = self.dubbin
else:
self.dubbin = DlangModule.class_dubbin
@@ -57,9 +52,9 @@
if not self.dubbin:
raise MesonException('DUB not found.')
- def generate_dub_file(self, interpreter, state, args, kwargs):
+ def generate_dub_file(self, state, args, kwargs):
if not DlangModule.init_dub:
- self._init_dub()
+ self._init_dub(state)
if len(args) < 2:
raise MesonException('Missing arguments')
@@ -70,7 +65,7 @@
config_path = os.path.join(args[1], 'dub.json')
if os.path.exists(config_path):
- with open(config_path, 'r', encoding='utf8') as ofile:
+ with open(config_path, encoding='utf-8') as ofile:
try:
config = json.load(ofile)
except ValueError:
@@ -87,20 +82,20 @@
config[key] = {}
if isinstance(value, list):
for dep in value:
- if isinstance(dep, DependencyHolder):
- name = dep.method_call('name', [], [])
+ if isinstance(dep, dependencies.Dependency):
+ name = dep.get_name()
ret, res = self._call_dubbin(['describe', name])
if ret == 0:
- version = dep.method_call('version', [], [])
+ version = dep.get_version()
if version is None:
config[key][name] = ''
else:
config[key][name] = version
- elif isinstance(value, DependencyHolder):
- name = value.method_call('name', [], [])
+ elif isinstance(value, dependencies.Dependency):
+ name = value.get_name()
ret, res = self._call_dubbin(['describe', name])
if ret == 0:
- version = value.method_call('version', [], [])
+ version = value.get_version()
if version is None:
config[key][name] = ''
else:
@@ -108,15 +103,15 @@
else:
config[key] = value
- with open(config_path, 'w', encoding='utf8') as ofile:
+ with open(config_path, 'w', encoding='utf-8') as ofile:
ofile.write(json.dumps(config, indent=4, ensure_ascii=False))
def _call_dubbin(self, args, env=None):
p, out = Popen_safe(self.dubbin.get_command() + args, env=env)[0:2]
return p.returncode, out.strip()
- def check_dub(self):
- dubbin = ExternalProgram('dub', silent=True)
+ def check_dub(self, state):
+ dubbin = state.find_program('dub', silent=True)
if dubbin.found():
try:
p, out = Popen_safe(dubbin.get_command() + ['--version'])[0:2]
diff -Nru meson-0.53.2/mesonbuild/modules/fs.py meson-0.61.2/mesonbuild/modules/fs.py
--- meson-0.53.2/mesonbuild/modules/fs.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/fs.py 2022-01-02 20:12:32.000000000 +0000
@@ -14,127 +14,246 @@
import typing as T
import hashlib
-from pathlib import Path, PurePath
+import os
+from pathlib import Path, PurePath, PureWindowsPath
from .. import mlog
from . import ExtensionModule
-from . import ModuleReturnValue
-from ..mesonlib import MesonException
+from ..mesonlib import (
+ File,
+ FileOrString,
+ MesonException,
+ path_is_in_root,
+)
+from ..interpreterbase import FeatureNew, KwargInfo, typed_kwargs, typed_pos_args, noKwargs
-from ..interpreterbase import stringArgs, noKwargs
if T.TYPE_CHECKING:
- from ..interpreter import ModuleState
+ from . import ModuleState
+ from ..interpreter import Interpreter
+
+ from typing_extensions import TypedDict
+
+ class ReadKwArgs(TypedDict):
+ """Keyword Arguments for fs.read."""
+
+ encoding: str
+
class FSModule(ExtensionModule):
- def __init__(self, interpreter):
+ @FeatureNew('Fs Module', '0.53.0')
+ def __init__(self, interpreter: 'Interpreter') -> None:
super().__init__(interpreter)
- self.snippets.add('generate_dub_file')
+ self.methods.update({
+ 'expanduser': self.expanduser,
+ 'is_absolute': self.is_absolute,
+ 'as_posix': self.as_posix,
+ 'exists': self.exists,
+ 'is_symlink': self.is_symlink,
+ 'is_file': self.is_file,
+ 'is_dir': self.is_dir,
+ 'hash': self.hash,
+ 'size': self.size,
+ 'is_samepath': self.is_samepath,
+ 'replace_suffix': self.replace_suffix,
+ 'parent': self.parent,
+ 'name': self.name,
+ 'stem': self.stem,
+ 'read': self.read,
+ })
- def _resolve_dir(self, state: 'ModuleState', arg: str) -> Path:
+ def _absolute_dir(self, state: 'ModuleState', arg: 'FileOrString') -> Path:
"""
- resolves (makes absolute) a directory relative to calling meson.build,
- if not already absolute
+ make an absolute path from a relative path, WITHOUT resolving symlinks
"""
- return Path(state.source_root) / state.subdir / Path(arg).expanduser()
+ if isinstance(arg, File):
+ return Path(arg.absolute_path(state.source_root, self.interpreter.environment.get_build_dir()))
+ return Path(state.source_root) / Path(state.subdir) / Path(arg).expanduser()
- def _check(self, check: str, state: 'ModuleState', args: T.Sequence[str]) -> ModuleReturnValue:
- if len(args) != 1:
- raise MesonException('fs.{} takes exactly one argument.'.format(check))
- test_file = self._resolve_dir(state, args[0])
- return ModuleReturnValue(getattr(test_file, check)(), [])
+ def _resolve_dir(self, state: 'ModuleState', arg: 'FileOrString') -> Path:
+ """
+ resolves symlinks and makes absolute a directory relative to calling meson.build,
+ if not already absolute
+ """
+ path = self._absolute_dir(state, arg)
+ try:
+ # accommodate unresolvable paths e.g. symlink loops
+ path = path.resolve()
+ except Exception:
+ # return the best we could do
+ pass
+ return path
+
+ @noKwargs
+ @FeatureNew('fs.expanduser', '0.54.0')
+ @typed_pos_args('fs.expanduser', str)
+ def expanduser(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> str:
+ return str(Path(args[0]).expanduser())
+
+ @noKwargs
+ @FeatureNew('fs.is_absolute', '0.54.0')
+ @typed_pos_args('fs.is_absolute', (str, File))
+ def is_absolute(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> bool:
+ if isinstance(args[0], File):
+ FeatureNew('fs.is_absolute_file', '0.59.0').use(state.subproject)
+ return PurePath(str(args[0])).is_absolute()
+
+ @noKwargs
+ @FeatureNew('fs.as_posix', '0.54.0')
+ @typed_pos_args('fs.as_posix', str)
+ def as_posix(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> str:
+ """
+ this function assumes you are passing a Windows path, even if on a Unix-like system
+ and so ALL '\' are turned to '/', even if you meant to escape a character
+ """
+ return PureWindowsPath(args[0]).as_posix()
- @stringArgs
@noKwargs
- def exists(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- return self._check('exists', state, args)
+ @typed_pos_args('fs.exists', str)
+ def exists(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> bool:
+ return self._resolve_dir(state, args[0]).exists()
- @stringArgs
@noKwargs
- def is_symlink(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- return self._check('is_symlink', state, args)
+ @typed_pos_args('fs.is_symlink', (str, File))
+ def is_symlink(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> bool:
+ if isinstance(args[0], File):
+ FeatureNew('fs.is_symlink_file', '0.59.0').use(state.subproject)
+ return self._absolute_dir(state, args[0]).is_symlink()
- @stringArgs
@noKwargs
- def is_file(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- return self._check('is_file', state, args)
+ @typed_pos_args('fs.is_file', str)
+ def is_file(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> bool:
+ return self._resolve_dir(state, args[0]).is_file()
- @stringArgs
@noKwargs
- def is_dir(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- return self._check('is_dir', state, args)
+ @typed_pos_args('fs.is_dir', str)
+ def is_dir(self, state: 'ModuleState', args: T.Tuple[str], kwargs: T.Dict[str, T.Any]) -> bool:
+ return self._resolve_dir(state, args[0]).is_dir()
- @stringArgs
@noKwargs
- def hash(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- if len(args) != 2:
- raise MesonException('method takes exactly two arguments.')
+ @typed_pos_args('fs.hash', (str, File), str)
+ def hash(self, state: 'ModuleState', args: T.Tuple['FileOrString', str], kwargs: T.Dict[str, T.Any]) -> str:
+ if isinstance(args[0], File):
+ FeatureNew('fs.hash_file', '0.59.0').use(state.subproject)
file = self._resolve_dir(state, args[0])
if not file.is_file():
- raise MesonException('{} is not a file and therefore cannot be hashed'.format(file))
+ raise MesonException(f'{file} is not a file and therefore cannot be hashed')
try:
h = hashlib.new(args[1])
except ValueError:
raise MesonException('hash algorithm {} is not available'.format(args[1]))
mlog.debug('computing {} sum of {} size {} bytes'.format(args[1], file, file.stat().st_size))
h.update(file.read_bytes())
- return ModuleReturnValue(h.hexdigest(), [])
+ return h.hexdigest()
- @stringArgs
@noKwargs
- def size(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- if len(args) != 1:
- raise MesonException('method takes exactly one argument.')
+ @typed_pos_args('fs.size', (str, File))
+ def size(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> int:
+ if isinstance(args[0], File):
+ FeatureNew('fs.size_file', '0.59.0').use(state.subproject)
file = self._resolve_dir(state, args[0])
if not file.is_file():
- raise MesonException('{} is not a file and therefore cannot be sized'.format(file))
+ raise MesonException(f'{file} is not a file and therefore cannot be sized')
try:
- return ModuleReturnValue(file.stat().st_size, [])
+ return file.stat().st_size
except ValueError:
raise MesonException('{} size could not be determined'.format(args[0]))
- @stringArgs
@noKwargs
- def is_samepath(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- if len(args) != 2:
- raise MesonException('fs.is_samepath takes exactly two arguments.')
+ @typed_pos_args('fs.is_samepath', (str, File), (str, File))
+ def is_samepath(self, state: 'ModuleState', args: T.Tuple['FileOrString', 'FileOrString'], kwargs: T.Dict[str, T.Any]) -> bool:
+ if isinstance(args[0], File) or isinstance(args[1], File):
+ FeatureNew('fs.is_samepath_file', '0.59.0').use(state.subproject)
file1 = self._resolve_dir(state, args[0])
file2 = self._resolve_dir(state, args[1])
if not file1.exists():
- return ModuleReturnValue(False, [])
+ return False
if not file2.exists():
- return ModuleReturnValue(False, [])
+ return False
try:
- return ModuleReturnValue(file1.samefile(file2), [])
+ return file1.samefile(file2)
except OSError:
- return ModuleReturnValue(False, [])
+ return False
- @stringArgs
@noKwargs
- def replace_suffix(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- if len(args) != 2:
- raise MesonException('method takes exactly two arguments.')
- original = PurePath(args[0])
+ @typed_pos_args('fs.replace_suffix', (str, File), str)
+ def replace_suffix(self, state: 'ModuleState', args: T.Tuple['FileOrString', str], kwargs: T.Dict[str, T.Any]) -> str:
+ if isinstance(args[0], File):
+ FeatureNew('fs.replace_suffix_file', '0.59.0').use(state.subproject)
+ original = PurePath(str(args[0]))
new = original.with_suffix(args[1])
- return ModuleReturnValue(str(new), [])
+ return str(new)
- @stringArgs
@noKwargs
- def parent(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- if len(args) != 1:
- raise MesonException('method takes exactly one argument.')
- original = PurePath(args[0])
+ @typed_pos_args('fs.parent', (str, File))
+ def parent(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
+ if isinstance(args[0], File):
+ FeatureNew('fs.parent_file', '0.59.0').use(state.subproject)
+ original = PurePath(str(args[0]))
new = original.parent
- return ModuleReturnValue(str(new), [])
+ return str(new)
- @stringArgs
@noKwargs
- def name(self, state: 'ModuleState', args: T.Sequence[str], kwargs: dict) -> ModuleReturnValue:
- if len(args) != 1:
- raise MesonException('method takes exactly one argument.')
- original = PurePath(args[0])
+ @typed_pos_args('fs.name', (str, File))
+ def name(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
+ if isinstance(args[0], File):
+ FeatureNew('fs.name_file', '0.59.0').use(state.subproject)
+ original = PurePath(str(args[0]))
new = original.name
- return ModuleReturnValue(str(new), [])
+ return str(new)
+
+ @noKwargs
+ @typed_pos_args('fs.stem', (str, File))
+ @FeatureNew('fs.stem', '0.54.0')
+ def stem(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: T.Dict[str, T.Any]) -> str:
+ if isinstance(args[0], File):
+ FeatureNew('fs.stem_file', '0.59.0').use(state.subproject)
+ original = PurePath(str(args[0]))
+ new = original.stem
+ return str(new)
+
+ @FeatureNew('fs.read', '0.57.0')
+ @typed_pos_args('fs.read', (str, File))
+ @typed_kwargs('fs.read', KwargInfo('encoding', str, default='utf-8'))
+ def read(self, state: 'ModuleState', args: T.Tuple['FileOrString'], kwargs: 'ReadKwArgs') -> str:
+ """Read a file from the source tree and return its value as a decoded
+ string.
+
+ If the encoding is not specified, the file is assumed to be utf-8
+ encoded. Paths must be relative by default (to prevent accidents) and
+ are forbidden to be read from the build directory (to prevent build
+ loops)
+ """
+ path = args[0]
+ encoding = kwargs['encoding']
+ src_dir = self.interpreter.environment.source_dir
+ sub_dir = self.interpreter.subdir
+ build_dir = self.interpreter.environment.get_build_dir()
+
+ if isinstance(path, File):
+ if path.is_built:
+ raise MesonException(
+ 'fs.read_file does not accept built files() objects')
+ path = os.path.join(src_dir, path.relative_name())
+ else:
+ if sub_dir:
+ src_dir = os.path.join(src_dir, sub_dir)
+ path = os.path.join(src_dir, path)
+
+ path = os.path.abspath(path)
+ if path_is_in_root(Path(path), Path(build_dir), resolve=True):
+ raise MesonException('path must not be in the build tree')
+ try:
+ with open(path, encoding=encoding) as f:
+ data = f.read()
+ except UnicodeDecodeError:
+ raise MesonException(f'decoding failed for {path}')
+ # Reconfigure when this file changes as it can contain data used by any
+ # part of the build configuration (e.g. `project(..., version:
+ # fs.read_file('VERSION')` or `configure_file(...)`
+ self.interpreter.add_build_def_file(path)
+ return data
+
-def initialize(*args, **kwargs) -> FSModule:
+def initialize(*args: T.Any, **kwargs: T.Any) -> FSModule:
return FSModule(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/gnome.py meson-0.61.2/mesonbuild/modules/gnome.py
--- meson-0.53.2/mesonbuild/modules/gnome.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/gnome.py 2022-02-14 19:03:13.000000000 +0000
@@ -15,24 +15,234 @@
'''This module provides helper functions for Gnome/GLib related
functionality such as gobject-introspection, gresources and gtk-doc'''
-import os
import copy
-import subprocess
import functools
+import os
+import subprocess
+import textwrap
+import typing as T
-from .. import build
-from .. import mlog
-from .. import mesonlib
-from .. import interpreter
-from . import GResourceTarget, GResourceHeaderTarget, GirTarget, TypelibTarget, VapiTarget
-from . import get_include_args
from . import ExtensionModule
+from . import GResourceTarget, GResourceHeaderTarget, GirTarget, TypelibTarget, VapiTarget
from . import ModuleReturnValue
+from .. import build
+from .. import interpreter
+from .. import mesonlib
+from .. import mlog
+from ..build import BuildTarget, CustomTarget, CustomTargetIndex, GeneratedList, InvalidArguments
+from ..dependencies import Dependency, PkgConfigDependency, InternalDependency
+from ..interpreter.type_checking import DEPENDS_KW, DEPEND_FILES_KW, INSTALL_KW, NoneType, in_set_validator
+from ..interpreterbase import noPosargs, noKwargs, FeatureNew, FeatureDeprecated
+from ..interpreterbase import typed_kwargs, KwargInfo, ContainerTypeInfo
+from ..interpreterbase.decorators import typed_pos_args
from ..mesonlib import (
- MachineChoice, MesonException, OrderedSet, Popen_safe, extract_as_list, join_args
+ MachineChoice, MesonException, OrderedSet, Popen_safe, join_args,
)
-from ..dependencies import Dependency, PkgConfigDependency, InternalDependency
-from ..interpreterbase import noKwargs, permittedKwargs, FeatureNew, FeatureNewKwargs
+from ..programs import ExternalProgram, OverrideProgram, EmptyExternalProgram
+from ..scripts.gettext import read_linguas
+
+if T.TYPE_CHECKING:
+ from typing_extensions import Literal, TypedDict
+
+ from . import ModuleState
+ from ..compilers import Compiler
+ from ..interpreter import Interpreter
+ from ..interpreterbase import TYPE_var, TYPE_kwargs
+ from ..mesonlib import FileOrString
+
+ class PostInstall(TypedDict):
+ glib_compile_schemas: bool
+ gio_querymodules: T.List[str]
+ gtk_update_icon_cache: bool
+ update_desktop_database: bool
+
+ class CompileSchemas(TypedDict):
+
+ build_by_default: bool
+ depend_files: T.List[FileOrString]
+
+ class Yelp(TypedDict):
+
+ languages: T.List[str]
+ media: T.List[str]
+ sources: T.List[str]
+ symlink_media: bool
+
+ class CompileResources(TypedDict):
+
+ build_by_default: bool
+ c_name: T.Optional[str]
+ dependencies: T.List[T.Union[mesonlib.File, build.CustomTarget, build.CustomTargetIndex]]
+ export: bool
+ extra_args: T.List[str]
+ gresource_bundle: bool
+ install: bool
+ install_dir: T.Optional[str]
+ install_header: bool
+ source_dir: T.List[str]
+
+ class GenerateGir(TypedDict):
+
+ build_by_default: bool
+ dependencies: T.List[Dependency]
+ export_packages: T.List[str]
+ extra_args: T.List[str]
+ fatal_warnings: bool
+ header: T.List[str]
+ identifier_prefix: T.List[str]
+ include_directories: T.List[T.Union[build.IncludeDirs, str]]
+ includes: T.List[T.Union[str, GirTarget]]
+ install: bool
+ install_dir_gir: T.Optional[str]
+ install_dir_typelib: T.Optional[str]
+ link_with: T.List[T.Union[build.SharedLibrary, build.StaticLibrary]]
+ namespace: str
+ nsversion: str
+ sources: T.List[T.Union[FileOrString, build.GeneratedTypes]]
+ symbol_prefix: T.List[str]
+
+ class GtkDoc(TypedDict):
+
+ src_dir: T.List[T.Union[str, build.IncludeDirs]]
+ main_sgml: str
+ main_xml: str
+ module_version: str
+ namespace: str
+ mode: Literal['xml', 'smgl', 'auto', 'none']
+ html_args: T.List[str]
+ scan_args: T.List[str]
+ scanobjs_args: T.List[str]
+ fixxref_args: T.List[str]
+ mkdb_args: T.List[str]
+ content_files: T.List[T.Union[build.GeneratedTypes, FileOrString]]
+ ignore_headers: T.List[str]
+ install_dir: T.List[str]
+ check: bool
+ install: bool
+ gobject_typesfile: T.List[FileOrString]
+ html_assets: T.List[FileOrString]
+ expand_content_files: T.List[FileOrString]
+ c_args: T.List[str]
+ include_directories: T.List[T.Union[str, build.IncludeDirs]]
+ dependencies: T.List[T.Union[Dependency, build.SharedLibrary, build.StaticLibrary]]
+
+ class GdbusCodegen(TypedDict):
+
+ sources: T.List[FileOrString]
+ extra_args: T.List[str]
+ interface_prefix: T.Optional[str]
+ namespace: T.Optional[str]
+ object_manager: bool
+ build_by_default: bool
+ annotations: T.List[T.List[str]]
+ install_header: bool
+ install_dir: T.Optional[str]
+ docbook: T.Optional[str]
+ autocleanup: Literal['all', 'none', 'objects', 'default']
+
+ class GenMarshal(TypedDict):
+
+ build_always: T.Optional[str]
+ build_always_stale: T.Optional[bool]
+ build_by_default: T.Optional[bool]
+ depend_files: T.List[mesonlib.File]
+ extra_args: T.List[str]
+ install_dir: T.List[T.Union[str, bool]]
+ install_header: bool
+ internal: bool
+ nostdinc: bool
+ prefix: T.Optional[str]
+ skip_source: bool
+ sources: T.List[FileOrString]
+ stdinc: bool
+ valist_marshallers: bool
+
+ class GenerateVapi(TypedDict):
+
+ sources: T.List[T.Union[str, GirTarget]]
+ install_dir: T.Optional[str]
+ install: bool
+ vapi_dirs: T.List[str]
+ metadata_dirs: T.List[str]
+ gir_dirs: T.List[str]
+ packages: T.List[T.Union[str, InternalDependency]]
+
+ class _MkEnumsCommon(TypedDict):
+
+ sources: T.List[T.Union[FileOrString, build.GeneratedTypes]]
+ install_header: bool
+ install_dir: T.Optional[str]
+ identifier_prefix: T.Optional[str]
+ symbol_prefix: T.Optional[str]
+
+ class MkEnumsSimple(_MkEnumsCommon):
+
+ header_prefix: str
+ decorator: str
+ function_prefix: str
+ body_prefix: str
+
+ class MkEnums(_MkEnumsCommon):
+
+ c_template: T.Optional[FileOrString]
+ h_template: T.Optional[FileOrString]
+ comments: T.Optional[str]
+ eprod: T.Optional[str]
+ fhead: T.Optional[str]
+ fprod: T.Optional[str]
+ ftail: T.Optional[str]
+ vhead: T.Optional[str]
+ vprod: T.Optional[str]
+ vtail: T.Optional[str]
+ depends: T.List[T.Union[BuildTarget, CustomTarget, CustomTargetIndex]]
+
+
+# Differs from the CustomTarget version in that it straight defaults to True
+_BUILD_BY_DEFAULT: KwargInfo[bool] = KwargInfo(
+ 'build_by_default', bool, default=True,
+)
+
+_EXTRA_ARGS_KW: KwargInfo[T.List[str]] = KwargInfo(
+ 'extra_args',
+ ContainerTypeInfo(list, str),
+ default=[],
+ listify=True,
+)
+
+_MK_ENUMS_COMMON_KWS: T.List[KwargInfo] = [
+ INSTALL_KW.evolve(name='install_header'),
+ KwargInfo(
+ 'sources',
+ ContainerTypeInfo(list, (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)),
+ listify=True,
+ required=True,
+ ),
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('identifier_prefix', (str, NoneType)),
+ KwargInfo('symbol_prefix', (str, NoneType)),
+]
+
+def annotations_validator(annotations: T.List[T.Union[str, T.List[str]]]) -> T.Optional[str]:
+ """Validate gdbus-codegen annotations argument"""
+
+ badlist = 'must be made up of 3 strings for ELEMENT, KEY, and VALUE'
+
+ if not annotations:
+ return None
+ elif all(isinstance(annot, str) for annot in annotations):
+ if len(annotations) == 3:
+ return None
+ else:
+ return badlist
+ elif not all(isinstance(annot, list) for annot in annotations):
+ for c, annot in enumerate(annotations):
+ if not isinstance(annot, list):
+ return f'element {c+1} must be a list'
+ else:
+ for c, annot in enumerate(annotations):
+ if len(annot) != 3 or not all(isinstance(i, str) for i in annot):
+ return f'element {c+1} {badlist}'
+ return None
# gresource compilation is broken due to the way
# the resource compiler and Ninja clash about it
@@ -43,25 +253,32 @@
native_glib_version = None
-@functools.lru_cache(maxsize=None)
-def gir_has_option(intr_obj, option):
- try:
- g_ir_scanner = intr_obj.find_program_impl('g-ir-scanner')
- # Handle overridden g-ir-scanner
- if isinstance(getattr(g_ir_scanner, "held_object", g_ir_scanner), interpreter.OverrideProgram):
- assert option in ['--extra-library', '--sources-top-dirs']
- return True
-
- opts = Popen_safe(g_ir_scanner.get_command() + ['--help'], stderr=subprocess.STDOUT)[1]
- return option in opts
- except (MesonException, FileNotFoundError, subprocess.CalledProcessError):
- return False
-
class GnomeModule(ExtensionModule):
- gir_dep = None
+ def __init__(self, interpreter: 'Interpreter') -> None:
+ super().__init__(interpreter)
+ self.gir_dep = None
+ self.install_glib_compile_schemas = False
+ self.install_gio_querymodules = []
+ self.install_gtk_update_icon_cache = False
+ self.install_update_desktop_database = False
+ self.devenv = None
+ self.methods.update({
+ 'post_install': self.post_install,
+ 'compile_resources': self.compile_resources,
+ 'generate_gir': self.generate_gir,
+ 'compile_schemas': self.compile_schemas,
+ 'yelp': self.yelp,
+ 'gtkdoc': self.gtkdoc,
+ 'gtkdoc_html_dir': self.gtkdoc_html_dir,
+ 'gdbus_codegen': self.gdbus_codegen,
+ 'mkenums': self.mkenums,
+ 'mkenums_simple': self.mkenums_simple,
+ 'genmarshal': self.genmarshal,
+ 'generate_vapi': self.generate_vapi,
+ })
@staticmethod
- def _get_native_glib_version(state):
+ def _get_native_glib_version(state: 'ModuleState') -> str:
global native_glib_version
if native_glib_version is None:
glib_dep = PkgConfigDependency('glib-2.0', state.environment,
@@ -75,7 +292,7 @@
return native_glib_version
@mesonlib.run_once
- def __print_gresources_warning(self, state):
+ def __print_gresources_warning(self, state: 'ModuleState') -> None:
if not mesonlib.version_compare(self._get_native_glib_version(state),
gresource_dep_needed_version):
mlog.warning('GLib compiled dependencies do not work reliably with \n'
@@ -83,67 +300,144 @@
mlog.bold('https://bugzilla.gnome.org/show_bug.cgi?id=774368'))
@staticmethod
- @mesonlib.run_once
- def _print_gdbus_warning():
+ def _print_gdbus_warning() -> None:
mlog.warning('Code generated with gdbus_codegen() requires the root directory be added to\n'
' include_directories of targets with GLib < 2.51.3:',
- mlog.bold('https://github.com/mesonbuild/meson/issues/1387'))
+ mlog.bold('https://github.com/mesonbuild/meson/issues/1387'),
+ once=True)
+
+ def _get_dep(self, state: 'ModuleState', depname: str, native: bool = False,
+ required: bool = True) -> Dependency:
+ kwargs = {'native': native, 'required': required}
+ return self.interpreter.func_dependency(state.current_node, [depname], kwargs)
+
+ def _get_native_binary(self, state: 'ModuleState', name: str, depname: str,
+ varname: str, required: bool = True) -> T.Union[ExternalProgram, OverrideProgram, 'build.Executable']:
+ # Look in overrides in case glib/gtk/etc are built as subproject
+ prog = self.interpreter.program_from_overrides([name], [])
+ if prog is not None:
+ return prog
+
+ # Look in machine file
+ prog_list = state.environment.lookup_binary_entry(MachineChoice.HOST, name)
+ if prog_list is not None:
+ return ExternalProgram.from_entry(name, prog_list)
+
+ # Check if pkgconfig has a variable
+ dep = self._get_dep(state, depname, native=True, required=False)
+ if dep.found() and dep.type_name == 'pkgconfig':
+ value = dep.get_pkgconfig_variable(varname, {})
+ if value:
+ return ExternalProgram(name, [value])
+
+ # Normal program lookup
+ return state.find_program(name, required=required)
+
+ @typed_kwargs('gnome.post_install',
+ KwargInfo('glib_compile_schemas', bool, default=False),
+ KwargInfo('gio_querymodules', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('gtk_update_icon_cache', bool, default=False),
+ KwargInfo('update_desktop_database', bool, default=False, since='0.59.0'),
+ )
+ @noPosargs
+ @FeatureNew('gnome.post_install', '0.57.0')
+ def post_install(self, state: 'ModuleState', args: T.List['TYPE_var'], kwargs: 'PostInstall') -> ModuleReturnValue:
+ rv: T.List['build.ExecutableSerialisation'] = []
+ datadir_abs = os.path.join(state.environment.get_prefix(), state.environment.get_datadir())
+ if kwargs['glib_compile_schemas'] and not self.install_glib_compile_schemas:
+ self.install_glib_compile_schemas = True
+ prog = self._get_native_binary(state, 'glib-compile-schemas', 'gio-2.0', 'glib_compile_schemas')
+ schemasdir = os.path.join(datadir_abs, 'glib-2.0', 'schemas')
+ script = state.backend.get_executable_serialisation([prog, schemasdir])
+ script.skip_if_destdir = True
+ rv.append(script)
+ for d in kwargs['gio_querymodules']:
+ if d not in self.install_gio_querymodules:
+ self.install_gio_querymodules.append(d)
+ prog = self._get_native_binary(state, 'gio-querymodules', 'gio-2.0', 'gio_querymodules')
+ moduledir = os.path.join(state.environment.get_prefix(), d)
+ script = state.backend.get_executable_serialisation([prog, moduledir])
+ script.skip_if_destdir = True
+ rv.append(script)
+ if kwargs['gtk_update_icon_cache'] and not self.install_gtk_update_icon_cache:
+ self.install_gtk_update_icon_cache = True
+ prog = self._get_native_binary(state, 'gtk4-update-icon-cache', 'gtk4', 'gtk4_update_icon_cache', required=False)
+ found = isinstance(prog, build.Executable) or prog.found()
+ if not found:
+ prog = self._get_native_binary(state, 'gtk-update-icon-cache', 'gtk+-3.0', 'gtk_update_icon_cache')
+ icondir = os.path.join(datadir_abs, 'icons', 'hicolor')
+ script = state.backend.get_executable_serialisation([prog, '-q', '-t', '-f', icondir])
+ script.skip_if_destdir = True
+ rv.append(script)
+ if kwargs['update_desktop_database'] and not self.install_update_desktop_database:
+ self.install_update_desktop_database = True
+ prog = self._get_native_binary(state, 'update-desktop-database', 'desktop-file-utils', 'update_desktop_database')
+ appdir = os.path.join(datadir_abs, 'applications')
+ script = state.backend.get_executable_serialisation([prog, '-q', appdir])
+ script.skip_if_destdir = True
+ rv.append(script)
+ return ModuleReturnValue(None, rv)
- @FeatureNewKwargs('gnome.compile_resources', '0.37.0', ['gresource_bundle', 'export', 'install_header'])
- @permittedKwargs({'source_dir', 'c_name', 'dependencies', 'export', 'gresource_bundle', 'install_header',
- 'install', 'install_dir', 'extra_args', 'build_by_default'})
- def compile_resources(self, state, args, kwargs):
+ @typed_pos_args('gnome.compile_resources', str, (str, mesonlib.File))
+ @typed_kwargs(
+ 'gnome.compile_resources',
+ _BUILD_BY_DEFAULT,
+ _EXTRA_ARGS_KW,
+ INSTALL_KW,
+ INSTALL_KW.evolve(name='install_header', since='0.37.0'),
+ KwargInfo('c_name', (str, NoneType)),
+ KwargInfo('dependencies', ContainerTypeInfo(list, (mesonlib.File, build.CustomTarget, build.CustomTargetIndex)), default=[], listify=True),
+ KwargInfo('export', bool, default=False, since='0.37.0'),
+ KwargInfo('gresource_bundle', bool, default=False, since='0.37.0'),
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('source_dir', ContainerTypeInfo(list, str), default=[], listify=True),
+ )
+ def compile_resources(self, state: 'ModuleState', args: T.Tuple[str, 'FileOrString'],
+ kwargs: 'CompileResources') -> 'ModuleReturnValue':
self.__print_gresources_warning(state)
glib_version = self._get_native_glib_version(state)
- cmd = ['glib-compile-resources', '@INPUT@']
+ glib_compile_resources = state.find_program('glib-compile-resources')
+ cmd = [glib_compile_resources, '@INPUT@']
- source_dirs, dependencies = mesonlib.extract_as_list(kwargs, 'source_dir', 'dependencies', pop=True)
+ source_dirs = kwargs['source_dir']
+ dependencies = kwargs['dependencies']
- if len(args) < 2:
- raise MesonException('Not enough arguments; the name of the resource '
- 'and the path to the XML file are required')
+ target_name, input_file = args
# Validate dependencies
- for (ii, dep) in enumerate(dependencies):
- if hasattr(dep, 'held_object'):
- dependencies[ii] = dep = dep.held_object
- if not isinstance(dep, (mesonlib.File, build.CustomTarget, build.CustomTargetIndex)):
- m = 'Unexpected dependency type {!r} for gnome.compile_resources() ' \
- '"dependencies" argument.\nPlease pass the return value of ' \
- 'custom_target() or configure_file()'
- raise MesonException(m.format(dep))
- if isinstance(dep, (build.CustomTarget, build.CustomTargetIndex)):
+ subdirs: T.List[str] = []
+ depends: T.List[T.Union[build.CustomTarget, build.CustomTargetIndex]] = []
+ for dep in dependencies:
+ if isinstance(dep, mesonlib.File):
+ subdirs.append(dep.subdir)
+ else:
+ depends.append(dep)
+ subdirs.append(dep.get_subdir())
if not mesonlib.version_compare(glib_version, gresource_dep_needed_version):
m = 'The "dependencies" argument of gnome.compile_resources() can not\n' \
'be used with the current version of glib-compile-resources due to\n' \
''
raise MesonException(m)
- ifile = args[1]
- if isinstance(ifile, mesonlib.File):
- # glib-compile-resources will be run inside the source dir,
- # so we need either 'src_to_build' or the absolute path.
- # Absolute path is the easiest choice.
- if ifile.is_built:
- ifile = os.path.join(state.environment.get_build_dir(), ifile.subdir, ifile.fname)
+ if not mesonlib.version_compare(glib_version, gresource_dep_needed_version):
+ # Resource xml files generated at build-time cannot be used with
+ # gnome.compile_resources() because we need to scan the xml for
+ # dependencies. Use configure_file() instead to generate it at
+ # configure-time
+ if isinstance(input_file, mesonlib.File):
+ # glib-compile-resources will be run inside the source dir,
+ # so we need either 'src_to_build' or the absolute path.
+ # Absolute path is the easiest choice.
+ if input_file.is_built:
+ ifile = os.path.join(state.environment.get_build_dir(), input_file.subdir, input_file.fname)
+ else:
+ ifile = os.path.join(input_file.subdir, input_file.fname)
else:
- ifile = os.path.join(ifile.subdir, ifile.fname)
- elif isinstance(ifile, str):
- ifile = os.path.join(state.subdir, ifile)
- elif isinstance(ifile, (interpreter.CustomTargetHolder,
- interpreter.CustomTargetIndexHolder,
- interpreter.GeneratedObjectsHolder)):
- m = 'Resource xml files generated at build-time cannot be used ' \
- 'with gnome.compile_resources() because we need to scan ' \
- 'the xml for dependencies. Use configure_file() instead ' \
- 'to generate it at configure-time.'
- raise MesonException(m)
- else:
- raise MesonException('Invalid file argument: {!r}'.format(ifile))
+ ifile = os.path.join(state.subdir, input_file)
- depend_files, depends, subdirs = self._get_gresource_dependencies(
- state, ifile, source_dirs, dependencies)
+ depend_files, depends, subdirs = self._get_gresource_dependencies(
+ state, ifile, source_dirs, dependencies)
# Make source dirs relative to build dir now
source_dirs = [os.path.join(state.build_to_src, state.subdir, d) for d in source_dirs]
@@ -155,67 +449,77 @@
for source_dir in OrderedSet(source_dirs):
cmd += ['--sourcedir', source_dir]
- if 'c_name' in kwargs:
- cmd += ['--c-name', kwargs.pop('c_name')]
- export = kwargs.pop('export', False)
- if not export:
+ if kwargs['c_name']:
+ cmd += ['--c-name', kwargs['c_name']]
+ if not kwargs['export']:
cmd += ['--internal']
cmd += ['--generate', '--target', '@OUTPUT@']
+ cmd += kwargs['extra_args']
- cmd += mesonlib.stringlistify(kwargs.pop('extra_args', []))
-
- gresource = kwargs.pop('gresource_bundle', False)
+ gresource = kwargs['gresource_bundle']
if gresource:
- output = args[0] + '.gresource'
- name = args[0] + '_gresource'
+ output = f'{target_name}.gresource'
+ name = f'{target_name}_gresource'
else:
- output = args[0] + '.c'
- name = args[0] + '_c'
+ if 'c' in state.environment.coredata.compilers.host:
+ output = f'{target_name}.c'
+ name = f'{target_name}_c'
+ elif 'cpp' in state.environment.coredata.compilers.host:
+ output = f'{target_name}.cpp'
+ name = f'{target_name}_cpp'
+ else:
+ raise MesonException('Compiling GResources into code is only supported in C and C++ projects')
- if kwargs.get('install', False) and not gresource:
+ if kwargs['install'] and not gresource:
raise MesonException('The install kwarg only applies to gresource bundles, see install_header')
- install_header = kwargs.pop('install_header', False)
+ install_header = kwargs['install_header']
if install_header and gresource:
raise MesonException('The install_header kwarg does not apply to gresource bundles')
- if install_header and not export:
+ if install_header and not kwargs['export']:
raise MesonException('GResource header is installed yet export is not enabled')
- kwargs['input'] = args[1]
- kwargs['output'] = output
- kwargs['depends'] = depends
+ c_kwargs: T.Dict[str, T.Any] = {
+ 'build_by_default': kwargs['build_by_default'],
+ 'depends': depends,
+ 'input': input_file,
+ 'install': kwargs['install'],
+ 'install_dir': kwargs['install_dir'] or [],
+ 'output': output,
+ }
if not mesonlib.version_compare(glib_version, gresource_dep_needed_version):
# This will eventually go out of sync if dependencies are added
- kwargs['depend_files'] = depend_files
- kwargs['command'] = cmd
+ c_kwargs['depend_files'] = depend_files
+ c_kwargs['command'] = cmd
else:
- depfile = kwargs['output'] + '.d'
- kwargs['depfile'] = depfile
- kwargs['command'] = copy.copy(cmd) + ['--dependency-file', '@DEPFILE@']
- target_c = GResourceTarget(name, state.subdir, state.subproject, kwargs)
+ depfile = f'{output}.d'
+ c_kwargs['depfile'] = depfile
+ c_kwargs['command'] = copy.copy(cmd) + ['--dependency-file', '@DEPFILE@']
+ target_c = GResourceTarget(name, state.subdir, state.subproject, c_kwargs)
if gresource: # Only one target for .gresource files
return ModuleReturnValue(target_c, [target_c])
- h_kwargs = {
+ h_kwargs: T.Dict[str, T.Any] = {
'command': cmd,
- 'input': args[1],
- 'output': args[0] + '.h',
+ 'input': input_file,
+ 'output': f'{target_name}.h',
# The header doesn't actually care about the files yet it errors if missing
- 'depends': depends
+ 'depends': depends,
+ 'build_by_default': kwargs['build_by_default'],
+ 'install_dir': kwargs['install_dir'] or [state.environment.coredata.get_option(mesonlib.OptionKey('includedir'))],
}
- if 'build_by_default' in kwargs:
- h_kwargs['build_by_default'] = kwargs['build_by_default']
if install_header:
h_kwargs['install'] = install_header
- h_kwargs['install_dir'] = kwargs.get('install_dir',
- state.environment.coredata.get_builtin_option('includedir'))
- target_h = GResourceHeaderTarget(args[0] + '_h', state.subdir, state.subproject, h_kwargs)
+ target_h = GResourceHeaderTarget(f'{target_name}_h', state.subdir, state.subproject, h_kwargs)
rv = [target_c, target_h]
return ModuleReturnValue(rv, rv)
- def _get_gresource_dependencies(self, state, input_file, source_dirs, dependencies):
+ def _get_gresource_dependencies(
+ self, state: 'ModuleState', input_file: str, source_dirs: T.List[str],
+ dependencies: T.Sequence[T.Union[mesonlib.File, build.CustomTarget, build.CustomTargetIndex]]
+ ) -> T.Tuple[T.List[mesonlib.FileOrString], T.List[T.Union[build.CustomTarget, build.CustomTargetIndex]], T.List[str]]:
cmd = ['glib-compile-resources',
input_file,
@@ -226,25 +530,27 @@
for source_dir in source_dirs:
cmd += ['--sourcedir', os.path.join(state.subdir, source_dir)]
- pc, stdout, stderr = Popen_safe(cmd, cwd=state.environment.get_source_dir())
+ try:
+ pc, stdout, stderr = Popen_safe(cmd, cwd=state.environment.get_source_dir())
+ except (FileNotFoundError, PermissionError):
+ raise MesonException('Could not execute glib-compile-resources.')
if pc.returncode != 0:
- m = 'glib-compile-resources failed to get dependencies for {}:\n{}'
- mlog.warning(m.format(cmd[1], stderr))
+ m = f'glib-compile-resources failed to get dependencies for {cmd[1]}:\n{stderr}'
+ mlog.warning(m)
raise subprocess.CalledProcessError(pc.returncode, cmd)
- dep_files = stdout.split('\n')[:-1]
+ raw_dep_files: T.List[str] = stdout.split('\n')[:-1]
- depends = []
- subdirs = []
- for resfile in dep_files[:]:
+ depends: T.List[T.Union[build.CustomTarget, build.CustomTargetIndex]] = []
+ subdirs: T.List[str] = []
+ dep_files: T.List[mesonlib.FileOrString] = []
+ for resfile in raw_dep_files.copy():
resbasename = os.path.basename(resfile)
for dep in dependencies:
- if hasattr(dep, 'held_object'):
- dep = dep.held_object
if isinstance(dep, mesonlib.File):
if dep.fname != resbasename:
continue
- dep_files.remove(resfile)
+ raw_dep_files.remove(resfile)
dep_files.append(dep)
subdirs.append(dep.subdir)
break
@@ -256,7 +562,7 @@
fname = o
break
if fname is not None:
- dep_files.remove(resfile)
+ raw_dep_files.remove(resfile)
depends.append(dep)
subdirs.append(dep.get_subdir())
break
@@ -274,17 +580,21 @@
".", resfile)
except MesonException:
raise MesonException(
- 'Resource "%s" listed in "%s" was not found. If this is a '
- 'generated file, pass the target that generates it to '
- 'gnome.compile_resources() using the "dependencies" '
- 'keyword argument.' % (resfile, input_file))
- dep_files.remove(resfile)
+ f'Resource "{resfile}" listed in "{input_file}" was not found. '
+ 'If this is a generated file, pass the target that generates '
+ 'it to gnome.compile_resources() using the "dependencies" '
+ 'keyword argument.')
+ raw_dep_files.remove(resfile)
dep_files.append(f)
+ dep_files.extend(raw_dep_files)
return dep_files, depends, subdirs
- def _get_link_args(self, state, lib, depends, include_rpath=False,
- use_gir_args=False):
- link_command = []
+ def _get_link_args(self, state: 'ModuleState',
+ lib: T.Union[build.SharedLibrary, build.StaticLibrary],
+ depends: T.List[build.BuildTarget],
+ include_rpath: bool = False,
+ use_gir_args: bool = False) -> T.List[str]:
+ link_command: T.List[str] = []
# Construct link args
if isinstance(lib, build.SharedLibrary):
libdir = os.path.join(state.environment.get_build_dir(), state.backend.get_target_dir(lib))
@@ -301,30 +611,36 @@
link_command.append('-L' + d)
if include_rpath:
link_command.append('-Wl,-rpath,' + d)
- if gir_has_option(self.interpreter, '--extra-library') and use_gir_args:
+ if use_gir_args and self._gir_has_option('--extra-library'):
link_command.append('--extra-library=' + lib.name)
else:
link_command.append('-l' + lib.name)
return link_command
- def _get_dependencies_flags(self, deps, state, depends, include_rpath=False,
- use_gir_args=False, separate_nodedup=False):
- cflags = OrderedSet()
- internal_ldflags = OrderedSet()
- external_ldflags = OrderedSet()
+ def _get_dependencies_flags(
+ self, deps: T.Sequence[T.Union['Dependency', build.SharedLibrary, build.StaticLibrary]],
+ state: 'ModuleState', depends: T.List[build.BuildTarget], include_rpath: bool = False,
+ use_gir_args: bool = False, separate_nodedup: bool = False
+ ) -> T.Tuple[OrderedSet[str], OrderedSet[str], OrderedSet[str], T.Optional[T.List[str]], OrderedSet[str]]:
+ cflags: OrderedSet[str] = OrderedSet()
+ internal_ldflags: OrderedSet[str] = OrderedSet()
+ external_ldflags: OrderedSet[str] = OrderedSet()
# External linker flags that can't be de-duped reliably because they
# require two args in order, such as -framework AVFoundation
- external_ldflags_nodedup = []
- gi_includes = OrderedSet()
- deps = mesonlib.listify(deps, unholder=True)
+ external_ldflags_nodedup: T.List[str] = []
+ gi_includes: OrderedSet[str] = OrderedSet()
+ deps = mesonlib.listify(deps)
for dep in deps:
+ if isinstance(dep, Dependency):
+ girdir = dep.get_variable(pkgconfig='girdir', internal='girdir', default_value='')
+ if girdir:
+ assert isinstance(girdir, str), 'for mypy'
+ gi_includes.update([girdir])
if isinstance(dep, InternalDependency):
cflags.update(dep.get_compile_args())
- cflags.update(get_include_args(dep.include_directories))
+ cflags.update(state.get_include_args(dep.include_directories))
for lib in dep.libraries:
- if hasattr(lib, 'held_object'):
- lib = lib.held_object
if isinstance(lib, build.SharedLibrary):
internal_ldflags.update(self._get_link_args(state, lib, depends, include_rpath))
libdepflags = self._get_dependencies_flags(lib.get_external_deps(), state, depends, include_rpath,
@@ -342,8 +658,6 @@
external_ldflags_nodedup += extdepflags[3]
gi_includes.update(extdepflags[4])
for source in dep.sources:
- if hasattr(source, 'held_object'):
- source = source.held_object
if isinstance(source, GirTarget):
gi_includes.update([os.path.join(state.environment.get_build_dir(),
source.get_subdir())])
@@ -351,43 +665,38 @@
elif isinstance(dep, Dependency):
cflags.update(dep.get_compile_args())
ldflags = iter(dep.get_link_args(raw=True))
- for lib in ldflags:
- if (os.path.isabs(lib) and
+ for flag in ldflags:
+ if (os.path.isabs(flag) and
# For PkgConfigDependency only:
getattr(dep, 'is_libtool', False)):
- lib_dir = os.path.dirname(lib)
- external_ldflags.update(["-L%s" % lib_dir])
+ lib_dir = os.path.dirname(flag)
+ external_ldflags.update([f'-L{lib_dir}'])
if include_rpath:
- external_ldflags.update(['-Wl,-rpath {}'.format(lib_dir)])
- libname = os.path.basename(lib)
+ external_ldflags.update([f'-Wl,-rpath {lib_dir}'])
+ libname = os.path.basename(flag)
if libname.startswith("lib"):
libname = libname[3:]
libname = libname.split(".so")[0]
- lib = "-l%s" % libname
+ flag = f"-l{libname}"
# FIXME: Hack to avoid passing some compiler options in
- if lib.startswith("-W"):
+ if flag.startswith("-W"):
continue
# If it's a framework arg, slurp the framework name too
# to preserve the order of arguments
- if lib == '-framework':
- external_ldflags_nodedup += [lib, next(ldflags)]
+ if flag == '-framework':
+ external_ldflags_nodedup += [flag, next(ldflags)]
else:
- external_ldflags.update([lib])
-
- if isinstance(dep, PkgConfigDependency):
- girdir = dep.get_pkgconfig_variable("girdir", {'default': ''})
- if girdir:
- gi_includes.update([girdir])
+ external_ldflags.update([flag])
elif isinstance(dep, (build.StaticLibrary, build.SharedLibrary)):
- cflags.update(get_include_args(dep.get_include_dirs()))
+ cflags.update(state.get_include_args(dep.get_include_dirs()))
depends.append(dep)
else:
- mlog.log('dependency {!r} not handled to build gir files'.format(dep))
+ mlog.log(f'dependency {dep!r} not handled to build gir files')
continue
- if gir_has_option(self.interpreter, '--extra-library') and use_gir_args:
- def fix_ldflags(ldflags):
- fixed_ldflags = OrderedSet()
+ if use_gir_args and self._gir_has_option('--extra-library'):
+ def fix_ldflags(ldflags: T.Iterable[str]) -> OrderedSet[str]:
+ fixed_ldflags: OrderedSet[str] = OrderedSet()
for ldflag in ldflags:
if ldflag.startswith("-l"):
ldflag = ldflag.replace('-l', '--extra-library=', 1)
@@ -397,17 +706,15 @@
external_ldflags = fix_ldflags(external_ldflags)
if not separate_nodedup:
external_ldflags.update(external_ldflags_nodedup)
- return cflags, internal_ldflags, external_ldflags, gi_includes
+ return cflags, internal_ldflags, external_ldflags, None, gi_includes
else:
return cflags, internal_ldflags, external_ldflags, external_ldflags_nodedup, gi_includes
- def _unwrap_gir_target(self, girtarget, state):
- while hasattr(girtarget, 'held_object'):
- girtarget = girtarget.held_object
-
+ def _unwrap_gir_target(self, girtarget: T.Union[build.Executable, build.StaticLibrary, build.SharedLibrary], state: 'ModuleState'
+ ) -> T.Union[build.Executable, build.StaticLibrary, build.SharedLibrary]:
if not isinstance(girtarget, (build.Executable, build.SharedLibrary,
build.StaticLibrary)):
- raise MesonException('Gir target must be an executable or library')
+ raise MesonException(f'Gir target must be an executable or library but is "{girtarget}" of type {type(girtarget).__name__}')
STATIC_BUILD_REQUIRED_VERSION = ">=1.58.1"
if isinstance(girtarget, (build.StaticLibrary)) and \
@@ -418,109 +725,49 @@
return girtarget
- def _get_gir_dep(self, state):
- try:
- gir_dep = self.gir_dep or PkgConfigDependency('gobject-introspection-1.0',
- state.environment,
- {'native': True})
- pkgargs = gir_dep.get_compile_args()
- except Exception:
- raise MesonException('gobject-introspection dependency was not found, gir cannot be generated.')
-
- return gir_dep, pkgargs
-
- def _scan_header(self, kwargs):
- ret = []
- header = kwargs.pop('header', None)
- if header:
- if not isinstance(header, str):
- raise MesonException('header must be a string')
- ret = ['--c-include=' + header]
- return ret
-
- def _scan_extra_args(self, kwargs):
- return mesonlib.stringlistify(kwargs.pop('extra_args', []))
-
- def _scan_link_withs(self, state, depends, kwargs):
- ret = []
- if 'link_with' in kwargs:
- link_with = mesonlib.extract_as_list(kwargs, 'link_with', pop = True)
-
- for link in link_with:
- ret += self._get_link_args(state, link.held_object, depends,
- use_gir_args=True)
- return ret
+ def _devenv_prepend(self, varname: str, value: str) -> None:
+ if self.devenv is None:
+ self.devenv = build.EnvironmentVariables()
+ self.interpreter.build.devenv.append(self.devenv)
+ self.devenv.prepend(varname, [value])
+
+ def _get_gir_dep(self, state: 'ModuleState') -> T.Tuple[Dependency, T.Union[build.Executable, 'ExternalProgram', 'OverrideProgram'],
+ T.Union[build.Executable, 'ExternalProgram', 'OverrideProgram']]:
+ if not self.gir_dep:
+ self.gir_dep = self._get_dep(state, 'gobject-introspection-1.0')
+ self.giscanner = self._get_native_binary(state, 'g-ir-scanner', 'gobject-introspection-1.0', 'g_ir_scanner')
+ self.gicompiler = self._get_native_binary(state, 'g-ir-compiler', 'gobject-introspection-1.0', 'g_ir_compiler')
+ return self.gir_dep, self.giscanner, self.gicompiler
+
+ @functools.lru_cache(maxsize=None)
+ def _gir_has_option(self, option: str) -> bool:
+ exe = self.giscanner
+ if isinstance(exe, OverrideProgram):
+ # Handle overridden g-ir-scanner
+ assert option in {'--extra-library', '--sources-top-dirs'}
+ return True
+ p, o, _ = Popen_safe(exe.get_command() + ['--help'], stderr=subprocess.STDOUT)
+ return p.returncode == 0 and option in o
# May mutate depends and gir_inc_dirs
- def _scan_include(self, state, depends, gir_inc_dirs, kwargs):
- ret = []
+ def _scan_include(self, state: 'ModuleState', includes: T.List[T.Union[str, GirTarget]]
+ ) -> T.Tuple[T.List[str], T.List[str], T.List[GirTarget]]:
+ ret: T.List[str] = []
+ gir_inc_dirs: T.List[str] = []
+ depends: T.List[GirTarget] = []
+
+ for inc in includes:
+ if isinstance(inc, str):
+ ret += [f'--include={inc}']
+ elif isinstance(inc, GirTarget):
+ gir_inc_dirs .append(os.path.join(state.environment.get_build_dir(), inc.get_subdir()))
+ ret.append(f"--include-uninstalled={os.path.join(inc.get_subdir(), inc.get_basename())}")
+ depends.append(inc)
- if 'includes' in kwargs:
- includes = mesonlib.extract_as_list(kwargs, 'includes', pop = True)
- for inc in includes:
- if hasattr(inc, 'held_object'):
- inc = inc.held_object
- if isinstance(inc, str):
- ret += ['--include=%s' % (inc, )]
- elif isinstance(inc, GirTarget):
- gir_inc_dirs += [
- os.path.join(state.environment.get_build_dir(),
- inc.get_subdir()),
- ]
- ret += [
- "--include-uninstalled=%s" % (os.path.join(inc.get_subdir(), inc.get_basename()), )
- ]
- depends += [inc]
- else:
- raise MesonException(
- 'Gir includes must be str, GirTarget, or list of them')
-
- return ret
+ return ret, gir_inc_dirs, depends
- def _scan_symbol_prefix(self, kwargs):
- ret = []
-
- if 'symbol_prefix' in kwargs:
- sym_prefixes = mesonlib.stringlistify(kwargs.pop('symbol_prefix', []))
- ret += ['--symbol-prefix=%s' % sym_prefix for sym_prefix in sym_prefixes]
-
- return ret
-
- def _scan_identifier_prefix(self, kwargs):
- ret = []
-
- if 'identifier_prefix' in kwargs:
- identifier_prefix = kwargs.pop('identifier_prefix')
- if not isinstance(identifier_prefix, str):
- raise MesonException('Gir identifier prefix must be str')
- ret += ['--identifier-prefix=%s' % identifier_prefix]
-
- return ret
-
- def _scan_export_packages(self, kwargs):
- ret = []
-
- if 'export_packages' in kwargs:
- pkgs = kwargs.pop('export_packages')
- if isinstance(pkgs, str):
- ret += ['--pkg-export=%s' % pkgs]
- elif isinstance(pkgs, list):
- ret += ['--pkg-export=%s' % pkg for pkg in pkgs]
- else:
- raise MesonException('Gir export packages must be str or list')
-
- return ret
-
- def _scan_inc_dirs(self, kwargs):
- ret = mesonlib.extract_as_list(kwargs, 'include_directories', pop = True)
- for incd in ret:
- if not isinstance(incd.held_object, (str, build.IncludeDirs)):
- raise MesonException(
- 'Gir include dirs should be include_directories().')
- return ret
-
- def _scan_langs(self, state, langs):
- ret = []
+ def _scan_langs(self, state: 'ModuleState', langs: T.Iterable[str]) -> T.List[str]:
+ ret: T.List[str] = []
for lang in langs:
link_args = state.environment.coredata.get_external_link_args(MachineChoice.HOST, lang)
@@ -530,8 +777,8 @@
return ret
- def _scan_gir_targets(self, state, girtargets):
- ret = []
+ def _scan_gir_targets(self, state: 'ModuleState', girtargets: T.Sequence[build.BuildTarget]) -> T.List[T.Union[str, build.Executable]]:
+ ret: T.List[T.Union[str, build.Executable]] = []
for girtarget in girtargets:
if isinstance(girtarget, build.Executable):
@@ -539,15 +786,20 @@
else:
# Because of https://gitlab.gnome.org/GNOME/gobject-introspection/merge_requests/72
# we can't use the full path until this is merged.
+ libpath = os.path.join(girtarget.get_subdir(), girtarget.get_filename())
+ # Must use absolute paths here because g-ir-scanner will not
+ # add them to the runtime path list if they're relative. This
+ # means we cannot use @BUILD_ROOT@
+ build_root = state.environment.get_build_dir()
if isinstance(girtarget, build.SharedLibrary):
+ # need to put our output directory first as we need to use the
+ # generated libraries instead of any possibly installed system/prefix
+ # ones.
+ ret += ["-L{}/{}".format(build_root, os.path.dirname(libpath))]
libname = girtarget.get_basename()
else:
- libname = os.path.join("@PRIVATE_OUTDIR_ABS_%s@" % girtarget.get_id(), girtarget.get_filename())
+ libname = os.path.join(f"{build_root}/{libpath}")
ret += ['--library', libname]
- # need to put our output directory first as we need to use the
- # generated libraries instead of any possibly installed system/prefix
- # ones.
- ret += ["-L@PRIVATE_OUTDIR_ABS_%s@" % girtarget.get_id()]
# Needed for the following binutils bug:
# https://github.com/mesonbuild/meson/issues/1911
# However, g-ir-scanner does not understand -Wl,-rpath
@@ -558,8 +810,8 @@
return ret
- def _get_girtargets_langs_compilers(self, girtargets):
- ret = []
+ def _get_girtargets_langs_compilers(self, girtargets: T.Sequence[build.BuildTarget]) -> T.List[T.Tuple[str, 'Compiler']]:
+ ret: T.List[T.Tuple[str, 'Compiler']] = []
for girtarget in girtargets:
for lang, compiler in girtarget.compilers.items():
# XXX: Can you use g-i with any other language?
@@ -569,31 +821,33 @@
return ret
- def _get_gir_targets_deps(self, girtargets):
- ret = []
+ def _get_gir_targets_deps(self, girtargets: T.Sequence[build.BuildTarget]
+ ) -> T.List[T.Union[build.Target, Dependency]]:
+ ret: T.List[T.Union[build.Target, Dependency]] = []
for girtarget in girtargets:
ret += girtarget.get_all_link_deps()
ret += girtarget.get_external_deps()
return ret
- def _get_gir_targets_inc_dirs(self, girtargets):
- ret = []
+ def _get_gir_targets_inc_dirs(self, girtargets: T.Sequence[build.BuildTarget]) -> T.List[build.IncludeDirs]:
+ ret: T.List[build.IncludeDirs] = []
for girtarget in girtargets:
ret += girtarget.get_include_dirs()
return ret
- def _get_langs_compilers_flags(self, state, langs_compilers):
- cflags = []
- internal_ldflags = []
- external_ldflags = []
+ def _get_langs_compilers_flags(self, state: 'ModuleState', langs_compilers: T.List[T.Tuple[str, 'Compiler']]
+ ) -> T.Tuple[T.List[str], T.List[str], T.List[str]]:
+ cflags: T.List[str] = []
+ internal_ldflags: T.List[str] = []
+ external_ldflags: T.List[str] = []
for lang, compiler in langs_compilers:
if state.global_args.get(lang):
cflags += state.global_args[lang]
if state.project_args.get(lang):
cflags += state.project_args[lang]
- if 'b_sanitize' in compiler.base_options:
- sanitize = state.environment.coredata.base_options['b_sanitize'].value
+ if mesonlib.OptionKey('b_sanitize') in compiler.base_options:
+ sanitize = state.environment.coredata.options[mesonlib.OptionKey('b_sanitize')].value
cflags += compiler.sanitizer_compile_args(sanitize)
sanitize = sanitize.split(',')
# These must be first in ldflags
@@ -609,16 +863,19 @@
return cflags, internal_ldflags, external_ldflags
- def _make_gir_filelist(self, state, srcdir, ns, nsversion, girtargets, libsources):
+ def _make_gir_filelist(self, state: 'ModuleState', srcdir: str, ns: str,
+ nsversion: str, girtargets: T.Sequence[build.BuildTarget],
+ libsources: T.Sequence[T.Union[
+ str, mesonlib.File, build.GeneratedList,
+ build.CustomTarget, build.CustomTargetIndex]]
+ ) -> str:
gir_filelist_dir = state.backend.get_target_private_dir_abs(girtargets[0])
if not os.path.isdir(gir_filelist_dir):
os.mkdir(gir_filelist_dir)
- gir_filelist_filename = os.path.join(gir_filelist_dir, '%s_%s_gir_filelist' % (ns, nsversion))
+ gir_filelist_filename = os.path.join(gir_filelist_dir, f'{ns}_{nsversion}_gir_filelist')
with open(gir_filelist_filename, 'w', encoding='utf-8') as gir_filelist:
for s in libsources:
- if hasattr(s, 'held_object'):
- s = s.held_object
if isinstance(s, (build.CustomTarget, build.CustomTargetIndex)):
for custom_output in s.get_outputs():
gir_filelist.write(os.path.join(state.environment.get_build_dir(),
@@ -634,52 +891,68 @@
return gir_filelist_filename
- def _make_gir_target(self, state, girfile, scan_command, depends, kwargs):
- scankwargs = {'output': girfile,
- 'command': scan_command,
- 'depends': depends}
-
- if 'install' in kwargs:
- scankwargs['install'] = kwargs['install']
- scankwargs['install_dir'] = kwargs.get('install_dir_gir',
- os.path.join(state.environment.get_datadir(), 'gir-1.0'))
-
- if 'build_by_default' in kwargs:
- scankwargs['build_by_default'] = kwargs['build_by_default']
+ def _make_gir_target(self, state: 'ModuleState', girfile: str, scan_command: T.List[str],
+ generated_files: T.Sequence[T.Union[str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]],
+ depends: T.List[build.Target], kwargs: T.Dict[str, T.Any]) -> GirTarget:
+ install = kwargs['install_gir']
+ if install is None:
+ install = kwargs['install']
+
+ install_dir = kwargs['install_dir_gir']
+ if install_dir is None:
+ install_dir = os.path.join(state.environment.get_datadir(), 'gir-1.0')
+ elif install_dir is False:
+ install = False
+
+ scankwargs = {
+ 'input': generated_files,
+ 'output': girfile,
+ 'command': scan_command,
+ 'depends': depends,
+ 'install': install,
+ 'install_dir': install_dir,
+ 'install_tag': 'devel',
+ 'build_by_default': kwargs['build_by_default'],
+ }
return GirTarget(girfile, state.subdir, state.subproject, scankwargs)
- def _make_typelib_target(self, state, typelib_output, typelib_cmd, kwargs):
+ def _make_typelib_target(self, state: 'ModuleState', typelib_output: str, typelib_cmd: T.List[str],
+ generated_files: T.Sequence[T.Union[str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]],
+ kwargs: T.Dict[str, T.Any]) -> TypelibTarget:
+ install = kwargs['install_typelib']
+ if install is None:
+ install = kwargs['install']
+
+ install_dir = kwargs['install_dir_typelib']
+ if install_dir is None:
+ install_dir = os.path.join(state.environment.get_libdir(), 'girepository-1.0')
+ elif install_dir is False:
+ install = False
+
typelib_kwargs = {
- 'output': typelib_output,
+ 'input': generated_files,
+ 'output': [typelib_output],
'command': typelib_cmd,
+ 'install': install,
+ 'install_dir': install_dir,
+ 'install_tag': 'typelib',
+ 'build_by_default': kwargs['build_by_default'],
}
- if 'install' in kwargs:
- typelib_kwargs['install'] = kwargs['install']
- typelib_kwargs['install_dir'] = kwargs.get('install_dir_typelib',
- os.path.join(state.environment.get_libdir(), 'girepository-1.0'))
-
- if 'build_by_default' in kwargs:
- typelib_kwargs['build_by_default'] = kwargs['build_by_default']
-
return TypelibTarget(typelib_output, state.subdir, state.subproject, typelib_kwargs)
# May mutate depends
- def _gather_typelib_includes_and_update_depends(self, state, deps, depends):
+ def _gather_typelib_includes_and_update_depends(self, state: 'ModuleState', deps: T.List[Dependency], depends: T.List[build.Target]) -> T.List[str]:
# Need to recursively add deps on GirTarget sources from our
# dependencies and also find the include directories needed for the
# typelib generation custom target below.
- typelib_includes = []
+ typelib_includes: T.List[str] = []
for dep in deps:
- if hasattr(dep, 'held_object'):
- dep = dep.held_object
# Add a dependency on each GirTarget listed in dependencies and add
# the directory where it will be generated to the typelib includes
if isinstance(dep, InternalDependency):
for source in dep.sources:
- if hasattr(source, 'held_object'):
- source = source.held_object
if isinstance(source, GirTarget) and source not in depends:
depends.append(source)
subdir = os.path.join(state.environment.get_build_dir(),
@@ -698,295 +971,399 @@
source.get_subdir())
if subdir not in typelib_includes:
typelib_includes.append(subdir)
- elif isinstance(dep, PkgConfigDependency):
- girdir = dep.get_pkgconfig_variable("girdir", {'default': ''})
+ if isinstance(dep, Dependency):
+ girdir = dep.get_variable(pkgconfig='girdir', internal='girdir', default_value='')
+ assert isinstance(girdir, str), 'for mypy'
if girdir and girdir not in typelib_includes:
typelib_includes.append(girdir)
-
return typelib_includes
- def _get_external_args_for_langs(self, state, langs):
- ret = []
+ def _get_external_args_for_langs(self, state: 'ModuleState', langs: T.Sequence[str]) -> T.List[str]:
+ ret: T.List[str] = []
for lang in langs:
- ret += state.environment.coredata.get_external_args(MachineChoice.HOST, lang)
+ ret += mesonlib.listify(state.environment.coredata.get_external_args(MachineChoice.HOST, lang))
return ret
@staticmethod
- def _get_scanner_cflags(cflags):
+ def _get_scanner_cflags(cflags: T.Iterable[str]) -> T.Iterable[str]:
'g-ir-scanner only accepts -I/-D/-U; must ignore all other flags'
for f in cflags:
- if f.startswith(('-D', '-U', '-I')):
+ # _FORTIFY_SOURCE depends on / works together with -O, on the other hand this
+ # just invokes the preprocessor anyway
+ if f.startswith(('-D', '-U', '-I')) and not f.startswith('-D_FORTIFY_SOURCE'):
yield f
@staticmethod
- def _get_scanner_ldflags(ldflags):
+ def _get_scanner_ldflags(ldflags: T.Iterable[str]) -> T.Iterable[str]:
'g-ir-scanner only accepts -L/-l; must ignore -F and other linker flags'
for f in ldflags:
if f.startswith(('-L', '-l', '--extra-library')):
yield f
- @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
- @permittedKwargs({'sources', 'nsversion', 'namespace', 'symbol_prefix', 'identifier_prefix',
- 'export_packages', 'includes', 'dependencies', 'link_with', 'include_directories',
- 'install', 'install_dir_gir', 'install_dir_typelib', 'extra_args',
- 'packages', 'header', 'build_by_default'})
- def generate_gir(self, state, args, kwargs):
- if not args:
- raise MesonException('generate_gir takes at least one argument')
- if kwargs.get('install_dir'):
- raise MesonException('install_dir is not supported with generate_gir(), see "install_dir_gir" and "install_dir_typelib"')
-
- giscanner = self.interpreter.find_program_impl('g-ir-scanner')
- gicompiler = self.interpreter.find_program_impl('g-ir-compiler')
-
- girtargets = [self._unwrap_gir_target(arg, state) for arg in args]
-
+ @typed_pos_args('gnome.generate_gir', varargs=(build.Executable, build.SharedLibrary, build.StaticLibrary), min_varargs=1)
+ @typed_kwargs(
+ 'gnome.generate_gir',
+ INSTALL_KW,
+ _BUILD_BY_DEFAULT.evolve(since='0.40.0'),
+ _EXTRA_ARGS_KW,
+ KwargInfo('dependencies', ContainerTypeInfo(list, Dependency), default=[], listify=True),
+ KwargInfo('export_packages', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('fatal_warnings', bool, default=False, since='0.55.0'),
+ KwargInfo('header', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('identifier_prefix', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('include_directories', ContainerTypeInfo(list, (str, build.IncludeDirs)), default=[], listify=True),
+ KwargInfo('includes', ContainerTypeInfo(list, (str, GirTarget)), default=[], listify=True),
+ KwargInfo('install_gir', (bool, NoneType), since='0.61.0'),
+ KwargInfo('install_dir_gir', (str, bool, NoneType),
+ deprecated_values={False: ('0.61.0', 'Use install_gir to disable installation')},
+ validator=lambda x: 'as boolean can only be false' if x is True else None),
+ KwargInfo('install_typelib', (bool, NoneType), since='0.61.0'),
+ KwargInfo('install_dir_typelib', (str, bool, NoneType),
+ deprecated_values={False: ('0.61.0', 'Use install_typelib to disable installation')},
+ validator=lambda x: 'as boolean can only be false' if x is True else None),
+ KwargInfo('link_with', ContainerTypeInfo(list, (build.SharedLibrary, build.StaticLibrary)), default=[], listify=True),
+ KwargInfo('namespace', str, required=True),
+ KwargInfo('nsversion', str, required=True),
+ KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex)), default=[], listify=True),
+ KwargInfo('symbol_prefix', ContainerTypeInfo(list, str), default=[], listify=True),
+ )
+ def generate_gir(self, state: 'ModuleState', args: T.Tuple[T.List[T.Union[build.Executable, build.SharedLibrary, build.StaticLibrary]]],
+ kwargs: 'GenerateGir') -> ModuleReturnValue:
+ girtargets = [self._unwrap_gir_target(arg, state) for arg in args[0]]
if len(girtargets) > 1 and any([isinstance(el, build.Executable) for el in girtargets]):
raise MesonException('generate_gir only accepts a single argument when one of the arguments is an executable')
- self.gir_dep, pkgargs = self._get_gir_dep(state)
+ gir_dep, giscanner, gicompiler = self._get_gir_dep(state)
+
+ ns = kwargs['namespace']
+ nsversion = kwargs['nsversion']
+ libsources = kwargs['sources']
- ns = kwargs.pop('namespace')
- nsversion = kwargs.pop('nsversion')
- libsources = mesonlib.extract_as_list(kwargs, 'sources', pop=True)
- girfile = '%s-%s.gir' % (ns, nsversion)
+ girfile = f'{ns}-{nsversion}.gir'
srcdir = os.path.join(state.environment.get_source_dir(), state.subdir)
builddir = os.path.join(state.environment.get_build_dir(), state.subdir)
- depends = [] + girtargets
- gir_inc_dirs = []
+
+ depends: T.List[T.Union['FileOrString', build.GeneratedTypes, build.Executable, build.SharedLibrary, build.StaticLibrary]] = []
+ depends.extend(gir_dep.sources)
+ depends.extend(girtargets)
+
langs_compilers = self._get_girtargets_langs_compilers(girtargets)
cflags, internal_ldflags, external_ldflags = self._get_langs_compilers_flags(state, langs_compilers)
deps = self._get_gir_targets_deps(girtargets)
- deps += extract_as_list(kwargs, 'dependencies', pop=True, unholder=True)
+ deps += kwargs['dependencies']
+ deps += [gir_dep]
typelib_includes = self._gather_typelib_includes_and_update_depends(state, deps, depends)
# ldflags will be misinterpreted by gir scanner (showing
# spurious dependencies) but building GStreamer fails if they
# are not used here.
- dep_cflags, dep_internal_ldflags, dep_external_ldflags, gi_includes = \
+ dep_cflags, dep_internal_ldflags, dep_external_ldflags, _, gi_includes = \
self._get_dependencies_flags(deps, state, depends, use_gir_args=True)
- cflags += list(self._get_scanner_cflags(dep_cflags))
- cflags += list(self._get_scanner_cflags(self._get_external_args_for_langs(state, [lc[0] for lc in langs_compilers])))
- internal_ldflags += list(self._get_scanner_ldflags(dep_internal_ldflags))
- external_ldflags += list(self._get_scanner_ldflags(dep_external_ldflags))
+ scan_cflags = []
+ scan_cflags += list(self._get_scanner_cflags(cflags))
+ scan_cflags += list(self._get_scanner_cflags(dep_cflags))
+ scan_cflags += list(self._get_scanner_cflags(self._get_external_args_for_langs(state, [lc[0] for lc in langs_compilers])))
+ scan_internal_ldflags = []
+ scan_internal_ldflags += list(self._get_scanner_ldflags(internal_ldflags))
+ scan_internal_ldflags += list(self._get_scanner_ldflags(dep_internal_ldflags))
+ scan_external_ldflags = []
+ scan_external_ldflags += list(self._get_scanner_ldflags(external_ldflags))
+ scan_external_ldflags += list(self._get_scanner_ldflags(dep_external_ldflags))
girtargets_inc_dirs = self._get_gir_targets_inc_dirs(girtargets)
- inc_dirs = self._scan_inc_dirs(kwargs)
+ inc_dirs = kwargs['include_directories']
- scan_command = [giscanner]
- scan_command += pkgargs
+ gir_inc_dirs: T.List[str] = []
+
+ scan_command: T.List[T.Union[str, build.Executable, 'ExternalProgram', 'OverrideProgram']] = [giscanner]
scan_command += ['--no-libtool']
scan_command += ['--namespace=' + ns, '--nsversion=' + nsversion]
scan_command += ['--warn-all']
scan_command += ['--output', '@OUTPUT@']
- scan_command += self._scan_header(kwargs)
- scan_command += self._scan_extra_args(kwargs)
+ scan_command += [f'--c-include={h}' for h in kwargs['header']]
+ scan_command += kwargs['extra_args']
scan_command += ['-I' + srcdir, '-I' + builddir]
- scan_command += get_include_args(girtargets_inc_dirs)
+ scan_command += state.get_include_args(girtargets_inc_dirs)
scan_command += ['--filelist=' + self._make_gir_filelist(state, srcdir, ns, nsversion, girtargets, libsources)]
- scan_command += self._scan_link_withs(state, depends, kwargs)
- scan_command += self._scan_include(state, depends, gir_inc_dirs, kwargs)
- scan_command += self._scan_symbol_prefix(kwargs)
- scan_command += self._scan_identifier_prefix(kwargs)
- scan_command += self._scan_export_packages(kwargs)
+ scan_command += mesonlib.listify([self._get_link_args(state, l, depends, use_gir_args=True)
+ for l in kwargs['link_with']])
+
+ _cmd, _ginc, _deps = self._scan_include(state, kwargs['includes'])
+ scan_command.extend(_cmd)
+ gir_inc_dirs.extend(_ginc)
+ depends.extend(_deps)
+
+ scan_command += [f'--symbol-prefix={p}' for p in kwargs['symbol_prefix']]
+ scan_command += [f'--identifier-prefix={p}' for p in kwargs['identifier_prefix']]
+ scan_command += [f'--pkg-export={p}' for p in kwargs['export_packages']]
scan_command += ['--cflags-begin']
- scan_command += cflags
+ scan_command += scan_cflags
scan_command += ['--cflags-end']
- scan_command += get_include_args(inc_dirs)
- scan_command += get_include_args(list(gi_includes) + gir_inc_dirs + inc_dirs, prefix='--add-include-path=')
- scan_command += list(internal_ldflags)
+ scan_command += state.get_include_args(inc_dirs)
+ scan_command += state.get_include_args(list(gi_includes) + gir_inc_dirs + inc_dirs, prefix='--add-include-path=')
+ scan_command += list(scan_internal_ldflags)
scan_command += self._scan_gir_targets(state, girtargets)
scan_command += self._scan_langs(state, [lc[0] for lc in langs_compilers])
- scan_command += list(external_ldflags)
+ scan_command += list(scan_external_ldflags)
- if gir_has_option(self.interpreter, '--sources-top-dirs'):
+ if self._gir_has_option('--sources-top-dirs'):
scan_command += ['--sources-top-dirs', os.path.join(state.environment.get_source_dir(), self.interpreter.subproject_dir, state.subproject)]
scan_command += ['--sources-top-dirs', os.path.join(state.environment.get_build_dir(), self.interpreter.subproject_dir, state.subproject)]
- scan_target = self._make_gir_target(state, girfile, scan_command, depends, kwargs)
+ if '--warn-error' in scan_command:
+ FeatureDeprecated.single_use('gnome.generate_gir argument --warn-error', '0.55.0',
+ state.subproject, 'Use "fatal_warnings" keyword argument', state.current_node)
+ if kwargs['fatal_warnings']:
+ scan_command.append('--warn-error')
- typelib_output = '%s-%s.typelib' % (ns, nsversion)
+ generated_files = [f for f in libsources if isinstance(f, (GeneratedList, CustomTarget, CustomTargetIndex))]
+
+ scan_target = self._make_gir_target(state, girfile, scan_command, generated_files, depends, kwargs)
+
+ typelib_output = f'{ns}-{nsversion}.typelib'
typelib_cmd = [gicompiler, scan_target, '--output', '@OUTPUT@']
- typelib_cmd += get_include_args(gir_inc_dirs, prefix='--includedir=')
+ typelib_cmd += state.get_include_args(gir_inc_dirs, prefix='--includedir=')
for incdir in typelib_includes:
typelib_cmd += ["--includedir=" + incdir]
- typelib_target = self._make_typelib_target(state, typelib_output, typelib_cmd, kwargs)
+ typelib_target = self._make_typelib_target(state, typelib_output, typelib_cmd, generated_files, kwargs)
+
+ self._devenv_prepend('GI_TYPELIB_PATH', os.path.join(state.environment.get_build_dir(), state.subdir))
rv = [scan_target, typelib_target]
return ModuleReturnValue(rv, rv)
- @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
- @permittedKwargs({'build_by_default', 'depend_files'})
- def compile_schemas(self, state, args, kwargs):
- if args:
- raise MesonException('Compile_schemas does not take positional arguments.')
+ @noPosargs
+ @typed_kwargs('gnome.compile_schemas', _BUILD_BY_DEFAULT.evolve(since='0.40.0'), DEPEND_FILES_KW)
+ def compile_schemas(self, state: 'ModuleState', args: T.List['TYPE_var'], kwargs: 'CompileSchemas') -> ModuleReturnValue:
srcdir = os.path.join(state.build_to_src, state.subdir)
outdir = state.subdir
- cmd = [self.interpreter.find_program_impl('glib-compile-schemas')]
- cmd += ['--targetdir', outdir, srcdir]
- kwargs['command'] = cmd
- kwargs['input'] = []
- kwargs['output'] = 'gschemas.compiled'
+ cmd = [state.find_program('glib-compile-schemas'), '--targetdir', outdir, srcdir]
+ ct_kwargs = T.cast(T.Dict[str, T.Any], kwargs.copy())
+ ct_kwargs['command'] = cmd
+ ct_kwargs['input'] = []
+ ct_kwargs['output'] = 'gschemas.compiled'
if state.subdir == '':
targetname = 'gsettings-compile'
else:
targetname = 'gsettings-compile-' + state.subdir.replace('/', '_')
- target_g = build.CustomTarget(targetname, state.subdir, state.subproject, kwargs)
+ target_g = build.CustomTarget(targetname, state.subdir, state.subproject, ct_kwargs)
+ self._devenv_prepend('GSETTINGS_SCHEMA_DIR', os.path.join(state.environment.get_build_dir(), state.subdir))
return ModuleReturnValue(target_g, [target_g])
- @permittedKwargs({'sources', 'media', 'symlink_media', 'languages'})
- def yelp(self, state, args, kwargs):
- if len(args) < 1:
- raise MesonException('Yelp requires a project id')
-
+ @typed_pos_args('gnome.yelp', str, varargs=str)
+ @typed_kwargs(
+ 'gnome.yelp',
+ KwargInfo(
+ 'languages', ContainerTypeInfo(list, str),
+ listify=True, default=[],
+ deprecated='0.43.0',
+ deprecated_message='Use a LINGUAS file in the source directory instead',
+ ),
+ KwargInfo('media', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('sources', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('symlink_media', bool, default=True),
+ )
+ def yelp(self, state: 'ModuleState', args: T.Tuple[str, T.List[str]], kwargs: 'Yelp') -> ModuleReturnValue:
project_id = args[0]
- sources = mesonlib.stringlistify(kwargs.pop('sources', []))
+ sources = kwargs['sources']
+ if args[1]:
+ FeatureDeprecated.single_use('gnome.yelp more than one positional argument', '0.60.0',
+ state.subproject, 'use the "sources" keyword argument instead.', state.current_node)
if not sources:
- if len(args) > 1:
- sources = mesonlib.stringlistify(args[1:])
+ sources = args[1]
if not sources:
raise MesonException('Yelp requires a list of sources')
- source_str = '@@'.join(sources)
-
- langs = mesonlib.stringlistify(kwargs.pop('languages', []))
- if langs:
- mlog.deprecation('''The "languages" argument of gnome.yelp() is deprecated.
-Use a LINGUAS file in the sources directory instead.
-This will become a hard error in the future.''')
-
- media = mesonlib.stringlistify(kwargs.pop('media', []))
- symlinks = kwargs.pop('symlink_media', True)
-
- if not isinstance(symlinks, bool):
- raise MesonException('symlink_media must be a boolean')
-
- if kwargs:
- raise MesonException('Unknown arguments passed: {}'.format(', '.join(kwargs.keys())))
-
- script = state.environment.get_build_command()
- args = ['--internal',
- 'yelphelper',
- 'install',
- '--subdir=' + state.subdir,
- '--id=' + project_id,
- '--installdir=' + os.path.join(state.environment.get_datadir(), 'help'),
- '--sources=' + source_str]
- if symlinks:
- args.append('--symlinks=true')
- if media:
- args.append('--media=' + '@@'.join(media))
- if langs:
- args.append('--langs=' + '@@'.join(langs))
- inscript = build.RunScript(script, args)
-
- potargs = state.environment.get_build_command() + [
- '--internal', 'yelphelper', 'pot',
- '--subdir=' + state.subdir,
- '--id=' + project_id,
- '--sources=' + source_str,
- ]
- pottarget = build.RunTarget('help-' + project_id + '-pot', potargs[0],
- potargs[1:], [], state.subdir, state.subproject)
-
- poargs = state.environment.get_build_command() + [
- '--internal', 'yelphelper', 'update-po',
- '--subdir=' + state.subdir,
- '--id=' + project_id,
- '--sources=' + source_str,
- '--langs=' + '@@'.join(langs),
- ]
- potarget = build.RunTarget('help-' + project_id + '-update-po', poargs[0],
- poargs[1:], [], state.subdir, state.subproject)
-
- rv = [inscript, pottarget, potarget]
- return ModuleReturnValue(None, rv)
-
- @FeatureNewKwargs('gnome.gtkdoc', '0.52.0', ['check'])
- @FeatureNewKwargs('gnome.gtkdoc', '0.48.0', ['c_args'])
- @FeatureNewKwargs('gnome.gtkdoc', '0.48.0', ['module_version'])
- @FeatureNewKwargs('gnome.gtkdoc', '0.37.0', ['namespace', 'mode'])
- @permittedKwargs({'main_xml', 'main_sgml', 'src_dir', 'dependencies', 'install',
- 'install_dir', 'scan_args', 'scanobjs_args', 'gobject_typesfile',
- 'fixxref_args', 'html_args', 'html_assets', 'content_files',
- 'mkdb_args', 'ignore_headers', 'include_directories',
- 'namespace', 'mode', 'expand_content_files', 'module_version',
- 'c_args'})
- def gtkdoc(self, state, args, kwargs):
- if len(args) != 1:
- raise MesonException('Gtkdoc must have one positional argument.')
+ elif args[1]:
+ mlog.warning('"gnome.yelp" ignores positional sources arguments when the "sources" keyword argument is set')
+ sources_files = [mesonlib.File.from_source_file(state.environment.source_dir,
+ os.path.join(state.subdir, 'C'),
+ s) for s in sources]
+
+ langs = kwargs['languages']
+ if not langs:
+ langs = read_linguas(os.path.join(state.environment.source_dir, state.subdir))
+
+ media = kwargs['media']
+ symlinks = kwargs['symlink_media']
+ targets: T.List[T.Union['Target', build.Data, build.SymlinkData]] = []
+ potargets: T.List[build.RunTarget] = []
+
+ itstool = state.find_program('itstool')
+ msgmerge = state.find_program('msgmerge')
+ msgfmt = state.find_program('msgfmt')
+
+ install_dir = os.path.join(state.environment.get_datadir(), 'help')
+ c_install_dir = os.path.join(install_dir, 'C', project_id)
+ c_data = build.Data(sources_files, c_install_dir, c_install_dir,
+ mesonlib.FileMode(), state.subproject)
+ targets.append(c_data)
+
+ media_files: T.List[mesonlib.File] = []
+ for m in media:
+ f = mesonlib.File.from_source_file(state.environment.source_dir,
+ os.path.join(state.subdir, 'C'), m)
+ media_files.append(f)
+ m_install_dir = os.path.join(c_install_dir, os.path.dirname(m))
+ m_data = build.Data([f], m_install_dir, m_install_dir,
+ mesonlib.FileMode(), state.subproject)
+ targets.append(m_data)
+
+ pot_file = os.path.join('@SOURCE_ROOT@', state.subdir, 'C', project_id + '.pot')
+ pot_sources = [os.path.join('@SOURCE_ROOT@', state.subdir, 'C', s) for s in sources]
+ pot_args = [itstool, '-o', pot_file] + pot_sources
+ pottarget = build.RunTarget(f'help-{project_id}-pot', pot_args, [],
+ os.path.join(state.subdir, 'C'), state.subproject)
+ targets.append(pottarget)
+
+ for l in langs:
+ l_subdir = os.path.join(state.subdir, l)
+ l_install_dir = os.path.join(install_dir, l, project_id)
+
+ for i, m in enumerate(media):
+ m_dir = os.path.dirname(m)
+ m_install_dir = os.path.join(l_install_dir, m_dir)
+ if symlinks:
+ link_target = os.path.join(os.path.relpath(c_install_dir, start=m_install_dir), m)
+ l_data = build.SymlinkData(link_target, os.path.basename(m),
+ m_install_dir, state.subproject)
+ else:
+ try:
+ m_file = mesonlib.File.from_source_file(state.environment.source_dir, l_subdir, m)
+ except MesonException:
+ m_file = media_files[i]
+ l_data = build.Data([m_file], m_install_dir, m_install_dir,
+ mesonlib.FileMode(), state.subproject)
+ targets.append(l_data)
+
+ po_file = l + '.po'
+ po_args = [msgmerge, '-q', '-o',
+ os.path.join('@SOURCE_ROOT@', l_subdir, po_file),
+ os.path.join('@SOURCE_ROOT@', l_subdir, po_file), pot_file]
+ potarget = build.RunTarget(f'help-{project_id}-{l}-update-po',
+ po_args, [pottarget], l_subdir, state.subproject)
+ targets.append(potarget)
+ potargets.append(potarget)
+
+ gmo_file = project_id + '-' + l + '.gmo'
+ gmo_kwargs = {'command': [msgfmt, '@INPUT@', '-o', '@OUTPUT@'],
+ 'input': po_file,
+ 'output': gmo_file,
+ }
+ gmotarget = build.CustomTarget(f'help-{project_id}-{l}-gmo', l_subdir, state.subproject, gmo_kwargs)
+ targets.append(gmotarget)
+
+ merge_kwargs = {'command': [itstool, '-m', os.path.join(l_subdir, gmo_file),
+ '-o', '@OUTDIR@', '@INPUT@'],
+ 'input': sources_files,
+ 'output': sources,
+ 'depends': gmotarget,
+ 'install': True,
+ 'install_dir': l_install_dir,
+ }
+ mergetarget = build.CustomTarget(f'help-{project_id}-{l}', l_subdir, state.subproject, merge_kwargs)
+ targets.append(mergetarget)
+
+ allpotarget = build.AliasTarget(f'help-{project_id}-update-po', potargets,
+ state.subdir, state.subproject)
+ targets.append(allpotarget)
+
+ return ModuleReturnValue(None, targets)
+
+ @typed_pos_args('gnome.gtkdoc', str)
+ @typed_kwargs(
+ 'gnome.gtkdoc',
+ KwargInfo('c_args', ContainerTypeInfo(list, str), since='0.48.0', default=[], listify=True),
+ KwargInfo('check', bool, default=False, since='0.52.0'),
+ KwargInfo('content_files', ContainerTypeInfo(list, (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex)), default=[], listify=True),
+ KwargInfo(
+ 'dependencies',
+ ContainerTypeInfo(list, (Dependency, build.SharedLibrary, build.StaticLibrary)),
+ listify=True, default=[]),
+ KwargInfo('expand_content_files', ContainerTypeInfo(list, (str, mesonlib.File)), default=[], listify=True),
+ KwargInfo('fixxref_args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('gobject_typesfile', ContainerTypeInfo(list, (str, mesonlib.File)), default=[], listify=True),
+ KwargInfo('html_args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('html_assets', ContainerTypeInfo(list, (str, mesonlib.File)), default=[], listify=True),
+ KwargInfo('ignore_headers', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo(
+ 'include_directories',
+ ContainerTypeInfo(list, (str, build.IncludeDirs)),
+ listify=True, default=[]),
+ KwargInfo('install', bool, default=True),
+ KwargInfo('install_dir', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('main_sgml', (str, NoneType)),
+ KwargInfo('main_xml', (str, NoneType)),
+ KwargInfo('mkdb_args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo(
+ 'mode', str, default='auto', since='0.37.0',
+ validator=in_set_validator({'xml', 'sgml', 'none', 'auto'})),
+ KwargInfo('module_version', str, default='', since='0.48.0'),
+ KwargInfo('namespace', str, default='', since='0.37.0'),
+ KwargInfo('scan_args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('scanobjs_args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('src_dir', ContainerTypeInfo(list, (str, build.IncludeDirs)), listify=True, required=True),
+ )
+ def gtkdoc(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'GtkDoc') -> ModuleReturnValue:
modulename = args[0]
- if not isinstance(modulename, str):
- raise MesonException('Gtkdoc arg must be string.')
- if 'src_dir' not in kwargs:
- raise MesonException('Keyword argument src_dir missing.')
- main_file = kwargs.get('main_sgml', '')
- if not isinstance(main_file, str):
- raise MesonException('Main sgml keyword argument must be a string.')
- main_xml = kwargs.get('main_xml', '')
- if not isinstance(main_xml, str):
- raise MesonException('Main xml keyword argument must be a string.')
- moduleversion = kwargs.get('module_version', '')
- if not isinstance(moduleversion, str):
- raise MesonException('Module version keyword argument must be a string.')
- if main_xml != '':
- if main_file != '':
- raise MesonException('You can only specify main_xml or main_sgml, not both.')
+ main_file = kwargs['main_sgml']
+ main_xml = kwargs['main_xml']
+ if main_xml is not None:
+ if main_file is not None:
+ raise InvalidArguments('gnome.gtkdoc: main_xml and main_sgml are exclusive arguments')
main_file = main_xml
+ moduleversion = kwargs['module_version']
targetname = modulename + ('-' + moduleversion if moduleversion else '') + '-doc'
command = state.environment.get_build_command()
- namespace = kwargs.get('namespace', '')
- mode = kwargs.get('mode', 'auto')
- VALID_MODES = ('xml', 'sgml', 'none', 'auto')
- if mode not in VALID_MODES:
- raise MesonException('gtkdoc: Mode {} is not a valid mode: {}'.format(mode, VALID_MODES))
+ namespace = kwargs['namespace']
+
+ def abs_filenames(files: T.Iterable['FileOrString']) -> T.Iterator[str]:
+ for f in files:
+ if isinstance(f, mesonlib.File):
+ yield f.absolute_path(state.environment.get_source_dir(), state.environment.get_build_dir())
+ else:
+ yield os.path.join(state.environment.get_source_dir(), state.subdir, f)
- src_dirs = mesonlib.extract_as_list(kwargs, 'src_dir')
- header_dirs = []
+ src_dirs = kwargs['src_dir']
+ header_dirs: T.List[str] = []
for src_dir in src_dirs:
- if hasattr(src_dir, 'held_object'):
- src_dir = src_dir.held_object
- if not isinstance(src_dir, build.IncludeDirs):
- raise MesonException('Invalid keyword argument for src_dir.')
- for inc_dir in src_dir.get_incdirs():
- header_dirs.append(os.path.join(state.environment.get_source_dir(),
- src_dir.get_curdir(), inc_dir))
- header_dirs.append(os.path.join(state.environment.get_build_dir(),
- src_dir.get_curdir(), inc_dir))
+ if isinstance(src_dir, build.IncludeDirs):
+ header_dirs.extend(src_dir.to_string_list(state.environment.get_source_dir(),
+ state.environment.get_build_dir()))
else:
header_dirs.append(src_dir)
- args = ['--internal', 'gtkdoc',
- '--sourcedir=' + state.environment.get_source_dir(),
- '--builddir=' + state.environment.get_build_dir(),
- '--subdir=' + state.subdir,
- '--headerdirs=' + '@@'.join(header_dirs),
- '--mainfile=' + main_file,
- '--modulename=' + modulename,
- '--moduleversion=' + moduleversion,
- '--mode=' + mode]
+ t_args = ['--internal', 'gtkdoc',
+ '--sourcedir=' + state.environment.get_source_dir(),
+ '--builddir=' + state.environment.get_build_dir(),
+ '--subdir=' + state.subdir,
+ '--headerdirs=' + '@@'.join(header_dirs),
+ '--mainfile=' + main_file,
+ '--modulename=' + modulename,
+ '--moduleversion=' + moduleversion,
+ '--mode=' + kwargs['mode']]
for tool in ['scan', 'scangobj', 'mkdb', 'mkhtml', 'fixxref']:
program_name = 'gtkdoc-' + tool
- program = self.interpreter.find_program_impl(program_name)
- path = program.held_object.get_path()
- args.append('--{}={}'.format(program_name, path))
+ program = state.find_program(program_name)
+ path = program.get_path()
+ t_args.append(f'--{program_name}={path}')
if namespace:
- args.append('--namespace=' + namespace)
- args += self._unpack_args('--htmlargs=', 'html_args', kwargs)
- args += self._unpack_args('--scanargs=', 'scan_args', kwargs)
- args += self._unpack_args('--scanobjsargs=', 'scanobjs_args', kwargs)
- args += self._unpack_args('--gobjects-types-file=', 'gobject_typesfile', kwargs, state)
- args += self._unpack_args('--fixxrefargs=', 'fixxref_args', kwargs)
- args += self._unpack_args('--mkdbargs=', 'mkdb_args', kwargs)
- args += self._unpack_args('--html-assets=', 'html_assets', kwargs, state)
+ t_args.append('--namespace=' + namespace)
+ if state.environment.need_exe_wrapper() and not isinstance(state.environment.get_exe_wrapper(), EmptyExternalProgram):
+ t_args.append('--run=' + ' '.join(state.environment.get_exe_wrapper().get_command()))
+ t_args.append(f'--htmlargs={"@@".join(kwargs["html_args"])}')
+ t_args.append(f'--scanargs={"@@".join(kwargs["scan_args"])}')
+ t_args.append(f'--scanobjsargs={"@@".join(kwargs["scanobjs_args"])}')
+ t_args.append(f'--gobjects-types-file={"@@".join(abs_filenames(kwargs["gobject_typesfile"]))}')
+ t_args.append(f'--fixxrefargs={"@@".join(kwargs["fixxref_args"])}')
+ t_args.append(f'--mkdbargs={"@@".join(kwargs["mkdb_args"])}')
+ t_args.append(f'--html-assets={"@@".join(abs_filenames(kwargs["html_assets"]))}')
- depends = []
+ depends: T.List['build.GeneratedTypes'] = []
content_files = []
- for s in mesonlib.extract_as_list(kwargs, 'content_files'):
- if hasattr(s, 'held_object'):
- s = s.held_object
+ for s in kwargs['content_files']:
if isinstance(s, (build.CustomTarget, build.CustomTargetIndex)):
depends.append(s)
for o in s.get_outputs():
@@ -1002,56 +1379,47 @@
content_files.append(os.path.join(state.environment.get_source_dir(),
state.subdir,
gen_src))
- elif isinstance(s, str):
+ else:
content_files.append(os.path.join(state.environment.get_source_dir(),
state.subdir,
s))
- else:
- raise MesonException(
- 'Invalid object type: {!r}'.format(s.__class__.__name__))
- args += ['--content-files=' + '@@'.join(content_files)]
-
- args += self._unpack_args('--expand-content-files=', 'expand_content_files', kwargs, state)
- args += self._unpack_args('--ignore-headers=', 'ignore_headers', kwargs)
- args += self._unpack_args('--installdir=', 'install_dir', kwargs)
- args += self._get_build_args(kwargs, state, depends)
+ t_args += ['--content-files=' + '@@'.join(content_files)]
+
+ t_args.append(f'--expand-content-files={"@@".join(abs_filenames(kwargs["expand_content_files"]))}')
+ t_args.append(f'--ignore-headers={"@@".join(kwargs["ignore_headers"])}')
+ t_args.append(f'--installdir={"@@".join(kwargs["install_dir"])}')
+ t_args += self._get_build_args(kwargs['c_args'], kwargs['include_directories'],
+ kwargs['dependencies'], state, depends)
custom_kwargs = {'output': modulename + '-decl.txt',
- 'command': command + args,
+ 'command': command + t_args,
'depends': depends,
'build_always_stale': True,
}
custom_target = build.CustomTarget(targetname, state.subdir, state.subproject, custom_kwargs)
alias_target = build.AliasTarget(targetname, [custom_target], state.subdir, state.subproject)
- if kwargs.get('check', False):
- check_cmd = self.interpreter.find_program_impl('gtkdoc-check')
+ if kwargs['check']:
+ check_cmd = state.find_program('gtkdoc-check')
check_env = ['DOC_MODULE=' + modulename,
'DOC_MAIN_SGML_FILE=' + main_file]
- check_args = [targetname + '-check', check_cmd]
- check_kwargs = {'env': check_env,
- 'workdir': os.path.join(state.environment.get_build_dir(), state.subdir),
- 'depends': custom_target}
- self.interpreter.add_test(state.current_node, check_args, check_kwargs, True)
- res = [custom_target, alias_target]
- if kwargs.get('install', True):
- res.append(build.RunScript(command, args))
+ check_args = (targetname + '-check', check_cmd)
+ check_workdir = os.path.join(state.environment.get_build_dir(), state.subdir)
+ state.test(check_args, env=check_env, workdir=check_workdir, depends=[custom_target])
+ res: T.List[T.Union[build.Target, build.ExecutableSerialisation]] = [custom_target, alias_target]
+ if kwargs['install']:
+ res.append(state.backend.get_executable_serialisation(command + t_args, tag='doc'))
return ModuleReturnValue(custom_target, res)
- def _get_build_args(self, kwargs, state, depends):
- args = []
- deps = extract_as_list(kwargs, 'dependencies', unholder=True)
- cflags = []
- cflags.extend(mesonlib.stringlistify(kwargs.pop('c_args', [])))
- deps_cflags, internal_ldflags, external_ldflags, gi_includes = \
+ def _get_build_args(self, c_args: T.List[str], inc_dirs: T.List[T.Union[str, build.IncludeDirs]],
+ deps: T.List[T.Union[Dependency, build.SharedLibrary, build.StaticLibrary]],
+ state: 'ModuleState', depends: T.List[build.BuildTarget]) -> T.List[str]:
+ args: T.List[str] = []
+ cflags = c_args.copy()
+ deps_cflags, internal_ldflags, external_ldflags, *_ = \
self._get_dependencies_flags(deps, state, depends, include_rpath=True)
- inc_dirs = mesonlib.extract_as_list(kwargs, 'include_directories')
- for incd in inc_dirs:
- if not isinstance(incd.held_object, (str, build.IncludeDirs)):
- raise MesonException(
- 'Gir include dirs should be include_directories().')
cflags.extend(deps_cflags)
- cflags.extend(get_include_args(inc_dirs))
- ldflags = []
+ cflags.extend(state.get_include_args(inc_dirs))
+ ldflags: T.List[str] = []
ldflags.extend(internal_ldflags)
ldflags.extend(external_ldflags)
@@ -1074,90 +1442,71 @@
return args
@noKwargs
- def gtkdoc_html_dir(self, state, args, kwargs):
- if len(args) != 1:
- raise MesonException('Must have exactly one argument.')
- modulename = args[0]
- if not isinstance(modulename, str):
- raise MesonException('Argument must be a string')
- return ModuleReturnValue(os.path.join('share/gtk-doc/html', modulename), [])
-
- @staticmethod
- def _unpack_args(arg, kwarg_name, kwargs, expend_file_state=None):
- if kwarg_name not in kwargs:
- return []
-
- new_args = mesonlib.extract_as_list(kwargs, kwarg_name)
- args = []
- for i in new_args:
- if expend_file_state and isinstance(i, mesonlib.File):
- i = i.absolute_path(expend_file_state.environment.get_source_dir(), expend_file_state.environment.get_build_dir())
- elif expend_file_state and isinstance(i, str):
- i = os.path.join(expend_file_state.environment.get_source_dir(), expend_file_state.subdir, i)
- elif not isinstance(i, str):
- raise MesonException(kwarg_name + ' values must be strings.')
- args.append(i)
-
- if args:
- return [arg + '@@'.join(args)]
-
- return []
-
- def _get_autocleanup_args(self, kwargs, glib_version):
- if not mesonlib.version_compare(glib_version, '>= 2.49.1'):
- # Warn if requested, silently disable if not
- if 'autocleanup' in kwargs:
- mlog.warning('Glib version ({}) is too old to support the \'autocleanup\' '
- 'kwarg, need 2.49.1 or newer'.format(glib_version))
- return []
- autocleanup = kwargs.pop('autocleanup', 'all')
- values = ('none', 'objects', 'all')
- if autocleanup not in values:
- raise MesonException('gdbus_codegen does not support {!r} as an autocleanup value, '
- 'must be one of: {!r}'.format(autocleanup, ', '.join(values)))
- return ['--c-generate-autocleanup', autocleanup]
-
- @FeatureNewKwargs('build target', '0.46.0', ['install_header', 'install_dir', 'sources'])
- @FeatureNewKwargs('build target', '0.40.0', ['build_by_default'])
- @FeatureNewKwargs('build target', '0.47.0', ['extra_args', 'autocleanup'])
- @permittedKwargs({'interface_prefix', 'namespace', 'extra_args', 'autocleanup', 'object_manager', 'build_by_default',
- 'annotations', 'docbook', 'install_header', 'install_dir', 'sources'})
- def gdbus_codegen(self, state, args, kwargs):
- if len(args) not in (1, 2):
- raise MesonException('gdbus_codegen takes at most two arguments, name and xml file.')
+ @typed_pos_args('gnome.gtkdoc_html_dir', str)
+ def gtkdoc_html_dir(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> str:
+ return os.path.join('share/gtk-doc/html', args[0])
+
+ @typed_pos_args('gnome.gdbus_codegen', str, optargs=[(str, mesonlib.File)])
+ @typed_kwargs(
+ 'gnome.gdbus_codegen',
+ _BUILD_BY_DEFAULT.evolve(since='0.40.0'),
+ KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File)), since='0.46.0', default=[], listify=True),
+ KwargInfo('extra_args', ContainerTypeInfo(list, str), since='0.47.0', default=[], listify=True),
+ KwargInfo('interface_prefix', (str, NoneType)),
+ KwargInfo('namespace', (str, NoneType)),
+ KwargInfo('object_manager', bool, default=False),
+ KwargInfo(
+ 'annotations', ContainerTypeInfo(list, (list, str)),
+ default=[],
+ validator=annotations_validator,
+ convertor=lambda x: [x] if x and isinstance(x[0], str) else x,
+ ),
+ KwargInfo('install_header', bool, default=False, since='0.46.0'),
+ KwargInfo('install_dir', (str, NoneType), since='0.46.0'),
+ KwargInfo('docbook', (str, NoneType)),
+ KwargInfo(
+ 'autocleanup', str, default='default', since='0.47.0',
+ validator=in_set_validator({'all', 'none', 'objects'})),
+ )
+ def gdbus_codegen(self, state: 'ModuleState', args: T.Tuple[str, T.Optional['FileOrString']],
+ kwargs: 'GdbusCodegen') -> ModuleReturnValue:
namebase = args[0]
- xml_files = args[1:]
- cmd = [self.interpreter.find_program_impl('gdbus-codegen')]
- extra_args = mesonlib.stringlistify(kwargs.pop('extra_args', []))
- cmd += extra_args
+ xml_files: T.List['FileOrString'] = [args[1]] if args[1] else []
+ cmd: T.List[T.Union['ExternalProgram', str]] = [state.find_program('gdbus-codegen')]
+ cmd.extend(kwargs['extra_args'])
+
# Autocleanup supported?
glib_version = self._get_native_glib_version(state)
- cmd += self._get_autocleanup_args(kwargs, glib_version)
- if 'interface_prefix' in kwargs:
- cmd += ['--interface-prefix', kwargs.pop('interface_prefix')]
- if 'namespace' in kwargs:
- cmd += ['--c-namespace', kwargs.pop('namespace')]
- if kwargs.get('object_manager', False):
- cmd += ['--c-generate-object-manager']
- if 'sources' in kwargs:
- xml_files += mesonlib.listify(kwargs.pop('sources'))
- build_by_default = kwargs.get('build_by_default', False)
+ if not mesonlib.version_compare(glib_version, '>= 2.49.1'):
+ # Warn if requested, silently disable if not
+ if kwargs['autocleanup'] != 'default':
+ mlog.warning(f'Glib version ({glib_version}) is too old to support the \'autocleanup\' '
+ 'kwarg, need 2.49.1 or newer')
+ else:
+ # Handle legacy glib versions that don't have autocleanup
+ ac = kwargs['autocleanup']
+ if ac == 'default':
+ ac = 'all'
+ cmd.extend(['--c-generate-autocleanup', ac])
+
+ if kwargs['interface_prefix'] is not None:
+ cmd.extend(['--interface-prefix', kwargs['interface_prefix']])
+ if kwargs['namespace'] is not None:
+ cmd.extend(['--c-namespace', kwargs['namespace']])
+ if kwargs['object_manager']:
+ cmd.extend(['--c-generate-object-manager'])
+ xml_files.extend(kwargs['sources'])
+ build_by_default = kwargs['build_by_default']
# Annotations are a bit ugly in that they are a list of lists of strings...
- annotations = kwargs.pop('annotations', [])
- if not isinstance(annotations, list):
- raise MesonException('annotations takes a list')
- if annotations and isinstance(annotations, list) and not isinstance(annotations[0], list):
- annotations = [annotations]
-
- for annotation in annotations:
- if len(annotation) != 3 or not all(isinstance(i, str) for i in annotation):
- raise MesonException('Annotations must be made up of 3 strings for ELEMENT, KEY, and VALUE')
- cmd += ['--annotate'] + annotation
+ for annot in kwargs['annotations']:
+ cmd.append('--annotate')
+ cmd.extend(annot)
targets = []
- install_header = kwargs.get('install_header', False)
- install_dir = kwargs.get('install_dir', state.environment.coredata.get_builtin_option('includedir'))
+ install_header = kwargs['install_header']
+ install_dir = kwargs['install_dir'] or state.environment.coredata.get_option(mesonlib.OptionKey('includedir'))
+ assert isinstance(install_dir, str), 'for mypy'
output = namebase + '.c'
# Added in https://gitlab.gnome.org/GNOME/glib/commit/e4d68c7b3e8b01ab1a4231bf6da21d045cb5a816 (2.55.2)
@@ -1169,10 +1518,8 @@
'build_by_default': build_by_default
}
else:
- if 'docbook' in kwargs:
+ if kwargs['docbook'] is not None:
docbook = kwargs['docbook']
- if not isinstance(docbook, str):
- raise MesonException('docbook value must be a string.')
cmd += ['--generate-docbook', docbook]
@@ -1214,7 +1561,7 @@
hfile_custom_target = build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs)
targets.append(hfile_custom_target)
- if 'docbook' in kwargs:
+ if kwargs['docbook'] is not None:
docbook = kwargs['docbook']
if not isinstance(docbook, str):
raise MesonException('docbook value must be a string.')
@@ -1246,78 +1593,53 @@
return ModuleReturnValue(targets, targets)
- @permittedKwargs({'sources', 'c_template', 'h_template', 'install_header', 'install_dir',
- 'comments', 'identifier_prefix', 'symbol_prefix', 'eprod', 'vprod',
- 'fhead', 'fprod', 'ftail', 'vhead', 'vtail', 'depends'})
- def mkenums(self, state, args, kwargs):
- if len(args) != 1:
- raise MesonException('Mkenums requires one positional argument.')
+ @typed_pos_args('gnome.mkenums', str)
+ @typed_kwargs(
+ 'gnome.mkenums',
+ *_MK_ENUMS_COMMON_KWS,
+ DEPENDS_KW,
+ KwargInfo('c_template', (str, mesonlib.File, NoneType)),
+ KwargInfo('h_template', (str, mesonlib.File, NoneType)),
+ KwargInfo('comments', (str, NoneType)),
+ KwargInfo('eprod', (str, NoneType)),
+ KwargInfo('fhead', (str, NoneType)),
+ KwargInfo('fprod', (str, NoneType)),
+ KwargInfo('ftail', (str, NoneType)),
+ KwargInfo('vhead', (str, NoneType)),
+ KwargInfo('vprod', (str, NoneType)),
+ KwargInfo('vtail', (str, NoneType)),
+ )
+ def mkenums(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'MkEnums') -> ModuleReturnValue:
basename = args[0]
- if 'sources' not in kwargs:
- raise MesonException('Missing keyword argument "sources".')
- sources = kwargs.pop('sources')
- if isinstance(sources, str):
- sources = [sources]
- elif not isinstance(sources, list):
- raise MesonException(
- 'Sources keyword argument must be a string or array.')
+ c_template = kwargs['c_template']
+ if isinstance(c_template, mesonlib.File):
+ c_template = c_template.absolute_path(state.environment.source_dir, state.environment.build_dir)
+ h_template = kwargs['h_template']
+ if isinstance(h_template, mesonlib.File):
+ h_template = h_template.absolute_path(state.environment.source_dir, state.environment.build_dir)
- cmd = []
+ cmd: T.List[str] = []
known_kwargs = ['comments', 'eprod', 'fhead', 'fprod', 'ftail',
- 'identifier_prefix', 'symbol_prefix', 'template',
+ 'identifier_prefix', 'symbol_prefix',
'vhead', 'vprod', 'vtail']
- known_custom_target_kwargs = ['install_dir', 'build_always',
- 'depends', 'depend_files']
- c_template = h_template = None
- install_header = False
- for arg, value in kwargs.items():
- if arg == 'sources':
- raise AssertionError("sources should've already been handled")
- elif arg == 'c_template':
- c_template = value
- if isinstance(c_template, mesonlib.File):
- c_template = c_template.absolute_path(state.environment.source_dir, state.environment.build_dir)
- if 'template' in kwargs:
- raise MesonException('Mkenums does not accept both '
- 'c_template and template keyword '
- 'arguments at the same time.')
- elif arg == 'h_template':
- h_template = value
- if isinstance(h_template, mesonlib.File):
- h_template = h_template.absolute_path(state.environment.source_dir, state.environment.build_dir)
- if 'template' in kwargs:
- raise MesonException('Mkenums does not accept both '
- 'h_template and template keyword '
- 'arguments at the same time.')
- elif arg == 'install_header':
- install_header = value
- elif arg in known_kwargs:
- cmd += ['--' + arg.replace('_', '-'), value]
- elif arg not in known_custom_target_kwargs:
- raise MesonException(
- 'Mkenums does not take a %s keyword argument.' % (arg, ))
- cmd = [self.interpreter.find_program_impl(['glib-mkenums', 'mkenums'])] + cmd
- custom_kwargs = {}
- for arg in known_custom_target_kwargs:
- if arg in kwargs:
- custom_kwargs[arg] = kwargs[arg]
+ for arg in known_kwargs:
+ # mypy can't figure this out
+ if kwargs[arg]: # type: ignore
+ cmd += ['--' + arg.replace('_', '-'), kwargs[arg]] # type: ignore
- targets = []
+ targets: T.List[CustomTarget] = []
+ h_target: T.Optional[CustomTarget] = None
if h_template is not None:
h_output = os.path.basename(os.path.splitext(h_template)[0])
# We always set template as the first element in the source array
# so --template consumes it.
h_cmd = cmd + ['--template', '@INPUT@']
- h_sources = [h_template] + sources
- custom_kwargs['install'] = install_header
- if 'install_dir' not in custom_kwargs:
- custom_kwargs['install_dir'] = \
- state.environment.coredata.get_builtin_option('includedir')
- h_target = self._make_mkenum_custom_target(state, h_sources,
- h_output, h_cmd,
- custom_kwargs)
+ h_sources = [h_template] + kwargs['sources']
+ h_target = self._make_mkenum_impl(
+ state, h_sources, h_output, h_cmd, install=kwargs['install_header'],
+ install_dir=kwargs['install_dir'])
targets.append(h_target)
if c_template is not None:
@@ -1325,203 +1647,206 @@
# We always set template as the first element in the source array
# so --template consumes it.
c_cmd = cmd + ['--template', '@INPUT@']
- c_sources = [c_template] + sources
- # Never install the C file. Complain on bug tracker if you need it.
- custom_kwargs['install'] = False
- if h_template is not None:
- if 'depends' in custom_kwargs:
- custom_kwargs['depends'] += [h_target]
- else:
- custom_kwargs['depends'] = h_target
- c_target = self._make_mkenum_custom_target(state, c_sources,
- c_output, c_cmd,
- custom_kwargs)
+ c_sources = [c_template] + kwargs['sources']
+
+ depends = kwargs['depends'].copy()
+ if h_target is not None:
+ depends.append(h_target)
+ c_target = self._make_mkenum_impl(
+ state, c_sources, c_output, c_cmd, depends=depends)
targets.insert(0, c_target)
if c_template is None and h_template is None:
generic_cmd = cmd + ['@INPUT@']
- custom_kwargs['install'] = install_header
- if 'install_dir' not in custom_kwargs:
- custom_kwargs['install_dir'] = \
- state.environment.coredata.get_builtin_option('includedir')
- target = self._make_mkenum_custom_target(state, sources, basename,
- generic_cmd, custom_kwargs)
+ target = self._make_mkenum_impl(
+ state, kwargs['sources'], basename, generic_cmd,
+ install=kwargs['install_header'],
+ install_dir=kwargs['install_dir'])
return ModuleReturnValue(target, [target])
- elif len(targets) == 1:
- return ModuleReturnValue(targets[0], [targets[0]])
else:
return ModuleReturnValue(targets, targets)
@FeatureNew('gnome.mkenums_simple', '0.42.0')
- def mkenums_simple(self, state, args, kwargs):
- hdr_filename = args[0] + '.h'
- body_filename = args[0] + '.c'
-
- # not really needed, just for sanity checking
- forbidden_kwargs = ['c_template', 'h_template', 'eprod', 'fhead',
- 'fprod', 'ftail', 'vhead', 'vtail', 'comments']
- for arg in forbidden_kwargs:
- if arg in kwargs:
- raise MesonException('mkenums_simple() does not take a %s keyword argument' % (arg, ))
-
- # kwargs to pass as-is from mkenums_simple() to mkenums()
- shared_kwargs = ['sources', 'install_header', 'install_dir',
- 'identifier_prefix', 'symbol_prefix']
- mkenums_kwargs = {}
- for arg in shared_kwargs:
- if arg in kwargs:
- mkenums_kwargs[arg] = kwargs[arg]
-
- # .c file generation
- c_file_kwargs = copy.deepcopy(mkenums_kwargs)
- if 'sources' not in kwargs:
- raise MesonException('Missing keyword argument "sources".')
- sources = kwargs['sources']
- if isinstance(sources, str):
- sources = [sources]
- elif not isinstance(sources, list):
- raise MesonException(
- 'Sources keyword argument must be a string or array.')
-
- # The `install_header` argument will be used by mkenums() when
- # not using template files, so we need to forcibly unset it
- # when generating the C source file, otherwise we will end up
- # installing it
- c_file_kwargs['install_header'] = False
-
- header_prefix = kwargs.get('header_prefix', '')
- decl_decorator = kwargs.get('decorator', '')
- func_prefix = kwargs.get('function_prefix', '')
- body_prefix = kwargs.get('body_prefix', '')
+ @typed_pos_args('gnome.mkenums_simple', str)
+ @typed_kwargs(
+ 'gnome.mkenums_simple',
+ *_MK_ENUMS_COMMON_KWS,
+ KwargInfo('header_prefix', str, default=''),
+ KwargInfo('function_prefix', str, default=''),
+ KwargInfo('body_prefix', str, default=''),
+ KwargInfo('decorator', str, default=''),
+ )
+ def mkenums_simple(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'MkEnumsSimple') -> ModuleReturnValue:
+ hdr_filename = f'{args[0]}.h'
+ body_filename = f'{args[0]}.c'
+
+ header_prefix = kwargs['header_prefix']
+ decl_decorator = kwargs['decorator']
+ func_prefix = kwargs['function_prefix']
+ body_prefix = kwargs['body_prefix']
+
+ cmd: T.List[str] = []
+ if kwargs['identifier_prefix']:
+ cmd.extend(['--identifier-prefix', kwargs['identifier_prefix']])
+ if kwargs['symbol_prefix']:
+ cmd.extend(['--symbol-prefix', kwargs['symbol_prefix']])
+ c_cmd = cmd.copy()
# Maybe we should write our own template files into the build dir
# instead, but that seems like much more work, nice as it would be.
fhead = ''
if body_prefix != '':
fhead += '%s\n' % body_prefix
fhead += '#include "%s"\n' % hdr_filename
- for hdr in sources:
- fhead += '#include "%s"\n' % os.path.basename(str(hdr))
- fhead += '''
-#define C_ENUM(v) ((gint) v)
-#define C_FLAGS(v) ((guint) v)
-'''
- c_file_kwargs['fhead'] = fhead
-
- c_file_kwargs['fprod'] = '''
-/* enumerations from "@basename@" */
-'''
-
- c_file_kwargs['vhead'] = '''
-GType
-%s@enum_name@_get_type (void)
-{
- static volatile gsize gtype_id = 0;
- static const G@Type@Value values[] = {''' % func_prefix
-
- c_file_kwargs['vprod'] = ' { C_@TYPE@(@VALUENAME@), "@VALUENAME@", "@valuenick@" },'
-
- c_file_kwargs['vtail'] = ''' { 0, NULL, NULL }
- };
- if (g_once_init_enter (>ype_id)) {
- GType new_type = g_@type@_register_static (g_intern_static_string ("@EnumName@"), values);
- g_once_init_leave (>ype_id, new_type);
- }
- return (GType) gtype_id;
-}'''
+ for hdr in kwargs['sources']:
+ fhead += '#include "{}"\n'.format(os.path.basename(str(hdr)))
+ fhead += textwrap.dedent(
+ '''
+ #define C_ENUM(v) ((gint) v)
+ #define C_FLAGS(v) ((guint) v)
+ ''')
+ c_cmd.extend(['--fhead', fhead])
+
+ c_cmd.append('--fprod')
+ c_cmd.append(textwrap.dedent(
+ '''
+ /* enumerations from "@basename@" */
+ '''))
+
+ c_cmd.append('--vhead')
+ c_cmd.append(textwrap.dedent(
+ f'''
+ GType
+ {func_prefix}@enum_name@_get_type (void)
+ {{
+ static gsize gtype_id = 0;
+ static const G@Type@Value values[] = {{'''))
+
+ c_cmd.extend(['--vprod', ' { C_@TYPE@(@VALUENAME@), "@VALUENAME@", "@valuenick@" },'])
+
+ c_cmd.append('--vtail')
+ c_cmd.append(textwrap.dedent(
+ ''' { 0, NULL, NULL }
+ };
+ if (g_once_init_enter (>ype_id)) {
+ GType new_type = g_@type@_register_static (g_intern_static_string ("@EnumName@"), values);
+ g_once_init_leave (>ype_id, new_type);
+ }
+ return (GType) gtype_id;
+ }'''))
+ c_cmd.append('@INPUT@')
- rv = self.mkenums(state, [body_filename], c_file_kwargs)
- c_file = rv.return_value
+ c_file = self._make_mkenum_impl(state, kwargs['sources'], body_filename, c_cmd)
# .h file generation
- h_file_kwargs = copy.deepcopy(mkenums_kwargs)
-
- h_file_kwargs['fhead'] = '''#pragma once
-
-#include
-{}
-
-G_BEGIN_DECLS
-'''.format(header_prefix)
-
- h_file_kwargs['fprod'] = '''
-/* enumerations from "@basename@" */
-'''
-
- h_file_kwargs['vhead'] = '''
-{}
-GType {}@enum_name@_get_type (void);
-#define @ENUMPREFIX@_TYPE_@ENUMSHORT@ ({}@enum_name@_get_type())'''.format(decl_decorator, func_prefix, func_prefix)
-
- h_file_kwargs['ftail'] = '''
-G_END_DECLS'''
+ h_cmd = cmd.copy()
- rv = self.mkenums(state, [hdr_filename], h_file_kwargs)
- h_file = rv.return_value
+ h_cmd.append('--fhead')
+ h_cmd.append(textwrap.dedent(
+ f'''#pragma once
+
+ #include
+ {header_prefix}
+
+ G_BEGIN_DECLS
+ '''))
+
+ h_cmd.append('--fprod')
+ h_cmd.append(textwrap.dedent(
+ '''
+ /* enumerations from "@basename@" */
+ '''))
+
+ h_cmd.append('--vhead')
+ h_cmd.append(textwrap.dedent(
+ f'''
+ {decl_decorator}
+ GType {func_prefix}@enum_name@_get_type (void);
+ #define @ENUMPREFIX@_TYPE_@ENUMSHORT@ ({func_prefix}@enum_name@_get_type())'''))
+
+ h_cmd.append('--ftail')
+ h_cmd.append(textwrap.dedent(
+ '''
+ G_END_DECLS'''))
+ h_cmd.append('@INPUT@')
+
+ h_file = self._make_mkenum_impl(
+ state, kwargs['sources'], hdr_filename, h_cmd,
+ install=kwargs['install_header'],
+ install_dir=kwargs['install_dir'])
return ModuleReturnValue([c_file, h_file], [c_file, h_file])
@staticmethod
- def _make_mkenum_custom_target(state, sources, output, cmd, kwargs):
+ def _make_mkenum_impl(
+ state: 'ModuleState',
+ sources: T.Sequence[T.Union[str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]],
+ output: str,
+ cmd: T.List[str],
+ *,
+ install: bool = False,
+ install_dir: T.Optional[T.Sequence[T.Union[str, bool]]] = None,
+ depends: T.Optional[T.List[CustomTarget]] = None) -> build.CustomTarget:
+ real_cmd: T.List[T.Union[str, ExternalProgram]] = [state.find_program(['glib-mkenums', 'mkenums'])]
+ real_cmd.extend(cmd)
custom_kwargs = {
'input': sources,
- 'output': output,
+ 'output': [output],
'capture': True,
- 'command': cmd
+ 'command': real_cmd,
+ 'install': install,
+ 'install_dir': install_dir or state.environment.coredata.get_option(mesonlib.OptionKey('includedir')),
+ 'depends': depends or [],
}
- custom_kwargs.update(kwargs)
return build.CustomTarget(output, state.subdir, state.subproject, custom_kwargs,
# https://github.com/mesonbuild/meson/issues/973
absolute_paths=True)
- @permittedKwargs({'sources', 'prefix', 'install_header', 'install_dir', 'stdinc',
- 'nostdinc', 'internal', 'skip_source', 'valist_marshallers',
- 'extra_args'})
- def genmarshal(self, state, args, kwargs):
- if len(args) != 1:
- raise MesonException(
- 'Genmarshal requires one positional argument.')
+ @typed_pos_args('gnome.genmarshal', str)
+ @typed_kwargs(
+ 'gnome.genmarshal',
+ DEPEND_FILES_KW.evolve(since='0.61.0'),
+ DEPENDS_KW.evolve(since='0.61.0'),
+ INSTALL_KW.evolve(name='install_header'),
+ KwargInfo('extra_args', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('internal', bool, default=False),
+ KwargInfo('nostdinc', bool, default=False),
+ KwargInfo('prefix', (str, NoneType)),
+ KwargInfo('skip_source', bool, default=False),
+ KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File), allow_empty=False), listify=True, required=True),
+ KwargInfo('stdinc', bool, default=False),
+ KwargInfo('valist_marshallers', bool, default=False),
+ )
+ def genmarshal(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'GenMarshal') -> ModuleReturnValue:
output = args[0]
-
- if 'sources' not in kwargs:
- raise MesonException('Missing keyword argument "sources".')
- sources = kwargs.pop('sources')
- if isinstance(sources, str):
- sources = [sources]
- elif not isinstance(sources, list):
- raise MesonException(
- 'Sources keyword argument must be a string or array.')
+ sources = kwargs['sources']
new_genmarshal = mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.53.3')
- cmd = [self.interpreter.find_program_impl('glib-genmarshal')]
- known_kwargs = ['internal', 'nostdinc', 'skip_source', 'stdinc',
- 'valist_marshallers', 'extra_args']
- known_custom_target_kwargs = ['build_always', 'depends',
- 'depend_files', 'install_dir',
- 'install_header']
- for arg, value in kwargs.items():
- if arg == 'prefix':
- cmd += ['--prefix', value]
- elif arg == 'extra_args':
- if new_genmarshal:
- cmd += mesonlib.stringlistify(value)
- else:
- mlog.warning('The current version of GLib does not support extra arguments \n'
- 'for glib-genmarshal. You need at least GLib 2.53.3. See ',
- mlog.bold('https://github.com/mesonbuild/meson/pull/2049'))
- elif arg in known_kwargs and value:
- cmd += ['--' + arg.replace('_', '-')]
- elif arg not in known_custom_target_kwargs:
- raise MesonException(
- 'Genmarshal does not take a %s keyword argument.' % (
- arg, ))
+ cmd: T.List[T.Union['ExternalProgram', str]] = [state.find_program('glib-genmarshal')]
+ if kwargs['prefix']:
+ cmd.extend(['--prefix', kwargs['prefix']])
+ if kwargs['extra_args']:
+ if new_genmarshal:
+ cmd.extend(kwargs['extra_args'])
+ else:
+ mlog.warning('The current version of GLib does not support extra arguments \n'
+ 'for glib-genmarshal. You need at least GLib 2.53.3. See ',
+ mlog.bold('https://github.com/mesonbuild/meson/pull/2049'))
+ for k in ['internal', 'nostdinc', 'skip_source', 'stdinc', 'valist_marshallers']:
+ # Mypy can't figure out that this is correct
+ if kwargs[k]: # type: ignore
+ cmd.append(f'--{k.replace("_", "-")}')
- install_header = kwargs.pop('install_header', False)
- install_dir = kwargs.pop('install_dir', None)
+ install_header = kwargs['install_header']
+ install_dir: T.List[T.Union[str, bool]] = kwargs['install_dir'] or []
- custom_kwargs = {
+
+ custom_kwargs: T.Dict[str, T.Any] = {
'input': sources,
+ 'depend_files': kwargs['depend_files'],
+ 'install_dir': kwargs['install_dir'],
}
# https://github.com/GNOME/glib/commit/0fbc98097fac4d3e647684f344e508abae109fdf
@@ -1530,10 +1855,6 @@
else:
custom_kwargs['capture'] = True
- for arg in known_custom_target_kwargs:
- if arg in kwargs:
- custom_kwargs[arg] = kwargs[arg]
-
header_file = output + '.h'
custom_kwargs['command'] = cmd + ['--body', '@INPUT@']
if mesonlib.version_compare(self._get_native_glib_version(state), '>= 2.53.4'):
@@ -1543,8 +1864,7 @@
body = build.CustomTarget(output + '_c', state.subdir, state.subproject, custom_kwargs)
custom_kwargs['install'] = install_header
- if install_dir is not None:
- custom_kwargs['install_dir'] = install_dir
+ custom_kwargs['install_dir'] = install_dir
if new_genmarshal:
cmd += ['--pragma-once']
custom_kwargs['command'] = cmd + ['--header', '@INPUT@']
@@ -1554,18 +1874,8 @@
rv = [body, header]
return ModuleReturnValue(rv, rv)
- @staticmethod
- def _vapi_args_to_command(prefix, variable, kwargs, accept_vapi=False):
- arg_list = mesonlib.extract_as_list(kwargs, variable)
- ret = []
- for arg in arg_list:
- if not isinstance(arg, str):
- types = 'strings' + ' or InternalDependencys' if accept_vapi else ''
- raise MesonException('All {} must be {}'.format(variable, types))
- ret.append(prefix + arg)
- return ret
-
- def _extract_vapi_packages(self, state, kwargs):
+ def _extract_vapi_packages(self, state: 'ModuleState', packages: T.List[T.Union[InternalDependency, str]],
+ ) -> T.Tuple[T.List[str], T.List[build.Target], T.List[str], T.List[str], T.List[str]]:
'''
Packages are special because we need to:
- Get a list of packages for the .deps file
@@ -1573,18 +1883,14 @@
- Get package name from VapiTargets
- Add include dirs for any VapiTargets
'''
- arg_list = kwargs.get('packages')
- if not arg_list:
- return [], [], [], []
- arg_list = mesonlib.listify(arg_list)
- vapi_depends = []
- vapi_packages = []
- vapi_includes = []
- ret = []
+ if not packages:
+ return [], [], [], [], []
+ vapi_depends: T.List[build.Target] = []
+ vapi_packages: T.List[str] = []
+ vapi_includes: T.List[str] = []
+ vapi_args: T.List[str] = []
remaining_args = []
- for arg in arg_list:
- if hasattr(arg, 'held_object'):
- arg = arg.held_object
+ for arg in packages:
if isinstance(arg, InternalDependency):
targets = [t for t in arg.sources if isinstance(t, VapiTarget)]
for target in targets:
@@ -1593,30 +1899,31 @@
outdir = os.path.join(state.environment.get_build_dir(),
target.get_subdir())
outfile = target.get_outputs()[0][:-5] # Strip .vapi
- ret.append('--vapidir=' + outdir)
- ret.append('--girdir=' + outdir)
- ret.append('--pkg=' + outfile)
+ vapi_args.append('--vapidir=' + outdir)
+ vapi_args.append('--girdir=' + outdir)
+ vapi_args.append('--pkg=' + outfile)
vapi_depends.append(target)
vapi_packages.append(outfile)
vapi_includes.append(srcdir)
else:
+ assert isinstance(arg, str), 'for mypy'
+ vapi_args.append(f'--pkg={arg}')
vapi_packages.append(arg)
remaining_args.append(arg)
- kwargs['packages'] = remaining_args
- vapi_args = ret + self._vapi_args_to_command('--pkg=', 'packages', kwargs, accept_vapi=True)
- return vapi_args, vapi_depends, vapi_packages, vapi_includes
+ # TODO: this is supposed to take IncludeDirs, but it never worked
+ return vapi_args, vapi_depends, vapi_packages, vapi_includes, remaining_args
- def _generate_deps(self, state, library, packages, install_dir):
+ def _generate_deps(self, state: 'ModuleState', library: str, packages: T.List[str], install_dir: str) -> build.Data:
outdir = state.environment.scratch_dir
fname = os.path.join(outdir, library + '.deps')
- with open(fname, 'w') as ofile:
+ with open(fname, 'w', encoding='utf-8') as ofile:
for package in packages:
ofile.write(package + '\n')
- return build.Data(mesonlib.File(True, outdir, fname), install_dir)
+ return build.Data([mesonlib.File(True, outdir, fname)], install_dir, install_dir, mesonlib.FileMode(), state.subproject)
- def _get_vapi_link_with(self, target):
- link_with = []
+ def _get_vapi_link_with(self, target: build.CustomTarget) -> T.List[T.Union[build.BuildTarget, build.CustomTarget]]:
+ link_with: T.List[T.Union[build.BuildTarget, build.CustomTarget]] = []
for dep in target.get_target_dependencies():
if isinstance(dep, build.SharedLibrary):
link_with.append(dep)
@@ -1624,48 +1931,48 @@
link_with += self._get_vapi_link_with(dep)
return link_with
- @permittedKwargs({'sources', 'packages', 'metadata_dirs', 'gir_dirs',
- 'vapi_dirs', 'install', 'install_dir'})
- def generate_vapi(self, state, args, kwargs):
- if len(args) != 1:
- raise MesonException('The library name is required')
-
- if not isinstance(args[0], str):
- raise MesonException('The first argument must be the name of the library')
- created_values = []
-
+ @typed_pos_args('gnome.generate_vapi', str)
+ @typed_kwargs(
+ 'gnome.generate_vapi',
+ INSTALL_KW,
+ KwargInfo(
+ 'sources',
+ ContainerTypeInfo(list, (str, GirTarget), allow_empty=False),
+ listify=True,
+ required=True,
+ ),
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('vapi_dirs', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('metadata_dirs', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('gir_dirs', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('packages', ContainerTypeInfo(list, (str, InternalDependency)), listify=True, default=[]),
+ )
+ def generate_vapi(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'GenerateVapi') -> ModuleReturnValue:
+ created_values: T.List[Dependency] = []
library = args[0]
build_dir = os.path.join(state.environment.get_build_dir(), state.subdir)
source_dir = os.path.join(state.environment.get_source_dir(), state.subdir)
- pkg_cmd, vapi_depends, vapi_packages, vapi_includes = self._extract_vapi_packages(state, kwargs)
- if 'VAPIGEN' in os.environ:
- cmd = [self.interpreter.find_program_impl(os.environ['VAPIGEN'])]
- else:
- cmd = [self.interpreter.find_program_impl('vapigen')]
- cmd += ['--quiet', '--library=' + library, '--directory=' + build_dir]
- cmd += self._vapi_args_to_command('--vapidir=', 'vapi_dirs', kwargs)
- cmd += self._vapi_args_to_command('--metadatadir=', 'metadata_dirs', kwargs)
- cmd += self._vapi_args_to_command('--girdir=', 'gir_dirs', kwargs)
+ pkg_cmd, vapi_depends, vapi_packages, vapi_includes, packages = self._extract_vapi_packages(state, kwargs['packages'])
+ cmd: T.List[T.Union[str, 'ExternalProgram']]
+ cmd = [state.find_program('vapigen'), '--quiet', f'--library={library}', f'--directory={build_dir}']
+ cmd.extend([f'--vapidir={d}' for d in kwargs['vapi_dirs']])
+ cmd.extend([f'--metadatadir={d}' for d in kwargs['metadata_dirs']])
+ cmd.extend([f'--girdir={d}' for d in kwargs['gir_dirs']])
cmd += pkg_cmd
cmd += ['--metadatadir=' + source_dir]
- if 'sources' not in kwargs:
- raise MesonException('sources are required to generate the vapi file')
-
- inputs = mesonlib.extract_as_list(kwargs, 'sources')
+ inputs = kwargs['sources']
link_with = []
for i in inputs:
if isinstance(i, str):
cmd.append(os.path.join(source_dir, i))
- elif hasattr(i, 'held_object') and isinstance(i.held_object, GirTarget):
- link_with += self._get_vapi_link_with(i.held_object)
+ elif isinstance(i, GirTarget):
+ link_with += self._get_vapi_link_with(i)
subdir = os.path.join(state.environment.get_build_dir(),
- i.held_object.get_subdir())
- gir_file = os.path.join(subdir, i.held_object.get_outputs()[0])
+ i.get_subdir())
+ gir_file = os.path.join(subdir, i.get_outputs()[0])
cmd.append(gir_file)
- else:
- raise MesonException('Input must be a str or GirTarget')
vapi_output = library + '.vapi'
custom_kwargs = {
@@ -1674,13 +1981,14 @@
'output': vapi_output,
'depends': vapi_depends,
}
- install_dir = kwargs.get('install_dir',
- os.path.join(state.environment.coredata.get_builtin_option('datadir'),
- 'vala', 'vapi'))
- if kwargs.get('install'):
- custom_kwargs['install'] = kwargs['install']
- custom_kwargs['install_dir'] = install_dir
+ datadir = state.environment.coredata.get_option(mesonlib.OptionKey('datadir'))
+ assert isinstance(datadir, str), 'for mypy'
+ install_dir = kwargs['install_dir'] or os.path.join(datadir, 'vala', 'vapi')
+ custom_kwargs['install'] = kwargs['install']
+ custom_kwargs['install_dir'] = install_dir
+ custom_kwargs['packages'] = packages
+ if kwargs['install']:
# We shouldn't need this locally but we install it
deps_target = self._generate_deps(state, library, vapi_packages, install_dir)
created_values.append(deps_target)
@@ -1692,9 +2000,15 @@
# - add relevant directories to include dirs
incs = [build.IncludeDirs(state.subdir, ['.'] + vapi_includes, False)]
sources = [vapi_target] + vapi_depends
- rv = InternalDependency(None, incs, [], [], link_with, [], sources, [])
+ rv = InternalDependency(None, incs, [], [], link_with, [], sources, [], {})
created_values.append(rv)
return ModuleReturnValue(rv, created_values)
-def initialize(*args, **kwargs):
- return GnomeModule(*args, **kwargs)
+def initialize(interp: 'Interpreter') -> GnomeModule:
+ mod = GnomeModule(interp)
+ mod.interpreter.append_holder_map(GResourceTarget, interpreter.CustomTargetHolder)
+ mod.interpreter.append_holder_map(GResourceHeaderTarget, interpreter.CustomTargetHolder)
+ mod.interpreter.append_holder_map(GirTarget, interpreter.CustomTargetHolder)
+ mod.interpreter.append_holder_map(TypelibTarget, interpreter.CustomTargetHolder)
+ mod.interpreter.append_holder_map(VapiTarget, interpreter.CustomTargetHolder)
+ return mod
diff -Nru meson-0.53.2/mesonbuild/modules/hotdoc.py meson-0.61.2/mesonbuild/modules/hotdoc.py
--- meson-0.53.2/mesonbuild/modules/hotdoc.py 2019-11-28 15:13:28.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/hotdoc.py 2021-12-26 16:24:25.000000000 +0000
@@ -22,10 +22,10 @@
from mesonbuild.coredata import MesonException
from . import ModuleReturnValue
from . import ExtensionModule
-from . import get_include_args
-from ..dependencies import Dependency, InternalDependency, ExternalProgram
+from ..dependencies import Dependency, InternalDependency
from ..interpreterbase import FeatureNew, InvalidArguments, noPosargs, noKwargs
from ..interpreter import CustomTargetHolder
+from ..programs import ExternalProgram
def ensure_list(value):
@@ -100,20 +100,19 @@
# When an option expects a single value, the unambiguous way
# to specify it is with =
if isinstance(value, str):
- self.cmd.extend(['%s=%s' % (option, value)])
+ self.cmd.extend([f'{option}={value}'])
else:
self.cmd.extend([option, value])
def check_extra_arg_type(self, arg, value):
- value = getattr(value, 'held_object', value)
if isinstance(value, list):
for v in value:
self.check_extra_arg_type(arg, v)
return
- valid_types = (str, bool, mesonlib.File, build.IncludeDirs, build.CustomTarget, build.BuildTarget)
+ valid_types = (str, bool, mesonlib.File, build.IncludeDirs, build.CustomTarget, build.CustomTargetIndex, build.BuildTarget)
if not isinstance(value, valid_types):
- raise InvalidArguments('Argument "%s=%s" should be of type: %s.' % (
+ raise InvalidArguments('Argument "{}={}" should be of type: {}.'.format(
arg, value, [t.__name__ for t in valid_types]))
def process_extra_args(self):
@@ -136,12 +135,11 @@
if force_list and not isinstance(value, list):
return [value], uvalue
return value, uvalue
- raise MesonException("%s field value %s is not valid,"
- " valid types are %s" % (argname, value,
- types))
+ raise MesonException(f"{argname} field value {value} is not valid,"
+ f" valid types are {types}")
except KeyError:
if mandatory:
- raise MesonException("%s mandatory field not found" % argname)
+ raise MesonException(f"{argname} mandatory field not found")
if default is not None:
return default, default
@@ -188,9 +186,8 @@
def process_dependencies(self, deps):
cflags = set()
for dep in mesonlib.listify(ensure_list(deps)):
- dep = getattr(dep, "held_object", dep)
if isinstance(dep, InternalDependency):
- inc_args = get_include_args(dep.include_directories)
+ inc_args = self.state.get_include_args(dep.include_directories)
cflags.update([self.replace_dirs_in_string(x)
for x in inc_args])
cflags.update(self.process_dependencies(dep.libraries))
@@ -212,6 +209,8 @@
self.add_extension_paths(dep.extra_extension_paths)
elif isinstance(dep, build.CustomTarget) or isinstance(dep, build.BuildTarget):
self._dependencies.append(dep)
+ elif isinstance(dep, build.CustomTargetIndex):
+ self._dependencies.append(dep.target)
return [f.strip('-I') for f in cflags]
@@ -232,7 +231,6 @@
def flatten_config_command(self):
cmd = []
for arg in mesonlib.listify(self.cmd, flatten=True):
- arg = getattr(arg, 'held_object', arg)
if isinstance(arg, mesonlib.File):
arg = arg.absolute_path(self.state.environment.get_source_dir(),
self.state.environment.get_build_dir())
@@ -242,9 +240,12 @@
cmd.append(os.path.join(self.builddir, arg.get_curdir(), inc_dir))
continue
- elif isinstance(arg, build.CustomTarget) or isinstance(arg, build.BuildTarget):
+ elif isinstance(arg, (build.BuildTarget, build.CustomTarget)):
self._dependencies.append(arg)
arg = self.interpreter.backend.get_target_filename_abs(arg)
+ elif isinstance(arg, build.CustomTargetIndex):
+ self._dependencies.append(arg.target)
+ arg = self.interpreter.backend.get_target_filename_abs(arg)
cmd.append(arg)
@@ -265,7 +266,7 @@
res.append(self.ensure_file(val))
return res
- if not isinstance(value, mesonlib.File):
+ if isinstance(value, str):
return mesonlib.File.from_source_file(self.sourcedir, self.subdir, value)
return value
@@ -277,21 +278,21 @@
_dir = os.path.join(self.sourcedir, self.subdir, value)
if not os.path.isdir(_dir):
- raise InvalidArguments('"%s" is not a directory.' % _dir)
+ raise InvalidArguments(f'"{_dir}" is not a directory.')
return os.path.relpath(_dir, os.path.join(self.builddir, self.subdir))
- def check_forbiden_args(self):
+ def check_forbidden_args(self):
for arg in ['conf_file']:
if arg in self.kwargs:
- raise InvalidArguments('Argument "%s" is forbidden.' % arg)
+ raise InvalidArguments(f'Argument "{arg}" is forbidden.')
def add_include_path(self, path):
self.include_paths[path] = path
def make_targets(self):
- self.check_forbiden_args()
- file_types = (str, mesonlib.File)
+ self.check_forbidden_args()
+ file_types = (str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex)
self.process_known_arg("--index", file_types, mandatory=True, value_processor=self.ensure_file)
self.process_known_arg("--project-version", str, mandatory=True)
self.process_known_arg("--sitemap", file_types, mandatory=True, value_processor=self.ensure_file)
@@ -313,7 +314,7 @@
hotdoc_config_name = fullname + '.json'
hotdoc_config_path = os.path.join(
self.builddir, self.subdir, hotdoc_config_name)
- with open(hotdoc_config_path, 'w') as f:
+ with open(hotdoc_config_path, 'w', encoding='utf-8') as f:
f.write('{}')
self.cmd += ['--conf-file', hotdoc_config_path]
@@ -326,7 +327,7 @@
for path in self.include_paths.keys():
self.cmd.extend(['--include-path', path])
- if self.state.environment.coredata.get_builtin_option('werror'):
+ if self.state.environment.coredata.get_option(mesonlib.OptionKey('werror', subproject=self.state.subproject)):
self.cmd.append('--fatal-warning')
self.generate_hotdoc_config()
@@ -350,13 +351,14 @@
install_script = None
if install is True:
- install_script = HotdocRunScript(self.build_command, [
+ install_script = self.state.backend.get_executable_serialisation(self.build_command + [
"--internal", "hotdoc",
"--install", os.path.join(fullname, 'html'),
'--name', self.name,
'--builddir', os.path.join(self.builddir, self.subdir)] +
self.hotdoc.get_command() +
['run', '--conf-file', hotdoc_config_name])
+ install_script.tag = 'doc'
return (target, install_script)
@@ -371,7 +373,7 @@
def config_path_method(self, *args, **kwargs):
conf = self.held_object.hotdoc_conf.absolute_path(self.interpreter.environment.source_dir,
self.interpreter.environment.build_dir)
- return self.interpreter.holderify(conf)
+ return conf
class HotdocTarget(build.CustomTarget):
@@ -391,11 +393,6 @@
return res
-class HotdocRunScript(build.RunScript):
- def __init__(self, script, args):
- super().__init__(script, args)
-
-
class HotDocModule(ExtensionModule):
@FeatureNew('Hotdoc Module', '0.48.0')
def __init__(self, interpreter):
@@ -408,13 +405,15 @@
from hotdoc.run_hotdoc import run # noqa: F401
self.hotdoc.run_hotdoc = run
except Exception as e:
- raise MesonException('hotdoc %s required but not found. (%s)' % (
- MIN_HOTDOC_VERSION, e))
+ raise MesonException(f'hotdoc {MIN_HOTDOC_VERSION} required but not found. ({e})')
+ self.methods.update({
+ 'has_extensions': self.has_extensions,
+ 'generate_doc': self.generate_doc,
+ })
@noKwargs
def has_extensions(self, state, args, kwargs):
- res = self.hotdoc.run_hotdoc(['--has-extension=%s' % extension for extension in args]) == 0
- return ModuleReturnValue(res, [res])
+ return self.hotdoc.run_hotdoc([f'--has-extension={extension}' for extension in args]) == 0
def generate_doc(self, state, args, kwargs):
if len(args) != 1:
@@ -424,7 +423,7 @@
project_name = args[0]
builder = HotdocTargetBuilder(project_name, state, self.hotdoc, self.interpreter, kwargs)
target, install_script = builder.make_targets()
- targets = [HotdocTargetHolder(target, self.interpreter)]
+ targets = [target]
if install_script:
targets.append(install_script)
@@ -432,4 +431,6 @@
def initialize(interpreter):
- return HotDocModule(interpreter)
+ mod = HotDocModule(interpreter)
+ mod.interpreter.append_holder_map(HotdocTarget, HotdocTargetHolder)
+ return mod
diff -Nru meson-0.53.2/mesonbuild/modules/i18n.py meson-0.61.2/mesonbuild/modules/i18n.py
--- meson-0.53.2/mesonbuild/modules/i18n.py 2019-09-28 23:52:33.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/i18n.py 2021-12-26 16:24:25.000000000 +0000
@@ -12,14 +12,67 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+from os import path
import shutil
+import typing as T
-from os import path
-from .. import coredata, mesonlib, build, mlog
-from ..mesonlib import MesonException, run_once
-from . import ModuleReturnValue
-from . import ExtensionModule
-from ..interpreterbase import permittedKwargs, FeatureNew, FeatureNewKwargs
+from . import ExtensionModule, ModuleReturnValue
+from .. import build
+from .. import mesonlib
+from .. import mlog
+from ..interpreter.type_checking import CT_BUILD_BY_DEFAULT, CT_INPUT_KW, CT_INSTALL_DIR_KW, CT_INSTALL_TAG_KW, CT_OUTPUT_KW, INSTALL_KW, NoneType, in_set_validator
+from ..interpreterbase import FeatureNew
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, noPosargs, typed_kwargs, typed_pos_args
+from ..scripts.gettext import read_linguas
+
+if T.TYPE_CHECKING:
+ from typing_extensions import Literal, TypedDict
+
+ from . import ModuleState
+ from ..build import Target
+ from ..interpreter import Interpreter
+ from ..interpreterbase import TYPE_var
+ from ..programs import ExternalProgram
+
+ class MergeFile(TypedDict):
+
+ input: T.List[T.Union[
+ str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex,
+ build.ExtractedObjects, build.GeneratedList, ExternalProgram,
+ mesonlib.File]]
+ output: T.List[str]
+ build_by_default: bool
+ install: bool
+ install_dir: T.List[T.Union[str, bool]]
+ install_tag: T.List[str]
+ args: T.List[str]
+ data_dirs: T.List[str]
+ po_dir: str
+ type: Literal['xml', 'desktop']
+
+ class Gettext(TypedDict):
+
+ args: T.List[str]
+ data_dirs: T.List[str]
+ install: bool
+ install_dir: T.Optional[str]
+ languages: T.List[str]
+ preset: T.Optional[str]
+
+
+_ARGS: KwargInfo[T.List[str]] = KwargInfo(
+ 'args',
+ ContainerTypeInfo(list, str),
+ default=[],
+ listify=True,
+)
+
+_DATA_DIRS: KwargInfo[T.List[str]] = KwargInfo(
+ 'data_dirs',
+ ContainerTypeInfo(list, str),
+ default=[],
+ listify=True
+)
PRESET_ARGS = {
'glib': [
@@ -57,134 +110,164 @@
class I18nModule(ExtensionModule):
+ def __init__(self, interpreter: 'Interpreter'):
+ super().__init__(interpreter)
+ self.methods.update({
+ 'merge_file': self.merge_file,
+ 'gettext': self.gettext,
+ })
@staticmethod
- @run_once
- def nogettext_warning():
- mlog.warning('Gettext not found, all translation targets will be ignored.')
- return ModuleReturnValue(None, [])
+ def nogettext_warning() -> None:
+ mlog.warning('Gettext not found, all translation targets will be ignored.', once=True)
@staticmethod
- def _get_data_dirs(state, dirs):
+ def _get_data_dirs(state: 'ModuleState', dirs: T.Iterable[str]) -> T.List[str]:
"""Returns source directories of relative paths"""
src_dir = path.join(state.environment.get_source_dir(), state.subdir)
return [path.join(src_dir, d) for d in dirs]
@FeatureNew('i18n.merge_file', '0.37.0')
- @FeatureNewKwargs('i18n.merge_file', '0.51.0', ['args'])
- @permittedKwargs(build.CustomTarget.known_kwargs | {'data_dirs', 'po_dir', 'type', 'args'})
- def merge_file(self, state, args, kwargs):
+ @noPosargs
+ @typed_kwargs(
+ 'i18n.merge_file',
+ CT_BUILD_BY_DEFAULT,
+ CT_INPUT_KW,
+ CT_INSTALL_DIR_KW,
+ CT_INSTALL_TAG_KW,
+ CT_OUTPUT_KW,
+ INSTALL_KW,
+ _ARGS.evolve(since='0.51.0'),
+ _DATA_DIRS.evolve(since='0.41.0'),
+ KwargInfo('po_dir', str, required=True),
+ KwargInfo('type', str, default='xml', validator=in_set_validator({'xml', 'desktop'})),
+ )
+ def merge_file(self, state: 'ModuleState', args: T.List['TYPE_var'], kwargs: 'MergeFile') -> ModuleReturnValue:
if not shutil.which('xgettext'):
- return self.nogettext_warning()
- podir = kwargs.pop('po_dir', None)
- if not podir:
- raise MesonException('i18n: po_dir is a required kwarg')
- podir = path.join(state.build_to_src, state.subdir, podir)
-
- file_type = kwargs.pop('type', 'xml')
- VALID_TYPES = ('xml', 'desktop')
- if file_type not in VALID_TYPES:
- raise MesonException('i18n: "{}" is not a valid type {}'.format(file_type, VALID_TYPES))
-
- datadirs = self._get_data_dirs(state, mesonlib.stringlistify(kwargs.pop('data_dirs', [])))
- datadirs = '--datadirs=' + ':'.join(datadirs) if datadirs else None
-
- command = state.environment.get_build_command() + [
+ self.nogettext_warning()
+ return ModuleReturnValue(None, [])
+ podir = path.join(state.build_to_src, state.subdir, kwargs['po_dir'])
+
+ ddirs = self._get_data_dirs(state, kwargs['data_dirs'])
+ datadirs = '--datadirs=' + ':'.join(ddirs) if ddirs else None
+
+ command: T.List[T.Union[str, build.BuildTarget, build.CustomTarget,
+ build.CustomTargetIndex, 'ExternalProgram', mesonlib.File]] = []
+ command.extend(state.environment.get_build_command())
+ command.extend([
'--internal', 'msgfmthelper',
- '@INPUT@', '@OUTPUT@', file_type, podir
- ]
+ '@INPUT@', '@OUTPUT@', kwargs['type'], podir
+ ])
if datadirs:
command.append(datadirs)
- if 'args' in kwargs:
+ if kwargs['args']:
command.append('--')
- command.append(mesonlib.stringlistify(kwargs.pop('args', [])))
+ command.extend(kwargs['args'])
+
+ build_by_default = kwargs['build_by_default']
+ if build_by_default is None:
+ build_by_default = kwargs['install']
+
+ real_kwargs = {
+ 'build_by_default': build_by_default,
+ 'command': command,
+ 'install': kwargs['install'],
+ 'install_dir': kwargs['install_dir'],
+ 'output': kwargs['output'],
+ 'input': kwargs['input'],
+ 'install_tag': kwargs['install_tag'],
+ }
- kwargs['command'] = command
+ ct = build.CustomTarget('', state.subdir, state.subproject,
+ T.cast(T.Dict[str, T.Any], real_kwargs))
- inputfile = kwargs['input']
- if hasattr(inputfile, 'held_object'):
- ct = build.CustomTarget(kwargs['output'] + '_merge', state.subdir, state.subproject, kwargs)
- else:
- if isinstance(inputfile, list):
- # We only use this input file to create a name of the custom target.
- # Thus we can ignore the other entries.
- inputfile = inputfile[0]
- if isinstance(inputfile, str):
- inputfile = mesonlib.File.from_source_file(state.environment.source_dir,
- state.subdir, inputfile)
- output = kwargs['output']
- ifile_abs = inputfile.absolute_path(state.environment.source_dir,
- state.environment.build_dir)
- values = mesonlib.get_filenames_templates_dict([ifile_abs], None)
- outputs = mesonlib.substitute_values([output], values)
- output = outputs[0]
- ct = build.CustomTarget(output + '_' + state.subdir.replace('/', '@').replace('\\', '@') + '_merge', state.subdir, state.subproject, kwargs)
return ModuleReturnValue(ct, [ct])
- @FeatureNewKwargs('i18n.gettext', '0.37.0', ['preset'])
- @FeatureNewKwargs('i18n.gettext', '0.50.0', ['install_dir'])
- @permittedKwargs({'po_dir', 'data_dirs', 'type', 'languages', 'args', 'preset', 'install', 'install_dir'})
- def gettext(self, state, args, kwargs):
- if len(args) != 1:
- raise coredata.MesonException('Gettext requires one positional argument (package name).')
+ @typed_pos_args('i81n.gettex', str)
+ @typed_kwargs(
+ 'i18n.gettext',
+ _ARGS,
+ _DATA_DIRS.evolve(since='0.36.0'),
+ INSTALL_KW.evolve(default=True),
+ KwargInfo('install_dir', (str, NoneType), since='0.50.0'),
+ KwargInfo('languages', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo(
+ 'preset',
+ (str, NoneType),
+ validator=in_set_validator(set(PRESET_ARGS)),
+ since='0.37.0',
+ ),
+ )
+ def gettext(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'Gettext') -> ModuleReturnValue:
if not shutil.which('xgettext'):
- return self.nogettext_warning()
+ self.nogettext_warning()
+ return ModuleReturnValue(None, [])
packagename = args[0]
- languages = mesonlib.stringlistify(kwargs.get('languages', []))
- datadirs = self._get_data_dirs(state, mesonlib.stringlistify(kwargs.get('data_dirs', [])))
- extra_args = mesonlib.stringlistify(kwargs.get('args', []))
+ pkg_arg = f'--pkgname={packagename}'
- preset = kwargs.pop('preset', None)
+ languages = kwargs['languages']
+ lang_arg = '--langs=' + '@@'.join(languages) if languages else None
+
+ _datadirs = ':'.join(self._get_data_dirs(state, kwargs['data_dirs']))
+ datadirs = f'--datadirs={_datadirs}' if _datadirs else None
+
+ extra_args = kwargs['args']
+ targets: T.List['Target'] = []
+ gmotargets: T.List['build.CustomTarget'] = []
+
+ preset = kwargs['preset']
if preset:
- preset_args = PRESET_ARGS.get(preset)
- if not preset_args:
- raise coredata.MesonException('i18n: Preset "{}" is not one of the valid options: {}'.format(
- preset, list(PRESET_ARGS.keys())))
- extra_args = set(preset_args + extra_args)
+ preset_args = PRESET_ARGS[preset]
+ extra_args = list(mesonlib.OrderedSet(preset_args + extra_args))
- pkg_arg = '--pkgname=' + packagename
- lang_arg = '--langs=' + '@@'.join(languages) if languages else None
- datadirs = '--datadirs=' + ':'.join(datadirs) if datadirs else None
- extra_args = '--extra-args=' + '@@'.join(extra_args) if extra_args else None
+ extra_arg = '--extra-args=' + '@@'.join(extra_args) if extra_args else None
potargs = state.environment.get_build_command() + ['--internal', 'gettext', 'pot', pkg_arg]
if datadirs:
potargs.append(datadirs)
- if extra_args:
- potargs.append(extra_args)
- pottarget = build.RunTarget(packagename + '-pot', potargs[0], potargs[1:], [], state.subdir, state.subproject)
+ if extra_arg:
+ potargs.append(extra_arg)
+ pottarget = build.RunTarget(packagename + '-pot', potargs, [], state.subdir, state.subproject)
+ targets.append(pottarget)
+
+ install = kwargs['install']
+ install_dir = kwargs['install_dir'] or state.environment.coredata.get_option(mesonlib.OptionKey('localedir'))
+ assert isinstance(install_dir, str), 'for mypy'
+ if not languages:
+ languages = read_linguas(path.join(state.environment.source_dir, state.subdir))
+ for l in languages:
+ po_file = mesonlib.File.from_source_file(state.environment.source_dir,
+ state.subdir, l+'.po')
+ gmo_kwargs = {'command': ['msgfmt', '@INPUT@', '-o', '@OUTPUT@'],
+ 'input': po_file,
+ 'output': packagename+'.mo',
+ 'install': install,
+ # We have multiple files all installed as packagename+'.mo' in different install subdirs.
+ # What we really wanted to do, probably, is have a rename: kwarg, but that's not available
+ # to custom_targets. Crude hack: set the build target's subdir manually.
+ # Bonus: the build tree has something usable as an uninstalled bindtextdomain() target dir.
+ 'install_dir': path.join(install_dir, l, 'LC_MESSAGES'),
+ 'install_tag': 'i18n',
+ }
+ gmotarget = build.CustomTarget(f'{packagename}-{l}.mo', path.join(state.subdir, l, 'LC_MESSAGES'), state.subproject, gmo_kwargs)
+ targets.append(gmotarget)
+ gmotargets.append(gmotarget)
- gmoargs = state.environment.get_build_command() + ['--internal', 'gettext', 'gen_gmo']
- if lang_arg:
- gmoargs.append(lang_arg)
- gmotarget = build.RunTarget(packagename + '-gmo', gmoargs[0], gmoargs[1:], [], state.subdir, state.subproject)
+ allgmotarget = build.AliasTarget(packagename + '-gmo', gmotargets, state.subdir, state.subproject)
+ targets.append(allgmotarget)
updatepoargs = state.environment.get_build_command() + ['--internal', 'gettext', 'update_po', pkg_arg]
if lang_arg:
updatepoargs.append(lang_arg)
if datadirs:
updatepoargs.append(datadirs)
- if extra_args:
- updatepoargs.append(extra_args)
- updatepotarget = build.RunTarget(packagename + '-update-po', updatepoargs[0], updatepoargs[1:], [], state.subdir, state.subproject)
-
- targets = [pottarget, gmotarget, updatepotarget]
-
- install = kwargs.get('install', True)
- if install:
- install_dir = kwargs.get('install_dir', state.environment.coredata.get_builtin_option('localedir'))
- script = state.environment.get_build_command()
- args = ['--internal', 'gettext', 'install',
- '--subdir=' + state.subdir,
- '--localedir=' + install_dir,
- pkg_arg]
- if lang_arg:
- args.append(lang_arg)
- iscript = build.RunScript(script, args)
- targets.append(iscript)
+ if extra_arg:
+ updatepoargs.append(extra_arg)
+ updatepotarget = build.RunTarget(packagename + '-update-po', updatepoargs, [], state.subdir, state.subproject)
+ targets.append(updatepotarget)
- return ModuleReturnValue(None, targets)
+ return ModuleReturnValue([gmotargets, pottarget, updatepotarget], targets)
-def initialize(*args, **kwargs):
- return I18nModule(*args, **kwargs)
+def initialize(interp: 'Interpreter') -> I18nModule:
+ return I18nModule(interp)
diff -Nru meson-0.53.2/mesonbuild/modules/__init__.py meson-0.61.2/mesonbuild/modules/__init__.py
--- meson-0.53.2/mesonbuild/modules/__init__.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/__init__.py 2022-01-17 10:50:38.000000000 +0000
@@ -12,77 +12,197 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-# This file contains the detection logic for external dependencies that
-# are UI-related.
+# This file contains the base representation for import('modname')
import os
+import typing as T
-from .. import build
+from .. import build, mesonlib
+from ..mesonlib import relpath, HoldableObject, MachineChoice, OptionKey
+from ..interpreterbase.decorators import noKwargs, noPosargs
+
+if T.TYPE_CHECKING:
+ from ..interpreter import Interpreter
+ from ..interpreterbase import TYPE_var, TYPE_kwargs
+ from ..programs import ExternalProgram
+ from ..wrap import WrapMode
+
+class ModuleState:
+ """Object passed to all module methods.
+
+ This is a WIP API provided to modules, it should be extended to have everything
+ needed so modules does not touch any other part of Meson internal APIs.
+ """
+
+ def __init__(self, interpreter: 'Interpreter') -> None:
+ # Keep it private, it should be accessed only through methods.
+ self._interpreter = interpreter
+
+ self.source_root = interpreter.environment.get_source_dir()
+ self.build_to_src = relpath(interpreter.environment.get_source_dir(),
+ interpreter.environment.get_build_dir())
+ self.subproject = interpreter.subproject
+ self.subdir = interpreter.subdir
+ self.current_lineno = interpreter.current_lineno
+ self.environment = interpreter.environment
+ self.project_name = interpreter.build.project_name
+ self.project_version = interpreter.build.dep_manifest[interpreter.active_projectname].version
+ # The backend object is under-used right now, but we will need it:
+ # https://github.com/mesonbuild/meson/issues/1419
+ self.backend = interpreter.backend
+ self.targets = interpreter.build.targets
+ self.data = interpreter.build.data
+ self.headers = interpreter.build.get_headers()
+ self.man = interpreter.build.get_man()
+ self.global_args = interpreter.build.global_args.host
+ self.project_args = interpreter.build.projects_args.host.get(interpreter.subproject, {})
+ self.build_machine = T.cast('MachineHolder', interpreter.builtin['build_machine']).held_object
+ self.host_machine = T.cast('MachineHolder', interpreter.builtin['host_machine']).held_object
+ self.target_machine = T.cast('MachineHolder', interpreter.builtin['target_machine']).held_object
+ self.current_node = interpreter.current_node
+
+ def get_include_args(self, include_dirs: T.Iterable[T.Union[str, build.IncludeDirs]], prefix: str = '-I') -> T.List[str]:
+ if not include_dirs:
+ return []
+
+ srcdir = self.environment.get_source_dir()
+ builddir = self.environment.get_build_dir()
+
+ dirs_str: T.List[str] = []
+ for dirs in include_dirs:
+ if isinstance(dirs, str):
+ dirs_str += [f'{prefix}{dirs}']
+ else:
+ dirs_str.extend([f'{prefix}{i}' for i in dirs.to_string_list(srcdir, builddir)])
+ dirs_str.extend([f'{prefix}{i}' for i in dirs.get_extra_build_dirs()])
+
+ return dirs_str
+
+ def find_program(self, prog: T.Union[str, T.List[str]], required: bool = True,
+ version_func: T.Optional[T.Callable[['ExternalProgram'], str]] = None,
+ wanted: T.Optional[str] = None, silent: bool = False) -> 'ExternalProgram':
+ return self._interpreter.find_program_impl(prog, required=required, version_func=version_func, wanted=wanted, silent=silent)
+
+ def test(self, args: T.Tuple[str, T.Union[build.Executable, build.Jar, 'ExternalProgram', mesonlib.File]],
+ workdir: T.Optional[str] = None,
+ env: T.Union[T.List[str], T.Dict[str, str], str] = None,
+ depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]] = None) -> None:
+ kwargs = {'workdir': workdir,
+ 'env': env,
+ 'depends': depends,
+ }
+ # typed_* takes a list, and gives a tuple to func_test. Violating that constraint
+ # makes the universe (or at least use of this function) implode
+ real_args = list(args)
+ # TODO: Use interpreter internal API, but we need to go through @typed_kwargs
+ self._interpreter.func_test(self.current_node, real_args, kwargs)
+
+ def get_option(self, name: str, subproject: str = '',
+ machine: MachineChoice = MachineChoice.HOST,
+ lang: T.Optional[str] = None,
+ module: T.Optional[str] = None) -> T.Union[str, int, bool, 'WrapMode']:
+ return self.environment.coredata.get_option(mesonlib.OptionKey(name, subproject, machine, lang, module))
+
+
+class ModuleObject(HoldableObject):
+ """Base class for all objects returned by modules
+ """
+ def __init__(self) -> None:
+ self.methods: T.Dict[
+ str,
+ T.Callable[[ModuleState, T.List['TYPE_var'], 'TYPE_kwargs'], T.Union[ModuleReturnValue, 'TYPE_var']]
+ ] = {}
+
+
+class MutableModuleObject(ModuleObject):
+ pass
+
+
+# FIXME: Port all modules to stop using self.interpreter and use API on
+# ModuleState instead. Modules should stop using this class and instead use
+# ModuleObject base class.
+class ExtensionModule(ModuleObject):
+ def __init__(self, interpreter: 'Interpreter') -> None:
+ super().__init__()
+ self.interpreter = interpreter
+ self.methods.update({
+ 'found': self.found_method,
+ })
+ @noPosargs
+ @noKwargs
+ def found_method(self, state: 'ModuleState', args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self.found()
-class ExtensionModule:
- def __init__(self, interpreter):
- self.interpreter = interpreter
- self.snippets = set() # List of methods that operate only on the interpreter.
+ @staticmethod
+ def found() -> bool:
+ return True
+
+
+class NewExtensionModule(ModuleObject):
+
+ """Class for modern modules
+
+ provides the found method.
+ """
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.methods.update({
+ 'found': self.found_method,
+ })
- def is_snippet(self, funcname):
- return funcname in self.snippets
+ @noPosargs
+ @noKwargs
+ def found_method(self, state: 'ModuleState', args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> bool:
+ return self.found()
+ @staticmethod
+ def found() -> bool:
+ return True
-def get_include_args(include_dirs, prefix='-I'):
+
+class NotFoundExtensionModule(NewExtensionModule):
+
+ """Class for modern modules
+
+ provides the found method.
+ """
+
+ @staticmethod
+ def found() -> bool:
+ return False
+
+
+def is_module_library(fname):
'''
- Expand include arguments to refer to the source and build dirs
- by using @SOURCE_ROOT@ and @BUILD_ROOT@ for later substitution
+ Check if the file is a library-like file generated by a module-specific
+ target, such as GirTarget or TypelibTarget
'''
- if not include_dirs:
- return []
-
- dirs_str = []
- for incdirs in include_dirs:
- if hasattr(incdirs, "held_object"):
- dirs = incdirs.held_object
- else:
- dirs = incdirs
-
- if isinstance(dirs, str):
- dirs_str += ['%s%s' % (prefix, dirs)]
- continue
-
- # Should be build.IncludeDirs object.
- basedir = dirs.get_curdir()
- for d in dirs.get_incdirs():
- expdir = os.path.join(basedir, d)
- srctreedir = os.path.join('@SOURCE_ROOT@', expdir)
- buildtreedir = os.path.join('@BUILD_ROOT@', expdir)
- dirs_str += ['%s%s' % (prefix, buildtreedir),
- '%s%s' % (prefix, srctreedir)]
- for d in dirs.get_extra_build_dirs():
- dirs_str += ['%s%s' % (prefix, d)]
+ if hasattr(fname, 'fname'):
+ fname = fname.fname
+ suffix = fname.split('.')[-1]
+ return suffix in ('gir', 'typelib')
- return dirs_str
class ModuleReturnValue:
- def __init__(self, return_value, new_objects):
+ def __init__(self, return_value: T.Optional['TYPE_var'],
+ new_objects: T.Sequence[T.Union['TYPE_var', 'build.ExecutableSerialisation']]) -> None:
self.return_value = return_value
- assert(isinstance(new_objects, list))
- self.new_objects = new_objects
+ assert isinstance(new_objects, list)
+ self.new_objects: T.List[T.Union['TYPE_var', 'build.ExecutableSerialisation']] = new_objects
class GResourceTarget(build.CustomTarget):
- def __init__(self, name, subdir, subproject, kwargs):
- super().__init__(name, subdir, subproject, kwargs)
+ pass
class GResourceHeaderTarget(build.CustomTarget):
- def __init__(self, name, subdir, subproject, kwargs):
- super().__init__(name, subdir, subproject, kwargs)
+ pass
class GirTarget(build.CustomTarget):
- def __init__(self, name, subdir, subproject, kwargs):
- super().__init__(name, subdir, subproject, kwargs)
+ pass
class TypelibTarget(build.CustomTarget):
- def __init__(self, name, subdir, subproject, kwargs):
- super().__init__(name, subdir, subproject, kwargs)
+ pass
class VapiTarget(build.CustomTarget):
- def __init__(self, name, subdir, subproject, kwargs):
- super().__init__(name, subdir, subproject, kwargs)
+ pass
diff -Nru meson-0.53.2/mesonbuild/modules/java.py meson-0.61.2/mesonbuild/modules/java.py
--- meson-0.53.2/mesonbuild/modules/java.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/java.py 2021-11-02 19:58:13.000000000 +0000
@@ -0,0 +1,76 @@
+# Copyright 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.
+
+import os
+import pathlib
+import typing as T
+from mesonbuild.build import CustomTarget
+from mesonbuild.compilers import detect_compiler_for
+from mesonbuild.interpreterbase.decorators import FeatureNew, KwargInfo, typed_pos_args, typed_kwargs
+from mesonbuild.interpreter.interpreterobjects import FileHolder
+from mesonbuild.mesonlib import version_compare, MachineChoice
+from . import ExtensionModule, ModuleReturnValue, ModuleState
+from ..interpreter import Interpreter
+
+class JavaModule(ExtensionModule):
+ @FeatureNew('Java Module', '0.60.0')
+ def __init__(self, interpreter: Interpreter):
+ super().__init__(interpreter)
+ self.methods.update({
+ 'generate_native_header': self.generate_native_header,
+ })
+
+ if 'java' not in interpreter.environment.coredata.compilers[MachineChoice.BUILD]:
+ detect_compiler_for(interpreter.environment, 'java', MachineChoice.BUILD)
+ self.javac = interpreter.environment.coredata.compilers[MachineChoice.BUILD]['java']
+
+ @typed_pos_args('generate_native_header', (str, FileHolder))
+ @typed_kwargs('java.generate_native_header', KwargInfo('package', str, default=None))
+ def generate_native_header(self, state: ModuleState, args: T.Tuple[T.Union[str, FileHolder]],
+ kwargs: T.Dict[str, T.Optional[str]]) -> ModuleReturnValue:
+ assert state.backend
+
+ package = kwargs.get('package')
+
+ file = self.interpreter.source_strings_to_files(
+ [a.held_object if isinstance(a, FileHolder) else a for a in args])[0]
+
+ if package:
+ header = f'{package.replace(".", "_")}_{pathlib.Path(file.fname).stem}.h'
+ else:
+ header = f'{pathlib.Path(file.fname).stem}.h'
+
+ ct_kwargs = {
+ 'input': file,
+ 'output': header,
+ 'command': [
+ self.javac.exelist[0],
+ '-d',
+ '@PRIVATE_DIR@',
+ '-h',
+ state.subdir,
+ '@INPUT@',
+ ]
+ }
+
+ target = CustomTarget(os.path.basename(header), state.subdir, state.subproject, backend=state.backend, kwargs=ct_kwargs)
+ # It is only known that 1.8.0 won't pre-create the directory. 11 and 16
+ # do not exhibit this behavior.
+ if version_compare(self.javac.version, '1.8.0'):
+ pathlib.Path(state.backend.get_target_private_dir_abs(target)).mkdir(parents=True, exist_ok=True)
+
+ return ModuleReturnValue(target, [target])
+
+def initialize(*args: T.Any, **kwargs: T.Any) -> JavaModule:
+ return JavaModule(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/keyval.py meson-0.61.2/mesonbuild/modules/keyval.py
--- meson-0.53.2/mesonbuild/modules/keyval.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/keyval.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,73 @@
+# Copyright 2017, 2019 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.
+
+import os
+import typing as T
+
+from . import ExtensionModule
+from .. import mesonlib
+from ..interpreterbase import FeatureNew, noKwargs, typed_pos_args
+
+if T.TYPE_CHECKING:
+ from ..interpreter import Interpreter
+ from . import ModuleState
+
+class KeyvalModule(ExtensionModule):
+
+ @FeatureNew('Keyval Module', '0.55.0')
+ def __init__(self, interp: 'Interpreter'):
+ super().__init__(interp)
+ self.methods.update({
+ 'load': self.load,
+ })
+
+ @staticmethod
+ def _load_file(path_to_config: str) -> T.Dict[str, str]:
+ result: T.Dict[str, str] = {}
+ try:
+ with open(path_to_config, encoding='utf-8') as f:
+ for line in f:
+ if '#' in line:
+ comment_idx = line.index('#')
+ line = line[:comment_idx]
+ line = line.strip()
+ try:
+ name, val = line.split('=', 1)
+ except ValueError:
+ continue
+ result[name.strip()] = val.strip()
+ except OSError as e:
+ raise mesonlib.MesonException(f'Failed to load {path_to_config}: {e}')
+
+ return result
+
+ @noKwargs
+ @typed_pos_args('keyval.laod', (str, mesonlib.File))
+ def load(self, state: 'ModuleState', args: T.Tuple['mesonlib.FileOrString'], kwargs: T.Dict[str, T.Any]) -> T.Dict[str, str]:
+ s = args[0]
+ is_built = False
+ if isinstance(s, mesonlib.File):
+ is_built = is_built or s.is_built
+ s = s.absolute_path(self.interpreter.environment.source_dir, self.interpreter.environment.build_dir)
+ else:
+ s = os.path.join(self.interpreter.environment.source_dir, s)
+
+ if s not in self.interpreter.build_def_files and not is_built:
+ self.interpreter.build_def_files.append(s)
+
+ return self._load_file(s)
+
+
+def initialize(interp: 'Interpreter') -> KeyvalModule:
+ return KeyvalModule(interp)
diff -Nru meson-0.53.2/mesonbuild/modules/modtest.py meson-0.61.2/mesonbuild/modules/modtest.py
--- meson-0.53.2/mesonbuild/modules/modtest.py 2018-08-25 08:05:43.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/modtest.py 2021-08-18 11:22:15.000000000 +0000
@@ -12,17 +12,19 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from . import ModuleReturnValue
from . import ExtensionModule
from ..interpreterbase import noKwargs
class TestModule(ExtensionModule):
+ def __init__(self, interpreter):
+ super().__init__(interpreter)
+ self.methods.update({
+ 'print_hello': self.print_hello,
+ })
@noKwargs
def print_hello(self, state, args, kwargs):
print('Hello from a Meson module')
- rv = ModuleReturnValue(None, [])
- return rv
def initialize(*args, **kwargs):
return TestModule(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/pkgconfig.py meson-0.61.2/mesonbuild/modules/pkgconfig.py
--- meson-0.53.2/mesonbuild/modules/pkgconfig.py 2020-01-23 22:29:05.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/pkgconfig.py 2021-12-26 16:24:25.000000000 +0000
@@ -12,21 +12,27 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os, types
from pathlib import PurePath
+import os
+import typing as T
+from . import ExtensionModule
+from . import ModuleReturnValue
from .. import build
from .. import dependencies
from .. import mesonlib
from .. import mlog
-from . import ModuleReturnValue
-from . import ExtensionModule
+from ..dependencies import ThreadDependency
from ..interpreterbase import permittedKwargs, FeatureNew, FeatureNewKwargs
+if T.TYPE_CHECKING:
+ from . import ModuleState
+
already_warned_objs = set()
class DependenciesHelper:
- def __init__(self, name):
+ def __init__(self, state, name):
+ self.state = state
self.name = name
self.pub_libs = []
self.pub_reqs = []
@@ -34,6 +40,7 @@
self.priv_reqs = []
self.cflags = []
self.version_reqs = {}
+ self.link_whole_targets = []
def add_pub_libs(self, libs):
libs, reqs, cflags = self._process_libs(libs, True)
@@ -72,15 +79,12 @@
def _process_reqs(self, reqs):
'''Returns string names of requirements'''
processed_reqs = []
- for obj in mesonlib.listify(reqs, unholder=True):
+ for obj in mesonlib.listify(reqs):
+ if not isinstance(obj, str):
+ FeatureNew.single_use('pkgconfig.generate requirement from non-string object', '0.46.0', self.state.subproject)
if hasattr(obj, 'generated_pc'):
self._check_generated_pc_deprecation(obj)
processed_reqs.append(obj.generated_pc)
- elif hasattr(obj, 'pcdep'):
- pcdeps = mesonlib.listify(obj.pcdep)
- for d in pcdeps:
- processed_reqs.append(d.name)
- self.add_version_reqs(d.name, obj.version_reqs)
elif isinstance(obj, dependencies.PkgConfigDependency):
if obj.found():
processed_reqs.append(obj.name)
@@ -91,53 +95,40 @@
self.add_version_reqs(name, version_req)
elif isinstance(obj, dependencies.Dependency) and not obj.found():
pass
- elif isinstance(obj, dependencies.ThreadDependency):
+ elif isinstance(obj, ThreadDependency):
pass
else:
raise mesonlib.MesonException('requires argument not a string, '
'library with pkgconfig-generated file '
- 'or pkgconfig-dependency object, '
- 'got {!r}'.format(obj))
+ 'or pkgconfig-dependency object, got {obj!r}')
return processed_reqs
def add_cflags(self, cflags):
self.cflags += mesonlib.stringlistify(cflags)
- def _process_libs(self, libs, public):
- libs = mesonlib.listify(libs, unholder=True)
+ def _process_libs(self, libs, public: bool):
+ libs = mesonlib.listify(libs)
processed_libs = []
processed_reqs = []
processed_cflags = []
for obj in libs:
- shared_library_only = getattr(obj, 'shared_library_only', False)
- if hasattr(obj, 'pcdep'):
- pcdeps = mesonlib.listify(obj.pcdep)
- for d in pcdeps:
- processed_reqs.append(d.name)
- self.add_version_reqs(d.name, obj.version_reqs)
- elif hasattr(obj, 'generated_pc'):
+ if hasattr(obj, 'generated_pc'):
self._check_generated_pc_deprecation(obj)
processed_reqs.append(obj.generated_pc)
elif isinstance(obj, dependencies.PkgConfigDependency):
if obj.found():
processed_reqs.append(obj.name)
self.add_version_reqs(obj.name, obj.version_reqs)
- elif isinstance(obj, dependencies.ThreadDependency):
- processed_libs += obj.get_compiler().thread_link_flags(obj.env)
- processed_cflags += obj.get_compiler().thread_flags(obj.env)
elif isinstance(obj, dependencies.InternalDependency):
if obj.found():
processed_libs += obj.get_link_args()
processed_cflags += obj.get_compile_args()
- if public:
- self.add_pub_libs(obj.libraries)
- else:
- self.add_priv_libs(obj.libraries)
+ self._add_lib_dependencies(obj.libraries, obj.whole_libraries, obj.ext_deps, public, private_external_deps=True)
elif isinstance(obj, dependencies.Dependency):
if obj.found():
processed_libs += obj.get_link_args()
processed_cflags += obj.get_compile_args()
- elif isinstance(obj, build.SharedLibrary) and shared_library_only:
+ elif isinstance(obj, build.SharedLibrary) and obj.shared_library_only:
# Do not pull dependencies for shared libraries because they are
# only required for static linking. Adding private requires has
# the side effect of exposing their cflags, which is the
@@ -147,19 +138,54 @@
processed_libs.append(obj)
elif isinstance(obj, (build.SharedLibrary, build.StaticLibrary)):
processed_libs.append(obj)
- if isinstance(obj, build.StaticLibrary) and public:
- self.add_pub_libs(obj.get_dependencies(for_pkgconfig=True))
- self.add_pub_libs(obj.get_external_deps())
- else:
- self.add_priv_libs(obj.get_dependencies(for_pkgconfig=True))
- self.add_priv_libs(obj.get_external_deps())
+ # If there is a static library in `Libs:` all its deps must be
+ # public too, otherwise the generated pc file will never be
+ # usable without --static.
+ self._add_lib_dependencies(obj.link_targets,
+ obj.link_whole_targets,
+ obj.external_deps,
+ isinstance(obj, build.StaticLibrary) and public)
+ elif isinstance(obj, (build.CustomTarget, build.CustomTargetIndex)):
+ if not obj.is_linkable_target():
+ raise mesonlib.MesonException('library argument contains a not linkable custom_target.')
+ FeatureNew.single_use('custom_target in pkgconfig.generate libraries', '0.58.0', self.state.subproject)
+ processed_libs.append(obj)
elif isinstance(obj, str):
processed_libs.append(obj)
else:
- raise mesonlib.MesonException('library argument not a string, library or dependency object.')
+ raise mesonlib.MesonException(f'library argument of type {type(obj).__name__} not a string, library or dependency object.')
return processed_libs, processed_reqs, processed_cflags
+ def _add_lib_dependencies(self, link_targets, link_whole_targets, external_deps, public, private_external_deps=False):
+ add_libs = self.add_pub_libs if public else self.add_priv_libs
+ # Recursively add all linked libraries
+ for t in link_targets:
+ # Internal libraries (uninstalled static library) will be promoted
+ # to link_whole, treat them as such here.
+ if t.is_internal():
+ self._add_link_whole(t, public)
+ else:
+ add_libs([t])
+ for t in link_whole_targets:
+ self._add_link_whole(t, public)
+ # And finally its external dependencies
+ if private_external_deps:
+ self.add_priv_libs(external_deps)
+ else:
+ add_libs(external_deps)
+
+ def _add_link_whole(self, t, public):
+ # Don't include static libraries that we link_whole. But we still need to
+ # include their dependencies: a static library we link_whole
+ # could itself link to a shared library or an installed static library.
+ # Keep track of link_whole_targets so we can remove them from our
+ # lists in case a library is link_with and link_whole at the same time.
+ # See remove_dups() below.
+ self.link_whole_targets.append(t)
+ if isinstance(t, build.BuildTarget):
+ self._add_lib_dependencies(t.link_targets, t.link_whole_targets, t.external_deps, public)
+
def add_version_reqs(self, name, version_reqs):
if version_reqs:
if name not in self.version_reqs:
@@ -195,6 +221,32 @@
return ', '.join(result)
def remove_dups(self):
+ # Set of ids that have already been handled and should not be added any more
+ exclude = set()
+
+ # We can't just check if 'x' is excluded because we could have copies of
+ # the same SharedLibrary object for example.
+ def _ids(x):
+ if hasattr(x, 'generated_pc'):
+ yield x.generated_pc
+ if isinstance(x, build.Target):
+ yield x.get_id()
+ yield x
+
+ # Exclude 'x' in all its forms and return if it was already excluded
+ def _add_exclude(x):
+ was_excluded = False
+ for i in _ids(x):
+ if i in exclude:
+ was_excluded = True
+ else:
+ exclude.add(i)
+ return was_excluded
+
+ # link_whole targets are already part of other targets, exclude them all.
+ for t in self.link_whole_targets:
+ _add_exclude(t)
+
def _fn(xs, libs=False):
# Remove duplicates whilst preserving original order
result = []
@@ -205,22 +257,35 @@
cannot_dedup = libs and isinstance(x, str) and \
not x.startswith(('-l', '-L')) and \
x not in known_flags
- if x not in result or cannot_dedup:
- result.append(x)
+ if not cannot_dedup and _add_exclude(x):
+ continue
+ result.append(x)
return result
- self.pub_libs = _fn(self.pub_libs, True)
+
+ # Handle lists in priority order: public items can be excluded from
+ # private and Requires can excluded from Libs.
self.pub_reqs = _fn(self.pub_reqs)
- self.priv_libs = _fn(self.priv_libs, True)
+ self.pub_libs = _fn(self.pub_libs, True)
self.priv_reqs = _fn(self.priv_reqs)
+ self.priv_libs = _fn(self.priv_libs, True)
+ # Reset exclude list just in case some values can be both cflags and libs.
+ exclude = set()
self.cflags = _fn(self.cflags)
- # Remove from private libs/reqs if they are in public already
- self.priv_libs = [i for i in self.priv_libs if i not in self.pub_libs]
- self.priv_reqs = [i for i in self.priv_reqs if i not in self.pub_reqs]
-
class PkgConfigModule(ExtensionModule):
-
- def _get_lname(self, l, msg, pcfile):
+ def __init__(self, interpreter):
+ super().__init__(interpreter)
+ self.methods.update({
+ 'generate': self.generate,
+ })
+
+ def _get_lname(self, l, msg, pcfile, is_custom_target):
+ if is_custom_target:
+ basename = os.path.basename(l.get_filename())
+ name = os.path.splitext(basename)[0]
+ if name.startswith('lib'):
+ name = name[3:]
+ return name
# Nothing special
if not l.name_prefix_set:
return l.name
@@ -251,45 +316,58 @@
return value.replace(' ', r'\ ')
def _make_relative(self, prefix, subdir):
- if isinstance(prefix, PurePath):
- prefix = prefix.as_posix()
- if isinstance(subdir, PurePath):
- subdir = subdir.as_posix()
- if subdir.startswith(prefix):
- subdir = subdir.replace(prefix, '')
- return subdir
-
- def generate_pkgconfig_file(self, state, deps, subdirs, name, description,
- url, version, pcfile, conflicts, variables):
- deps.remove_dups()
+ prefix = PurePath(prefix)
+ subdir = PurePath(subdir)
+ try:
+ libdir = subdir.relative_to(prefix)
+ except ValueError:
+ libdir = subdir
+ # pathlib joining makes sure absolute libdir is not appended to '${prefix}'
+ return ('${prefix}' / libdir).as_posix()
+
+ def _generate_pkgconfig_file(self, state, deps, subdirs, name, description,
+ url, version, pcfile, conflicts, variables,
+ unescaped_variables, uninstalled=False, dataonly=False):
coredata = state.environment.get_coredata()
- outdir = state.environment.scratch_dir
- fname = os.path.join(outdir, pcfile)
- prefix = PurePath(coredata.get_builtin_option('prefix'))
+ if uninstalled:
+ outdir = os.path.join(state.environment.build_dir, 'meson-uninstalled')
+ if not os.path.exists(outdir):
+ os.mkdir(outdir)
+ prefix = PurePath(state.environment.get_build_dir())
+ srcdir = PurePath(state.environment.get_source_dir())
+ else:
+ outdir = state.environment.scratch_dir
+ prefix = PurePath(coredata.get_option(mesonlib.OptionKey('prefix')))
# These always return paths relative to prefix
- libdir = PurePath(coredata.get_builtin_option('libdir'))
- incdir = PurePath(coredata.get_builtin_option('includedir'))
+ libdir = PurePath(coredata.get_option(mesonlib.OptionKey('libdir')))
+ incdir = PurePath(coredata.get_option(mesonlib.OptionKey('includedir')))
+ fname = os.path.join(outdir, pcfile)
with open(fname, 'w', encoding='utf-8') as ofile:
- ofile.write('prefix={}\n'.format(self._escape(prefix)))
- ofile.write('libdir={}\n'.format(self._escape('${prefix}' / libdir)))
- ofile.write('includedir={}\n'.format(self._escape('${prefix}' / incdir)))
- if variables:
+ if not dataonly:
+ ofile.write('prefix={}\n'.format(self._escape(prefix)))
+ if uninstalled:
+ ofile.write('srcdir={}\n'.format(self._escape(srcdir)))
+ ofile.write('libdir={}\n'.format(self._escape('${prefix}' / libdir)))
+ ofile.write('includedir={}\n'.format(self._escape('${prefix}' / incdir)))
+ if variables or unescaped_variables:
ofile.write('\n')
for k, v in variables:
ofile.write('{}={}\n'.format(k, self._escape(v)))
+ for k, v in unescaped_variables:
+ ofile.write(f'{k}={v}\n')
ofile.write('\n')
- ofile.write('Name: %s\n' % name)
+ ofile.write(f'Name: {name}\n')
if len(description) > 0:
- ofile.write('Description: %s\n' % description)
+ ofile.write(f'Description: {description}\n')
if len(url) > 0:
- ofile.write('URL: %s\n' % url)
- ofile.write('Version: %s\n' % version)
+ ofile.write(f'URL: {url}\n')
+ ofile.write(f'Version: {version}\n')
reqs_str = deps.format_reqs(deps.pub_reqs)
if len(reqs_str) > 0:
- ofile.write('Requires: {}\n'.format(reqs_str))
+ ofile.write(f'Requires: {reqs_str}\n')
reqs_str = deps.format_reqs(deps.priv_reqs)
if len(reqs_str) > 0:
- ofile.write('Requires.private: {}\n'.format(reqs_str))
+ ofile.write(f'Requires.private: {reqs_str}\n')
if len(conflicts) > 0:
ofile.write('Conflicts: {}\n'.format(' '.join(conflicts)))
@@ -302,75 +380,116 @@
if isinstance(l, str):
yield l
else:
- install_dir = l.get_custom_install_dir()[0]
+ if uninstalled:
+ install_dir = os.path.dirname(state.backend.get_target_filename_abs(l))
+ else:
+ _i = l.get_custom_install_dir()
+ install_dir = _i[0] if _i else None
if install_dir is False:
continue
- if 'cs' in l.compilers:
+ is_custom_target = isinstance(l, (build.CustomTarget, build.CustomTargetIndex))
+ if not is_custom_target and 'cs' in l.compilers:
if isinstance(install_dir, str):
- Lflag = '-r${prefix}/%s/%s ' % (self._escape(self._make_relative(prefix, install_dir)), l.filename)
+ Lflag = '-r{}/{}'.format(self._escape(self._make_relative(prefix, install_dir)), l.filename)
else: # install_dir is True
Lflag = '-r${libdir}/%s' % l.filename
else:
if isinstance(install_dir, str):
- Lflag = '-L${prefix}/%s ' % self._escape(self._make_relative(prefix, install_dir))
+ Lflag = '-L{}'.format(self._escape(self._make_relative(prefix, install_dir)))
else: # install_dir is True
Lflag = '-L${libdir}'
if Lflag not in Lflags:
Lflags.append(Lflag)
yield Lflag
- lname = self._get_lname(l, msg, pcfile)
+ lname = self._get_lname(l, msg, pcfile, is_custom_target)
# If using a custom suffix, the compiler may not be able to
# find the library
- if l.name_suffix_set:
+ if not is_custom_target and l.name_suffix_set:
mlog.warning(msg.format(l.name, 'name_suffix', lname, pcfile))
- if 'cs' not in l.compilers:
- yield '-l%s' % lname
+ if is_custom_target or 'cs' not in l.compilers:
+ yield f'-l{lname}'
+
+ def get_uninstalled_include_dirs(libs):
+ result = []
+ for l in libs:
+ if isinstance(l, (str, build.CustomTarget, build.CustomTargetIndex)):
+ continue
+ if l.get_subdir() not in result:
+ result.append(l.get_subdir())
+ for i in l.get_include_dirs():
+ curdir = i.get_curdir()
+ for d in i.get_incdirs():
+ path = os.path.join(curdir, d)
+ if path not in result:
+ result.append(path)
+ return result
+
+ def generate_uninstalled_cflags(libs):
+ for d in get_uninstalled_include_dirs(libs):
+ for basedir in ['${prefix}', '${srcdir}']:
+ path = PurePath(basedir, d)
+ yield '-I%s' % self._escape(path.as_posix())
if len(deps.pub_libs) > 0:
ofile.write('Libs: {}\n'.format(' '.join(generate_libs_flags(deps.pub_libs))))
if len(deps.priv_libs) > 0:
ofile.write('Libs.private: {}\n'.format(' '.join(generate_libs_flags(deps.priv_libs))))
- ofile.write('Cflags:')
- for h in subdirs:
- ofile.write(' ')
- if h == '.':
- ofile.write('-I${includedir}')
- else:
- ofile.write(self._escape(PurePath('-I${includedir}') / h))
- for f in deps.cflags:
- ofile.write(' ')
- ofile.write(self._escape(f))
- ofile.write('\n')
+ cflags = []
+ if uninstalled:
+ cflags += generate_uninstalled_cflags(deps.pub_libs + deps.priv_libs)
+ else:
+ for d in subdirs:
+ if d == '.':
+ cflags.append('-I${includedir}')
+ else:
+ cflags.append(self._escape(PurePath('-I${includedir}') / d))
+ cflags += [self._escape(f) for f in deps.cflags]
+ if cflags and not dataonly:
+ ofile.write('Cflags: {}\n'.format(' '.join(cflags)))
+
+ @FeatureNewKwargs('pkgconfig.generate', '0.59.0', ['unescaped_variables', 'unescaped_uninstalled_variables'])
+ @FeatureNewKwargs('pkgconfig.generate', '0.54.0', ['uninstalled_variables'])
@FeatureNewKwargs('pkgconfig.generate', '0.42.0', ['extra_cflags'])
@FeatureNewKwargs('pkgconfig.generate', '0.41.0', ['variables'])
+ @FeatureNewKwargs('pkgconfig.generate', '0.54.0', ['dataonly'])
@permittedKwargs({'libraries', 'version', 'name', 'description', 'filebase',
'subdirs', 'requires', 'requires_private', 'libraries_private',
- 'install_dir', 'extra_cflags', 'variables', 'url', 'd_module_versions'})
- def generate(self, state, args, kwargs):
- if 'variables' in kwargs:
- FeatureNew('custom pkgconfig variables', '0.41.0').use(state.subproject)
- default_version = state.project_version['version']
+ 'install_dir', 'extra_cflags', 'variables', 'url', 'd_module_versions',
+ 'dataonly', 'conflicts', 'uninstalled_variables',
+ 'unescaped_variables', 'unescaped_uninstalled_variables'})
+ def generate(self, state: 'ModuleState', args, kwargs):
+ default_version = state.project_version
default_install_dir = None
default_description = None
default_name = None
mainlib = None
+ default_subdirs = ['.']
if not args and 'version' not in kwargs:
- FeatureNew('pkgconfig.generate implicit version keyword', '0.46.0').use(state.subproject)
+ FeatureNew.single_use('pkgconfig.generate implicit version keyword', '0.46.0', state.subproject)
elif len(args) == 1:
- FeatureNew('pkgconfig.generate optional positional argument', '0.46.0').use(state.subproject)
- mainlib = getattr(args[0], 'held_object', args[0])
+ FeatureNew.single_use('pkgconfig.generate optional positional argument', '0.46.0', state.subproject)
+ mainlib = args[0]
if not isinstance(mainlib, (build.StaticLibrary, build.SharedLibrary)):
raise mesonlib.MesonException('Pkgconfig_gen first positional argument must be a library object')
default_name = mainlib.name
default_description = state.project_name + ': ' + mainlib.name
- install_dir = mainlib.get_custom_install_dir()[0]
- if isinstance(install_dir, str):
- default_install_dir = os.path.join(install_dir, 'pkgconfig')
+ install_dir = mainlib.get_custom_install_dir()
+ if install_dir and isinstance(install_dir[0], str):
+ default_install_dir = os.path.join(install_dir[0], 'pkgconfig')
elif len(args) > 1:
raise mesonlib.MesonException('Too many positional arguments passed to Pkgconfig_gen.')
- subdirs = mesonlib.stringlistify(kwargs.get('subdirs', ['.']))
+ dataonly = kwargs.get('dataonly', False)
+ if not isinstance(dataonly, bool):
+ raise mesonlib.MesonException('dataonly must be boolean.')
+ if dataonly:
+ default_subdirs = []
+ blocked_vars = ['libraries', 'libraries_private', 'require_private', 'extra_cflags', 'subdirs']
+ if any(k in kwargs for k in blocked_vars):
+ raise mesonlib.MesonException(f'Cannot combine dataonly with any of {blocked_vars}')
+
+ subdirs = mesonlib.stringlistify(kwargs.get('subdirs', default_subdirs))
version = kwargs.get('version', default_version)
if not isinstance(version, str):
raise mesonlib.MesonException('Version must be specified.')
@@ -395,7 +514,7 @@
if mainlib:
libraries = [mainlib] + libraries
- deps = DependenciesHelper(filebase)
+ deps = DependenciesHelper(state, filebase)
deps.add_pub_libs(libraries)
deps.add_priv_libs(kwargs.get('libraries_private', []))
deps.add_pub_reqs(kwargs.get('requires', []))
@@ -408,44 +527,46 @@
if compiler:
deps.add_cflags(compiler.get_feature_args({'versions': dversions}, None))
- def parse_variable_list(stringlist):
+ deps.remove_dups()
+
+ def parse_variable_list(vardict):
reserved = ['prefix', 'libdir', 'includedir']
variables = []
- for var in stringlist:
- # foo=bar=baz is ('foo', 'bar=baz')
- l = var.split('=', 1)
- if len(l) < 2:
- raise mesonlib.MesonException('Invalid variable "{}". Variables must be in \'name=value\' format'.format(var))
-
- name, value = l[0].strip(), l[1].strip()
- if not name or not value:
- raise mesonlib.MesonException('Invalid variable "{}". Variables must be in \'name=value\' format'.format(var))
-
- # Variable names must not contain whitespaces
- if any(c.isspace() for c in name):
- raise mesonlib.MesonException('Invalid whitespace in assignment "{}"'.format(var))
-
- if name in reserved:
- raise mesonlib.MesonException('Variable "{}" is reserved'.format(name))
-
+ for name, value in vardict.items():
+ if not dataonly and name in reserved:
+ raise mesonlib.MesonException(f'Variable "{name}" is reserved')
variables.append((name, value))
-
return variables
- variables = parse_variable_list(mesonlib.stringlistify(kwargs.get('variables', [])))
+ variables = self.interpreter.extract_variables(kwargs, dict_new=True)
+ variables = parse_variable_list(variables)
+ unescaped_variables = self.interpreter.extract_variables(kwargs, argname='unescaped_variables')
+ unescaped_variables = parse_variable_list(unescaped_variables)
pcfile = filebase + '.pc'
- pkgroot = kwargs.get('install_dir', default_install_dir)
+ pkgroot = pkgroot_name = kwargs.get('install_dir', default_install_dir)
if pkgroot is None:
if mesonlib.is_freebsd():
- pkgroot = os.path.join(state.environment.coredata.get_builtin_option('prefix'), 'libdata', 'pkgconfig')
+ pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('prefix')), 'libdata', 'pkgconfig')
+ pkgroot_name = os.path.join('{prefix}', 'libdata', 'pkgconfig')
else:
- pkgroot = os.path.join(state.environment.coredata.get_builtin_option('libdir'), 'pkgconfig')
+ pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'pkgconfig')
+ pkgroot_name = os.path.join('{libdir}', 'pkgconfig')
if not isinstance(pkgroot, str):
raise mesonlib.MesonException('Install_dir must be a string.')
- self.generate_pkgconfig_file(state, deps, subdirs, name, description, url,
- version, pcfile, conflicts, variables)
- res = build.Data(mesonlib.File(True, state.environment.get_scratch_dir(), pcfile), pkgroot)
+ self._generate_pkgconfig_file(state, deps, subdirs, name, description, url,
+ version, pcfile, conflicts, variables,
+ unescaped_variables, False, dataonly)
+ res = build.Data([mesonlib.File(True, state.environment.get_scratch_dir(), pcfile)], pkgroot, pkgroot_name, None, state.subproject, install_tag='devel')
+ variables = self.interpreter.extract_variables(kwargs, argname='uninstalled_variables', dict_new=True)
+ variables = parse_variable_list(variables)
+ unescaped_variables = self.interpreter.extract_variables(kwargs, argname='unescaped_uninstalled_variables')
+ unescaped_variables = parse_variable_list(unescaped_variables)
+
+ pcfile = filebase + '-uninstalled.pc'
+ self._generate_pkgconfig_file(state, deps, subdirs, name, description, url,
+ version, pcfile, conflicts, variables,
+ unescaped_variables, uninstalled=True, dataonly=dataonly)
# Associate the main library with this generated pc file. If the library
# is used in any subsequent call to the generated, it will generate a
# 'Requires:' or 'Requires.private:'.
@@ -461,8 +582,7 @@
for lib in deps.pub_libs:
if not isinstance(lib, str) and not hasattr(lib, 'generated_pc'):
lib.generated_pc = filebase
- location = types.SimpleNamespace(subdir=state.subdir,
- lineno=state.current_lineno)
+ location = state.current_node
lib.generated_pc_warn = [name, location]
return ModuleReturnValue(res, [res])
diff -Nru meson-0.53.2/mesonbuild/modules/python3.py meson-0.61.2/mesonbuild/modules/python3.py
--- meson-0.53.2/mesonbuild/modules/python3.py 2019-02-07 09:08:55.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/python3.py 2022-01-02 20:12:32.000000000 +0000
@@ -13,22 +13,28 @@
# limitations under the License.
import sysconfig
-from .. import mesonlib, dependencies
+from .. import mesonlib
from . import ExtensionModule
-from mesonbuild.modules import ModuleReturnValue
-from ..interpreterbase import noKwargs, permittedKwargs, FeatureDeprecated
+from ..interpreterbase import noKwargs, permittedKwargs, FeatureDeprecated, FeatureNew
from ..build import known_shmod_kwargs
+from ..programs import ExternalProgram
class Python3Module(ExtensionModule):
+ @FeatureNew('python3 module', '0.38.0')
@FeatureDeprecated('python3 module', '0.48.0')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
- self.snippets.add('extension_module')
+ self.methods.update({
+ 'extension_module': self.extension_module,
+ 'find_python': self.find_python,
+ 'language_version': self.language_version,
+ 'sysconfig_path': self.sysconfig_path,
+ })
@permittedKwargs(known_shmod_kwargs)
- def extension_module(self, interpreter, state, args, kwargs):
+ def extension_module(self, state, args, kwargs):
if 'name_prefix' in kwargs:
raise mesonlib.MesonException('Name_prefix is set automatically, specifying it is forbidden.')
if 'name_suffix' in kwargs:
@@ -44,20 +50,20 @@
suffix = []
kwargs['name_prefix'] = ''
kwargs['name_suffix'] = suffix
- return interpreter.func_shared_module(None, args, kwargs)
+ return self.interpreter.func_shared_module(None, args, kwargs)
@noKwargs
def find_python(self, state, args, kwargs):
- command = state.environment.binaries.host.lookup_entry('python3')
+ command = state.environment.lookup_binary_entry(mesonlib.MachineChoice.HOST, 'python3')
if command is not None:
- py3 = dependencies.ExternalProgram.from_entry('python3', command)
+ py3 = ExternalProgram.from_entry('python3', command)
else:
- py3 = dependencies.ExternalProgram('python3', mesonlib.python_command, silent=True)
- return ModuleReturnValue(py3, [py3])
+ py3 = ExternalProgram('python3', mesonlib.python_command, silent=True)
+ return py3
@noKwargs
def language_version(self, state, args, kwargs):
- return ModuleReturnValue(sysconfig.get_python_version(), [])
+ return sysconfig.get_python_version()
@noKwargs
def sysconfig_path(self, state, args, kwargs):
@@ -66,11 +72,10 @@
path_name = args[0]
valid_names = sysconfig.get_path_names()
if path_name not in valid_names:
- raise mesonlib.MesonException('{} is not a valid path name {}.'.format(path_name, valid_names))
+ raise mesonlib.MesonException(f'{path_name} is not a valid path name {valid_names}.')
# Get a relative path without a prefix, e.g. lib/python3.6/site-packages
- path = sysconfig.get_path(path_name, vars={'base': '', 'platbase': '', 'installed_base': ''})[1:]
- return ModuleReturnValue(path, [])
+ return sysconfig.get_path(path_name, vars={'base': '', 'platbase': '', 'installed_base': ''})[1:]
def initialize(*args, **kwargs):
diff -Nru meson-0.53.2/mesonbuild/modules/python.py meson-0.61.2/mesonbuild/modules/python.py
--- meson-0.53.2/mesonbuild/modules/python.py 2020-02-25 18:00:46.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/python.py 2021-12-26 16:24:25.000000000 +0000
@@ -12,122 +12,99 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os
+from pathlib import Path
+import functools
import json
+import os
import shutil
import typing as T
-from pathlib import Path
-from .. import mesonlib
-from ..mesonlib import MesonException
from . import ExtensionModule
-from mesonbuild.modules import ModuleReturnValue
-from ..interpreterbase import (
- noPosargs, noKwargs, permittedKwargs,
- InvalidArguments,
- FeatureNew, FeatureNewKwargs, disablerIfNotFound
-)
-from ..interpreter import ExternalProgramHolder, extract_required_kwarg, permitted_kwargs
-from ..build import known_shmod_kwargs
+from .. import mesonlib
from .. import mlog
+from ..coredata import UserFeatureOption
+from ..build import known_shmod_kwargs
+from ..dependencies import DependencyMethods, PkgConfigDependency, NotFoundDependency, SystemDependency, ExtraFrameworkDependency
+from ..dependencies.base import process_method_kw
from ..environment import detect_cpu_family
-from ..dependencies.base import (
- DependencyMethods, ExternalDependency,
- ExternalProgram, PkgConfigDependency,
- NonExistingExternalProgram
+from ..interpreter import ExternalProgramHolder, extract_required_kwarg, permitted_dependency_kwargs
+from ..interpreter.type_checking import NoneType
+from ..interpreterbase import (
+ noPosargs, noKwargs, permittedKwargs, ContainerTypeInfo,
+ InvalidArguments, typed_pos_args, typed_kwargs, KwargInfo,
+ FeatureNew, FeatureNewKwargs, disablerIfNotFound
)
+from ..mesonlib import MachineChoice
+from ..programs import ExternalProgram, NonExistingExternalProgram
+
+if T.TYPE_CHECKING:
+ from . import ModuleState
+ from ..build import SharedModule, Data
+ from ..dependencies import ExternalDependency, Dependency
+ from ..dependencies.factory import DependencyGenerator
+ from ..environment import Environment
+ from ..interpreter import Interpreter
+ from ..interpreterbase.interpreterbase import TYPE_var, TYPE_kwargs
+
+ from typing_extensions import TypedDict
-mod_kwargs = set(['subdir'])
+
+mod_kwargs = {'subdir'}
mod_kwargs.update(known_shmod_kwargs)
-mod_kwargs -= set(['name_prefix', 'name_suffix'])
+mod_kwargs -= {'name_prefix', 'name_suffix'}
+
-class PythonDependency(ExternalDependency):
+if T.TYPE_CHECKING:
+ _Base = ExternalDependency
+else:
+ _Base = object
- def __init__(self, python_holder, environment, kwargs):
- super().__init__('python', environment, None, kwargs)
- self.name = 'python'
- self.static = kwargs.get('static', False)
- self.embed = kwargs.get('embed', False)
- self.version = python_holder.version
+class _PythonDependencyBase(_Base):
+
+ def __init__(self, python_holder: 'PythonInstallation', embed: bool):
+ self.name = 'python' # override the name from the "real" dependency lookup
+ self.embed = embed
+ self.version: str = python_holder.version
self.platform = python_holder.platform
- self.pkgdep = None
self.variables = python_holder.variables
self.paths = python_holder.paths
self.link_libpython = python_holder.link_libpython
+ self.info: T.Optional[T.Dict[str, str]] = None
if mesonlib.version_compare(self.version, '>= 3.0'):
self.major_version = 3
else:
self.major_version = 2
- # We first try to find the necessary python variables using pkgconfig
- if DependencyMethods.PKGCONFIG in self.methods and not python_holder.is_pypy:
- pkg_version = self.variables.get('LDVERSION') or self.version
- pkg_libdir = self.variables.get('LIBPC')
- pkg_embed = '-embed' if self.embed and mesonlib.version_compare(self.version, '>=3.8') else ''
- pkg_name = 'python-{}{}'.format(pkg_version, pkg_embed)
-
- # If python-X.Y.pc exists in LIBPC, we will try to use it
- if pkg_libdir is not None and Path(os.path.join(pkg_libdir, '{}.pc'.format(pkg_name))).is_file():
- old_pkg_libdir = os.environ.get('PKG_CONFIG_LIBDIR')
- old_pkg_path = os.environ.get('PKG_CONFIG_PATH')
-
- os.environ.pop('PKG_CONFIG_PATH', None)
-
- if pkg_libdir:
- os.environ['PKG_CONFIG_LIBDIR'] = pkg_libdir
-
- try:
- self.pkgdep = PkgConfigDependency(pkg_name, environment, kwargs)
- mlog.debug('Found "{}" via pkgconfig lookup in LIBPC ({})'.format(pkg_name, pkg_libdir))
- py_lookup_method = 'pkgconfig'
- except MesonException as e:
- mlog.debug('"{}" could not be found in LIBPC ({})'.format(pkg_name, pkg_libdir))
- mlog.debug(e)
- if old_pkg_path is not None:
- os.environ['PKG_CONFIG_PATH'] = old_pkg_path
+class PythonPkgConfigDependency(PkgConfigDependency, _PythonDependencyBase):
- if old_pkg_libdir is not None:
- os.environ['PKG_CONFIG_LIBDIR'] = old_pkg_libdir
- else:
- os.environ.pop('PKG_CONFIG_LIBDIR', None)
- else:
- mlog.debug('"{}" could not be found in LIBPC ({}), this is likely due to a relocated python installation'.format(pkg_name, pkg_libdir))
+ def __init__(self, name: str, environment: 'Environment',
+ kwargs: T.Dict[str, T.Any], installation: 'PythonInstallation'):
+ PkgConfigDependency.__init__(self, name, environment, kwargs)
+ _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
+
+
+class PythonFrameworkDependency(ExtraFrameworkDependency, _PythonDependencyBase):
+
+ def __init__(self, name: str, environment: 'Environment',
+ kwargs: T.Dict[str, T.Any], installation: 'PythonInstallation'):
+ ExtraFrameworkDependency.__init__(self, name, environment, kwargs)
+ _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
- # If lookup via LIBPC failed, try to use fallback PKG_CONFIG_LIBDIR/PKG_CONFIG_PATH mechanisms
- if self.pkgdep is None or not self.pkgdep.found():
- try:
- self.pkgdep = PkgConfigDependency(pkg_name, environment, kwargs)
- mlog.debug('Found "{}" via fallback pkgconfig lookup in PKG_CONFIG_LIBDIR/PKG_CONFIG_PATH'.format(pkg_name))
- py_lookup_method = 'pkgconfig-fallback'
- except MesonException as e:
- mlog.debug('"{}" could not be found via fallback pkgconfig lookup in PKG_CONFIG_LIBDIR/PKG_CONFIG_PATH'.format(pkg_name))
- mlog.debug(e)
-
- if self.pkgdep and self.pkgdep.found():
- self.compile_args = self.pkgdep.get_compile_args()
- self.link_args = self.pkgdep.get_link_args()
- self.is_found = True
- self.pcdep = self.pkgdep
- else:
- self.pkgdep = None
-
- # Finally, try to find python via SYSCONFIG as a final measure
- if DependencyMethods.SYSCONFIG in self.methods:
- if mesonlib.is_windows():
- self._find_libpy_windows(environment)
- else:
- self._find_libpy(python_holder, environment)
- if self.is_found:
- mlog.debug('Found "python-{}" via SYSCONFIG module'.format(self.version))
- py_lookup_method = 'sysconfig'
- if self.is_found:
- mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.green('YES ({})'.format(py_lookup_method)))
+class PythonSystemDependency(SystemDependency, _PythonDependencyBase):
+
+ def __init__(self, name: str, environment: 'Environment',
+ kwargs: T.Dict[str, T.Any], installation: 'PythonInstallation'):
+ SystemDependency.__init__(self, name, environment, kwargs)
+ _PythonDependencyBase.__init__(self, installation, kwargs.get('embed', False))
+
+ if mesonlib.is_windows():
+ self._find_libpy_windows(environment)
else:
- mlog.log('Dependency', mlog.bold(self.name), 'found:', mlog.red('NO'))
+ self._find_libpy(installation, environment)
- def _find_libpy(self, python_holder, environment):
+ def _find_libpy(self, python_holder: 'PythonInstallation', environment: 'Environment') -> None:
if python_holder.is_pypy:
if self.major_version == 3:
libname = 'pypy3-c'
@@ -136,7 +113,7 @@
libdir = os.path.join(self.variables.get('base'), 'bin')
libdirs = [libdir]
else:
- libname = 'python{}'.format(self.version)
+ libname = f'python{self.version}'
if 'DEBUG_EXT' in self.variables:
libname += self.variables['DEBUG_EXT']
if 'ABIFLAGS' in self.variables:
@@ -156,7 +133,7 @@
self.compile_args += ['-I' + path for path in inc_paths if path]
- def get_windows_python_arch(self):
+ def _get_windows_python_arch(self) -> T.Optional[str]:
if self.platform == 'mingw':
pycc = self.variables.get('CC')
if pycc.startswith('x86_64'):
@@ -164,45 +141,48 @@
elif pycc.startswith(('i686', 'i386')):
return '32'
else:
- mlog.log('MinGW Python built with unknown CC {!r}, please file'
- 'a bug'.format(pycc))
+ mlog.log(f'MinGW Python built with unknown CC {pycc!r}, please file a bug')
return None
elif self.platform == 'win32':
return '32'
elif self.platform in ('win64', 'win-amd64'):
return '64'
- mlog.log('Unknown Windows Python platform {!r}'.format(self.platform))
+ mlog.log(f'Unknown Windows Python platform {self.platform!r}')
return None
- def get_windows_link_args(self):
+ def _get_windows_link_args(self) -> T.Optional[T.List[str]]:
if self.platform.startswith('win'):
vernum = self.variables.get('py_version_nodot')
if self.static:
- libpath = Path('libs') / 'libpython{}.a'.format(vernum)
+ libpath = Path('libs') / f'libpython{vernum}.a'
else:
comp = self.get_compiler()
if comp.id == "gcc":
- libpath = 'python{}.dll'.format(vernum)
+ libpath = Path(f'python{vernum}.dll')
else:
- libpath = Path('libs') / 'python{}.lib'.format(vernum)
- lib = Path(self.variables.get('base')) / libpath
+ libpath = Path('libs') / f'python{vernum}.lib'
+ # base_prefix to allow for virtualenvs.
+ lib = Path(self.variables.get('base_prefix')) / libpath
elif self.platform == 'mingw':
if self.static:
libname = self.variables.get('LIBRARY')
else:
libname = self.variables.get('LDLIBRARY')
lib = Path(self.variables.get('LIBDIR')) / libname
+ else:
+ raise mesonlib.MesonBugException(
+ 'On a Windows path, but the OS doesn\'t appear to be Windows or MinGW.')
if not lib.exists():
mlog.log('Could not find Python3 library {!r}'.format(str(lib)))
return None
return [str(lib)]
- def _find_libpy_windows(self, env):
+ def _find_libpy_windows(self, env: 'Environment') -> None:
'''
Find python3 libraries on Windows and also verify that the arch matches
what we are building for.
'''
- pyarch = self.get_windows_python_arch()
+ pyarch = self._get_windows_python_arch()
if pyarch is None:
self.is_found = False
return
@@ -213,18 +193,17 @@
arch = '64'
else:
# We can't cross-compile Python 3 dependencies on Windows yet
- mlog.log('Unknown architecture {!r} for'.format(arch),
+ mlog.log(f'Unknown architecture {arch!r} for',
mlog.bold(self.name))
self.is_found = False
return
# Pyarch ends in '32' or '64'
if arch != pyarch:
- mlog.log('Need', mlog.bold(self.name), 'for {}-bit, but '
- 'found {}-bit'.format(arch, pyarch))
+ mlog.log('Need', mlog.bold(self.name), f'for {arch}-bit, but found {pyarch}-bit')
self.is_found = False
return
# This can fail if the library is not found
- largs = self.get_windows_link_args()
+ largs = self._get_windows_link_args()
if largs is None:
self.is_found = False
return
@@ -243,27 +222,96 @@
self.is_found = True
- @staticmethod
- def get_methods():
- if mesonlib.is_windows():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSCONFIG]
- elif mesonlib.is_osx():
- return [DependencyMethods.PKGCONFIG, DependencyMethods.EXTRAFRAMEWORK]
- else:
- return [DependencyMethods.PKGCONFIG, DependencyMethods.SYSCONFIG]
-
- def get_pkgconfig_variable(self, variable_name, kwargs):
- if self.pkgdep:
- return self.pkgdep.get_pkgconfig_variable(variable_name, kwargs)
- else:
- return super().get_pkgconfig_variable(variable_name, kwargs)
-
-INTROSPECT_COMMAND = '''import sysconfig
+def python_factory(env: 'Environment', for_machine: 'MachineChoice',
+ kwargs: T.Dict[str, T.Any], methods: T.List[DependencyMethods],
+ installation: 'PythonInstallation') -> T.List['DependencyGenerator']:
+ # We can't use the factory_methods decorator here, as we need to pass the
+ # extra installation argument
+ embed = kwargs.get('embed', False)
+ candidates: T.List['DependencyGenerator'] = []
+ pkg_version = installation.variables.get('LDVERSION') or installation.version
+
+ if DependencyMethods.PKGCONFIG in methods:
+ pkg_libdir = installation.variables.get('LIBPC')
+ pkg_embed = '-embed' if embed and mesonlib.version_compare(installation.version, '>=3.8') else ''
+ pkg_name = f'python-{pkg_version}{pkg_embed}'
+
+ # If python-X.Y.pc exists in LIBPC, we will try to use it
+ def wrap_in_pythons_pc_dir(name: str, env: 'Environment', kwargs: T.Dict[str, T.Any],
+ installation: 'PythonInstallation') -> 'ExternalDependency':
+ old_pkg_libdir = os.environ.pop('PKG_CONFIG_LIBDIR', None)
+ old_pkg_path = os.environ.pop('PKG_CONFIG_PATH', None)
+ if pkg_libdir:
+ os.environ['PKG_CONFIG_LIBDIR'] = pkg_libdir
+ try:
+ return PythonPkgConfigDependency(name, env, kwargs, installation)
+ finally:
+ def set_env(name, value):
+ if value is not None:
+ os.environ[name] = value
+ elif name in os.environ:
+ del os.environ[name]
+ set_env('PKG_CONFIG_LIBDIR', old_pkg_libdir)
+ set_env('PKG_CONFIG_PATH', old_pkg_path)
+
+ candidates.extend([
+ functools.partial(wrap_in_pythons_pc_dir, pkg_name, env, kwargs, installation),
+ functools.partial(PythonPkgConfigDependency, pkg_name, env, kwargs, installation)
+ ])
+
+ if DependencyMethods.SYSTEM in methods:
+ candidates.append(functools.partial(PythonSystemDependency, 'python', env, kwargs, installation))
+
+ if DependencyMethods.EXTRAFRAMEWORK in methods:
+ nkwargs = kwargs.copy()
+ if mesonlib.version_compare(pkg_version, '>= 3'):
+ # There is a python in /System/Library/Frameworks, but that's python 2.x,
+ # Python 3 will always be in /Library
+ nkwargs['paths'] = ['/Library/Frameworks']
+ candidates.append(functools.partial(PythonFrameworkDependency, 'Python', env, nkwargs, installation))
+
+ return candidates
+
+
+INTROSPECT_COMMAND = '''\
+import os.path
+import sysconfig
import json
import sys
+import distutils.command.install
-install_paths = sysconfig.get_paths(scheme='posix_prefix', vars={'base': '', 'platbase': '', 'installed_base': ''})
+def get_distutils_paths(scheme=None, prefix=None):
+ import distutils.dist
+ distribution = distutils.dist.Distribution()
+ install_cmd = distribution.get_command_obj('install')
+ if prefix is not None:
+ install_cmd.prefix = prefix
+ if scheme:
+ install_cmd.select_scheme(scheme)
+ install_cmd.finalize_options()
+ return {
+ 'data': install_cmd.install_data,
+ 'include': os.path.dirname(install_cmd.install_headers),
+ 'platlib': install_cmd.install_platlib,
+ 'purelib': install_cmd.install_purelib,
+ 'scripts': install_cmd.install_scripts,
+ }
+
+# On Debian derivatives, the Python interpreter shipped by the distribution uses
+# a custom install scheme, deb_system, for the system install, and changes the
+# default scheme to a custom one pointing to /usr/local and replacing
+# site-packages with dist-packages.
+# See https://github.com/mesonbuild/meson/issues/8739.
+# XXX: We should be using sysconfig, but Debian only patches distutils.
+
+if 'deb_system' in distutils.command.install.INSTALL_SCHEMES:
+ paths = get_distutils_paths(scheme='deb_system')
+ install_paths = get_distutils_paths(scheme='deb_system', prefix='')
+else:
+ paths = sysconfig.get_paths()
+ empty_vars = {'base': '', 'platbase': '', 'installed_base': ''}
+ install_paths = sysconfig.get_paths(vars=empty_vars)
def links_against_libpython():
from distutils.core import Distribution, Extension
@@ -271,10 +319,14 @@
cmd.ensure_finalized()
return bool(cmd.get_libraries(Extension('dummy', [])))
-print (json.dumps ({
- 'variables': sysconfig.get_config_vars(),
- 'paths': sysconfig.get_paths(),
+variables = sysconfig.get_config_vars()
+variables.update({'base_prefix': getattr(sys, 'base_prefix', sys.prefix)})
+
+print(json.dumps({
+ 'variables': variables,
+ 'paths': paths,
'install_paths': install_paths,
+ 'sys_paths': sys.path,
'version': sysconfig.get_python_version(),
'platform': sysconfig.get_platform(),
'is_pypy': '__pypy__' in sys.builtin_module_names,
@@ -282,18 +334,116 @@
}))
'''
+if T.TYPE_CHECKING:
+ class PythonIntrospectionDict(TypedDict):
+
+ install_paths: T.Dict[str, str]
+ is_pypy: bool
+ link_libpython: bool
+ paths: T.Dict[str, str]
+ platform: str
+ suffix: str
+ variables: T.Dict[str, str]
+ version: str
+
+
+class PythonExternalProgram(ExternalProgram):
+ def __init__(self, name: str, command: T.Optional[T.List[str]] = None,
+ ext_prog: T.Optional[ExternalProgram] = None):
+ if ext_prog is None:
+ super().__init__(name, command=command, silent=True)
+ else:
+ self.name = name
+ self.command = ext_prog.command
+ self.path = ext_prog.path
+
+ # We want strong key values, so we always populate this with bogus data.
+ # Otherwise to make the type checkers happy we'd have to do .get() for
+ # everycall, even though we know that the introspection data will be
+ # complete
+ self.info: 'PythonIntrospectionDict' = {
+ 'install_paths': {},
+ 'is_pypy': False,
+ 'link_libpython': False,
+ 'paths': {},
+ 'platform': 'sentinal',
+ 'variables': {},
+ 'version': '0.0',
+ }
+
+ def _check_version(self, version: str) -> bool:
+ if self.name == 'python2':
+ return mesonlib.version_compare(version, '< 3.0')
+ elif self.name == 'python3':
+ return mesonlib.version_compare(version, '>= 3.0')
+ return True
+
+ def sanity(self, state: T.Optional['ModuleState'] = None) -> bool:
+ # Sanity check, we expect to have something that at least quacks in tune
+ cmd = self.get_command() + ['-c', INTROSPECT_COMMAND]
+ p, stdout, stderr = mesonlib.Popen_safe(cmd)
+ try:
+ info = json.loads(stdout)
+ except json.JSONDecodeError:
+ info = None
+ mlog.debug('Could not introspect Python (%s): exit code %d' % (str(p.args), p.returncode))
+ mlog.debug('Program stdout:\n')
+ mlog.debug(stdout)
+ mlog.debug('Program stderr:\n')
+ mlog.debug(stderr)
+
+ if info is not None and self._check_version(info['version']):
+ variables = info['variables']
+ info['suffix'] = variables.get('EXT_SUFFIX') or variables.get('SO') or variables.get('.so')
+ self.info = T.cast('PythonIntrospectionDict', info)
+ self.platlib = self._get_path(state, 'platlib')
+ self.purelib = self._get_path(state, 'purelib')
+ return True
+ else:
+ return False
+
+ def _get_path(self, state: T.Optional['ModuleState'], key: str) -> None:
+ rel_path = self.info['install_paths'][key][1:]
+ if not state:
+ # This happens only from run_project_tests.py
+ return rel_path
+ value = state.get_option(f'{key}dir', module='python')
+ if value:
+ return value
+ # Use python's path relative to prefix, and warn if that's not a location
+ # python will lookup for modules.
+ abs_path = Path(state.get_option('prefix'), rel_path)
+ sys_paths = [Path(i) for i in self.info['sys_paths']]
+ if abs_path not in sys_paths:
+ mlog.warning('Python files installed by Meson might not be found by python interpreter.\n',
+ f'This warning can be avoided by setting "python.{key}dir" option.',
+ once=True)
+ return rel_path
+
+
+_PURE_KW = KwargInfo('pure', bool, default=True)
+_SUBDIR_KW = KwargInfo('subdir', str, default='')
+
+if T.TYPE_CHECKING:
+
+ class PyInstallKw(TypedDict):
+
+ pure: bool
+ subdir: str
+ install_tag: T.Optional[str]
+
class PythonInstallation(ExternalProgramHolder):
- def __init__(self, interpreter, python, info):
- ExternalProgramHolder.__init__(self, python)
- self.interpreter = interpreter
- self.subproject = self.interpreter.subproject
- prefix = self.interpreter.environment.coredata.get_builtin_option('prefix')
+ def __init__(self, python: 'PythonExternalProgram', interpreter: 'Interpreter'):
+ ExternalProgramHolder.__init__(self, python, interpreter)
+ info = python.info
+ prefix = self.interpreter.environment.coredata.get_option(mesonlib.OptionKey('prefix'))
+ assert isinstance(prefix, str), 'for mypy'
self.variables = info['variables']
+ self.suffix = info['suffix']
self.paths = info['paths']
- install_paths = info['install_paths']
- self.platlib_install_path = os.path.join(prefix, install_paths['platlib'][1:])
- self.purelib_install_path = os.path.join(prefix, install_paths['purelib'][1:])
+ self.platlib_install_path = os.path.join(prefix, python.platlib)
+ self.purelib_install_path = os.path.join(prefix, python.purelib)
self.version = info['version']
self.platform = info['platform']
self.is_pypy = info['is_pypy']
@@ -313,11 +463,11 @@
})
@permittedKwargs(mod_kwargs)
- def extension_module_method(self, args, kwargs):
- if 'subdir' in kwargs and 'install_dir' in kwargs:
- raise InvalidArguments('"subdir" and "install_dir" are mutually exclusive')
-
- if 'subdir' in kwargs:
+ def extension_module_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> 'SharedModule':
+ if 'install_dir' in kwargs:
+ if 'subdir' in kwargs:
+ raise InvalidArguments('"subdir" and "install_dir" are mutually exclusive')
+ else:
subdir = kwargs.pop('subdir', '')
if not isinstance(subdir, str):
raise InvalidArguments('"subdir" argument must be a string.')
@@ -329,148 +479,137 @@
# behavior. See https://github.com/mesonbuild/meson/issues/4117
if not self.link_libpython:
new_deps = []
- for holder in mesonlib.extract_as_list(kwargs, 'dependencies'):
- dep = holder.held_object
- if isinstance(dep, PythonDependency):
- holder = self.interpreter.holderify(dep.get_partial_dependency(compile_args=True))
- new_deps.append(holder)
+ for dep in mesonlib.extract_as_list(kwargs, 'dependencies'):
+ if isinstance(dep, _PythonDependencyBase):
+ dep = dep.get_partial_dependency(compile_args=True)
+ new_deps.append(dep)
kwargs['dependencies'] = new_deps
- suffix = self.variables.get('EXT_SUFFIX') or self.variables.get('SO') or self.variables.get('.so')
-
# msys2's python3 has "-cpython-36m.dll", we have to be clever
- split = suffix.rsplit('.', 1)
- suffix = split.pop(-1)
- args[0] += ''.join(s for s in split)
+ # FIXME: explain what the specific cleverness is here
+ split, suffix = self.suffix.rsplit('.', 1)
+ args[0] += split
kwargs['name_prefix'] = ''
kwargs['name_suffix'] = suffix
return self.interpreter.func_shared_module(None, args, kwargs)
- @permittedKwargs(permitted_kwargs['dependency'])
+ @disablerIfNotFound
+ @permittedKwargs(permitted_dependency_kwargs | {'embed'})
@FeatureNewKwargs('python_installation.dependency', '0.53.0', ['embed'])
- def dependency_method(self, args, kwargs):
- if args:
- mlog.warning('python_installation.dependency() does not take any '
- 'positional arguments. It always returns a Python '
- 'dependency. This will become an error in the future.',
- location=self.interpreter.current_node)
- dep = PythonDependency(self, self.interpreter.environment, kwargs)
- return self.interpreter.holderify(dep)
-
- @permittedKwargs(['pure', 'subdir'])
- def install_sources_method(self, args, kwargs):
- pure = kwargs.pop('pure', False)
- if not isinstance(pure, bool):
- raise InvalidArguments('"pure" argument must be a boolean.')
-
- subdir = kwargs.pop('subdir', '')
- if not isinstance(subdir, str):
- raise InvalidArguments('"subdir" argument must be a string.')
-
- if pure:
- kwargs['install_dir'] = os.path.join(self.purelib_install_path, subdir)
+ @noPosargs
+ def dependency_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> 'Dependency':
+ disabled, required, feature = extract_required_kwarg(kwargs, self.subproject)
+ # it's theoretically (though not practically) possible for the else clse
+ # to not bind dep, let's ensure it is.
+ dep: 'Dependency' = NotFoundDependency('python', self.interpreter.environment)
+ if disabled:
+ mlog.log('Dependency', mlog.bold('python'), 'skipped: feature', mlog.bold(feature), 'disabled')
else:
- kwargs['install_dir'] = os.path.join(self.platlib_install_path, subdir)
-
- return self.interpreter.holderify(self.interpreter.func_install_data(None, args, kwargs))
+ new_kwargs = kwargs.copy()
+ new_kwargs['required'] = False
+ methods = process_method_kw({DependencyMethods.PKGCONFIG, DependencyMethods.SYSTEM}, kwargs)
+ for d in python_factory(self.interpreter.environment,
+ MachineChoice.BUILD if kwargs.get('native', False) else MachineChoice.HOST,
+ new_kwargs, methods, self):
+ dep = d()
+ if dep.found():
+ break
+ if required and not dep.found():
+ raise mesonlib.MesonException('Python dependency not found')
+
+ return dep
+
+ @typed_pos_args('install_data', varargs=(str, mesonlib.File))
+ @typed_kwargs('python_installation.install_sources', _PURE_KW, _SUBDIR_KW,
+ KwargInfo('install_tag', (str, NoneType), since='0.60.0'))
+ def install_sources_method(self, args: T.Tuple[T.List[T.Union[str, mesonlib.File]]],
+ kwargs: 'PyInstallKw') -> 'Data':
+ tag = kwargs['install_tag'] or 'runtime'
+ return self.interpreter.install_data_impl(
+ self.interpreter.source_strings_to_files(args[0]),
+ self._get_install_dir_impl(kwargs['pure'], kwargs['subdir']),
+ mesonlib.FileMode(), rename=None, tag=tag, install_data_type='python',
+ install_dir_name=self._get_install_dir_name_impl(kwargs['pure'], kwargs['subdir']))
@noPosargs
- @permittedKwargs(['pure', 'subdir'])
- def get_install_dir_method(self, args, kwargs):
- pure = kwargs.pop('pure', True)
- if not isinstance(pure, bool):
- raise InvalidArguments('"pure" argument must be a boolean.')
-
- subdir = kwargs.pop('subdir', '')
- if not isinstance(subdir, str):
- raise InvalidArguments('"subdir" argument must be a string.')
+ @typed_kwargs('python_installation.install_dir', _PURE_KW, _SUBDIR_KW)
+ def get_install_dir_method(self, args: T.List['TYPE_var'], kwargs: 'PyInstallKw') -> str:
+ return self._get_install_dir_impl(kwargs['pure'], kwargs['subdir'])
+
+ def _get_install_dir_impl(self, pure: bool, subdir: str) -> str:
+ return os.path.join(
+ self.purelib_install_path if pure else self.platlib_install_path, subdir)
- if pure:
- res = os.path.join(self.purelib_install_path, subdir)
- else:
- res = os.path.join(self.platlib_install_path, subdir)
-
- return self.interpreter.module_method_callback(ModuleReturnValue(res, []))
+ def _get_install_dir_name_impl(self, pure: bool, subdir: str) -> str:
+ return os.path.join('{py_purelib}' if pure else '{py_platlib}', subdir)
@noPosargs
@noKwargs
- def language_version_method(self, args, kwargs):
- return self.interpreter.module_method_callback(ModuleReturnValue(self.version, []))
+ def language_version_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
+ return self.version
+ @typed_pos_args('python_installation.has_path', str)
@noKwargs
- def has_path_method(self, args, kwargs):
- if len(args) != 1:
- raise InvalidArguments('has_path takes exactly one positional argument.')
- path_name = args[0]
- if not isinstance(path_name, str):
- raise InvalidArguments('has_path argument must be a string.')
-
- return self.interpreter.module_method_callback(ModuleReturnValue(path_name in self.paths, []))
+ def has_path_method(self, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool:
+ return args[0] in self.paths
+ @typed_pos_args('python_installation.get_path', str, optargs=[object])
@noKwargs
- def get_path_method(self, args, kwargs):
- if len(args) not in (1, 2):
- raise InvalidArguments('get_path must have one or two arguments.')
- path_name = args[0]
- if not isinstance(path_name, str):
- raise InvalidArguments('get_path argument must be a string.')
-
+ def get_path_method(self, args: T.Tuple[str, T.Optional['TYPE_var']], kwargs: 'TYPE_kwargs') -> 'TYPE_var':
+ path_name, fallback = args
try:
- path = self.paths[path_name]
+ return self.paths[path_name]
except KeyError:
- if len(args) == 2:
- path = args[1]
- else:
- raise InvalidArguments('{} is not a valid path name'.format(path_name))
-
- return self.interpreter.module_method_callback(ModuleReturnValue(path, []))
+ if fallback is not None:
+ return fallback
+ raise InvalidArguments(f'{path_name} is not a valid path name')
+ @typed_pos_args('python_installation.has_variable', str)
@noKwargs
- def has_variable_method(self, args, kwargs):
- if len(args) != 1:
- raise InvalidArguments('has_variable takes exactly one positional argument.')
- var_name = args[0]
- if not isinstance(var_name, str):
- raise InvalidArguments('has_variable argument must be a string.')
-
- return self.interpreter.module_method_callback(ModuleReturnValue(var_name in self.variables, []))
+ def has_variable_method(self, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool:
+ return args[0] in self.variables
+ @typed_pos_args('python_installation.get_variable', str, optargs=[object])
@noKwargs
- def get_variable_method(self, args, kwargs):
- if len(args) not in (1, 2):
- raise InvalidArguments('get_variable must have one or two arguments.')
- var_name = args[0]
- if not isinstance(var_name, str):
- raise InvalidArguments('get_variable argument must be a string.')
-
+ def get_variable_method(self, args: T.Tuple[str, T.Optional['TYPE_var']], kwargs: 'TYPE_kwargs') -> 'TYPE_var':
+ var_name, fallback = args
try:
- var = self.variables[var_name]
+ return self.variables[var_name]
except KeyError:
- if len(args) == 2:
- var = args[1]
- else:
- raise InvalidArguments('{} is not a valid variable name'.format(var_name))
-
- return self.interpreter.module_method_callback(ModuleReturnValue(var, []))
+ if fallback is not None:
+ return fallback
+ raise InvalidArguments(f'{var_name} is not a valid variable name')
@noPosargs
@noKwargs
@FeatureNew('Python module path method', '0.50.0')
- def path_method(self, args, kwargs):
+ def path_method(self, args: T.List['TYPE_var'], kwargs: 'TYPE_kwargs') -> str:
return super().path_method(args, kwargs)
+if T.TYPE_CHECKING:
+ from ..interpreter.kwargs import ExtractRequired
+
+ class FindInstallationKw(ExtractRequired):
+
+ disabler: bool
+ modules: T.List[str]
+
+
class PythonModule(ExtensionModule):
@FeatureNew('Python Module', '0.46.0')
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self.snippets.add('find_installation')
+ def __init__(self, interpreter: 'Interpreter') -> None:
+ super().__init__(interpreter)
+ self.methods.update({
+ 'find_installation': self.find_installation,
+ })
# https://www.python.org/dev/peps/pep-0397/
- def _get_win_pythonpath(self, name_or_path):
+ @staticmethod
+ def _get_win_pythonpath(name_or_path: str) -> T.Optional[str]:
if name_or_path not in ['python2', 'python3']:
return None
if not shutil.which('py'):
@@ -485,66 +624,69 @@
else:
return None
- def _check_version(self, name_or_path, version):
- if name_or_path == 'python2':
- return mesonlib.version_compare(version, '< 3.0')
- elif name_or_path == 'python3':
- return mesonlib.version_compare(version, '>= 3.0')
- return True
-
- @FeatureNewKwargs('python.find_installation', '0.49.0', ['disabler'])
- @FeatureNewKwargs('python.find_installation', '0.51.0', ['modules'])
@disablerIfNotFound
- @permittedKwargs({'required', 'modules'})
- def find_installation(self, interpreter, state, args, kwargs):
+ @typed_pos_args('python.find_installation', optargs=[str])
+ @typed_kwargs(
+ 'python.find_installation',
+ KwargInfo('required', (bool, UserFeatureOption), default=True),
+ KwargInfo('disabler', bool, default=False, since='0.49.0'),
+ KwargInfo('modules', ContainerTypeInfo(list, str), listify=True, default=[], since='0.51.0'),
+ )
+ def find_installation(self, state: 'ModuleState', args: T.Tuple[T.Optional[str]],
+ kwargs: 'FindInstallationKw') -> ExternalProgram:
feature_check = FeatureNew('Passing "feature" option to find_installation', '0.48.0')
disabled, required, feature = extract_required_kwarg(kwargs, state.subproject, feature_check)
- want_modules = mesonlib.extract_as_list(kwargs, 'modules') # type: T.List[str]
- found_modules = [] # type: T.List[str]
- missing_modules = [] # type: T.List[str]
-
- if len(args) > 1:
- raise InvalidArguments('find_installation takes zero or one positional argument.')
-
- name_or_path = state.environment.binaries.host.lookup_entry('python')
- if name_or_path is None and args:
- name_or_path = args[0]
- if not isinstance(name_or_path, str):
- raise InvalidArguments('find_installation argument must be a string.')
+ want_modules = kwargs['modules']
+ found_modules: T.List[str] = []
+ missing_modules: T.List[str] = []
+
+ # FIXME: this code is *full* of sharp corners. It assumes that it's
+ # going to get a string value (or now a list of length 1), of `python2`
+ # or `python3` which is completely nonsense. On windows the value could
+ # easily be `['py', '-3']`, or `['py', '-3.7']` to get a very specific
+ # version of python. On Linux we might want a python that's not in
+ # $PATH, or that uses a wrapper of some kind.
+ np: T.List[str] = state.environment.lookup_binary_entry(MachineChoice.HOST, 'python') or []
+ fallback = args[0]
+ display_name = fallback or 'python'
+ if not np and fallback is not None:
+ np = [fallback]
+ name_or_path = np[0] if np else None
if disabled:
mlog.log('Program', name_or_path or 'python', 'found:', mlog.red('NO'), '(disabled by:', mlog.bold(feature), ')')
- return ExternalProgramHolder(NonExistingExternalProgram())
+ return NonExistingExternalProgram()
if not name_or_path:
- python = ExternalProgram('python3', mesonlib.python_command, silent=True)
+ python = PythonExternalProgram('python3', mesonlib.python_command)
else:
- python = ExternalProgram.from_entry('python3', name_or_path)
+ tmp_python = ExternalProgram.from_entry(display_name, name_or_path)
+ python = PythonExternalProgram(display_name, ext_prog=tmp_python)
if not python.found() and mesonlib.is_windows():
pythonpath = self._get_win_pythonpath(name_or_path)
if pythonpath is not None:
name_or_path = pythonpath
- python = ExternalProgram(name_or_path, silent=True)
+ python = PythonExternalProgram(name_or_path)
# Last ditch effort, python2 or python3 can be named python
# on various platforms, let's not give up just yet, if an executable
# named python is available and has a compatible version, let's use
# it
if not python.found() and name_or_path in ['python2', 'python3']:
- python = ExternalProgram('python', silent=True)
+ python = PythonExternalProgram('python')
if python.found() and want_modules:
for mod in want_modules:
- p, out, err = mesonlib.Popen_safe(
+ p, *_ = mesonlib.Popen_safe(
python.command +
- ['-c', 'import {0}'.format(mod)])
+ ['-c', f'import {mod}'])
if p.returncode != 0:
missing_modules.append(mod)
else:
found_modules.append(mod)
- msg = ['Program', python.name]
+ msg: T.List['mlog.TV_Loggable'] = ['Program', python.name]
if want_modules:
msg.append('({})'.format(', '.join(want_modules)))
msg.append('found:')
@@ -561,34 +703,25 @@
if not python.found():
if required:
raise mesonlib.MesonException('{} not found'.format(name_or_path or 'python'))
- res = ExternalProgramHolder(NonExistingExternalProgram())
+ return NonExistingExternalProgram()
elif missing_modules:
if required:
raise mesonlib.MesonException('{} is missing modules: {}'.format(name_or_path or 'python', ', '.join(missing_modules)))
- res = ExternalProgramHolder(NonExistingExternalProgram())
+ return NonExistingExternalProgram()
else:
- # Sanity check, we expect to have something that at least quacks in tune
- try:
- cmd = python.get_command() + ['-c', INTROSPECT_COMMAND]
- p, stdout, stderr = mesonlib.Popen_safe(cmd)
- info = json.loads(stdout)
- except json.JSONDecodeError:
- info = None
- mlog.debug('Could not introspect Python (%s): exit code %d' % (str(p.args), p.returncode))
- mlog.debug('Program stdout:\n')
- mlog.debug(stdout)
- mlog.debug('Program stderr:\n')
- mlog.debug(stderr)
+ sane = python.sanity(state)
- if isinstance(info, dict) and 'version' in info and self._check_version(name_or_path, info['version']):
- res = PythonInstallation(interpreter, python, info)
+ if sane:
+ return python
else:
- res = ExternalProgramHolder(NonExistingExternalProgram())
if required:
- raise mesonlib.MesonException('{} is not a valid python or it is missing setuptools'.format(python))
+ raise mesonlib.MesonException(f'{python} is not a valid python or it is missing distutils')
+ return NonExistingExternalProgram()
- return res
+ raise mesonlib.MesonBugException('Unreachable code was reached (PythonModule.find_installation).')
-def initialize(*args, **kwargs):
- return PythonModule(*args, **kwargs)
+def initialize(interpreter: 'Interpreter') -> PythonModule:
+ mod = PythonModule(interpreter)
+ mod.interpreter.append_holder_map(PythonExternalProgram, PythonInstallation)
+ return mod
diff -Nru meson-0.53.2/mesonbuild/modules/qt4.py meson-0.61.2/mesonbuild/modules/qt4.py
--- meson-0.53.2/mesonbuild/modules/qt4.py 2018-12-09 14:27:23.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/qt4.py 2021-04-01 21:12:21.000000000 +0000
@@ -12,7 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from .. import mlog
from .qt import QtBaseModule
@@ -23,6 +22,4 @@
def initialize(*args, **kwargs):
- mlog.warning('rcc dependencies will not work properly until this upstream issue is fixed:',
- mlog.bold('https://bugreports.qt.io/browse/QTBUG-45460'))
return Qt4Module(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/qt5.py meson-0.61.2/mesonbuild/modules/qt5.py
--- meson-0.53.2/mesonbuild/modules/qt5.py 2018-12-09 14:27:23.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/qt5.py 2021-04-01 21:12:21.000000000 +0000
@@ -12,7 +12,6 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from .. import mlog
from .qt import QtBaseModule
@@ -23,6 +22,4 @@
def initialize(*args, **kwargs):
- mlog.warning('rcc dependencies will not work reliably until this upstream issue is fixed:',
- mlog.bold('https://bugreports.qt.io/browse/QTBUG-45460'))
return Qt5Module(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/qt6.py meson-0.61.2/mesonbuild/modules/qt6.py
--- meson-0.53.2/mesonbuild/modules/qt6.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/qt6.py 2022-01-02 20:12:32.000000000 +0000
@@ -0,0 +1,27 @@
+# Copyright 2020 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 .qt import QtBaseModule
+from ..interpreterbase import FeatureNew
+
+
+class Qt6Module(QtBaseModule):
+
+ @FeatureNew('Qt6 Module', '0.57.0')
+ def __init__(self, interpreter):
+ QtBaseModule.__init__(self, interpreter, qt_version=6)
+
+
+def initialize(*args, **kwargs):
+ return Qt6Module(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/qt.py meson-0.61.2/mesonbuild/modules/qt.py
--- meson-0.53.2/mesonbuild/modules/qt.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/qt.py 2021-12-26 16:24:25.000000000 +0000
@@ -1,4 +1,5 @@
# Copyright 2015 The Meson development team
+# Copyright © 2021 Intel Corporation
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
@@ -13,210 +14,574 @@
# limitations under the License.
import os
-from .. import mlog
-from .. import build
-from ..mesonlib import MesonException, Popen_safe, extract_as_list, File
-from ..dependencies import Dependency, Qt4Dependency, Qt5Dependency
+import shutil
+import typing as T
import xml.etree.ElementTree as ET
-from . import ModuleReturnValue, get_include_args, ExtensionModule
-from ..interpreterbase import permittedKwargs, FeatureNew, FeatureNewKwargs
-
-_QT_DEPS_LUT = {
- 4: Qt4Dependency,
- 5: Qt5Dependency
-}
+from . import ModuleReturnValue, ExtensionModule
+from .. import build
+from .. import coredata
+from .. import mlog
+from ..dependencies import find_external_dependency, Dependency, ExternalLibrary
+from ..mesonlib import MesonException, File, FileOrString, version_compare, Popen_safe
+from ..interpreter import extract_required_kwarg
+from ..interpreter.type_checking import NoneType
+from ..interpreterbase import ContainerTypeInfo, FeatureDeprecated, KwargInfo, noPosargs, FeatureNew, typed_kwargs
+from ..programs import ExternalProgram, NonExistingExternalProgram
+
+if T.TYPE_CHECKING:
+ from . import ModuleState
+ from ..dependencies.qt import QtPkgConfigDependency, QmakeQtDependency
+ from ..interpreter import Interpreter
+ from ..interpreter import kwargs
+
+ QtDependencyType = T.Union[QtPkgConfigDependency, QmakeQtDependency]
+
+ from typing_extensions import TypedDict
+
+ class ResourceCompilerKwArgs(TypedDict):
+
+ """Keyword arguments for the Resource Compiler method."""
+
+ name: T.Optional[str]
+ sources: T.Sequence[T.Union[FileOrString, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]]
+ extra_args: T.List[str]
+ method: str
+
+ class UICompilerKwArgs(TypedDict):
+
+ """Keyword arguments for the Ui Compiler method."""
+
+ sources: T.Sequence[T.Union[FileOrString, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]]
+ extra_args: T.List[str]
+ method: str
+
+ class MocCompilerKwArgs(TypedDict):
+
+ """Keyword arguments for the Moc Compiler method."""
+
+ sources: T.Sequence[T.Union[FileOrString, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]]
+ headers: T.Sequence[T.Union[FileOrString, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]]
+ extra_args: T.List[str]
+ method: str
+ include_directories: T.List[T.Union[str, build.IncludeDirs]]
+ dependencies: T.List[T.Union[Dependency, ExternalLibrary]]
+
+ class PreprocessKwArgs(TypedDict):
+
+ sources: T.List[FileOrString]
+ moc_sources: T.List[T.Union[FileOrString, build.CustomTarget]]
+ moc_headers: T.List[T.Union[FileOrString, build.CustomTarget]]
+ qresources: T.List[FileOrString]
+ ui_files: T.List[T.Union[FileOrString, build.CustomTarget]]
+ moc_extra_arguments: T.List[str]
+ rcc_extra_arguments: T.List[str]
+ uic_extra_arguments: T.List[str]
+ include_directories: T.List[T.Union[str, build.IncludeDirs]]
+ dependencies: T.List[T.Union[Dependency, ExternalLibrary]]
+ method: str
+
+ class HasToolKwArgs(kwargs.ExtractRequired):
+
+ method: str
+
+ class CompileTranslationsKwArgs(TypedDict):
+
+ build_by_default: bool
+ install: bool
+ install_dir: T.Optional[str]
+ method: str
+ qresource: T.Optional[str]
+ rcc_extra_arguments: T.List[str]
+ ts_files: T.List[T.Union[str, File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]]
class QtBaseModule(ExtensionModule):
- tools_detected = False
+ _tools_detected = False
+ _rcc_supports_depfiles = False
+ _moc_supports_depfiles = False
- def __init__(self, interpreter, qt_version=5):
+ def __init__(self, interpreter: 'Interpreter', qt_version: int = 5):
ExtensionModule.__init__(self, interpreter)
self.qt_version = qt_version
+ self.tools: T.Dict[str, ExternalProgram] = {
+ 'moc': NonExistingExternalProgram('moc'),
+ 'uic': NonExistingExternalProgram('uic'),
+ 'rcc': NonExistingExternalProgram('rcc'),
+ 'lrelease': NonExistingExternalProgram('lrelease'),
+ }
+ self.methods.update({
+ 'has_tools': self.has_tools,
+ 'preprocess': self.preprocess,
+ 'compile_translations': self.compile_translations,
+ 'compile_resources': self.compile_resources,
+ 'compile_ui': self.compile_ui,
+ 'compile_moc': self.compile_moc,
+ })
+
+ def compilers_detect(self, state: 'ModuleState', qt_dep: 'QtDependencyType') -> None:
+ """Detect Qt (4 or 5) moc, uic, rcc in the specified bindir or in PATH"""
+ # It is important that this list does not change order as the order of
+ # the returned ExternalPrograms will change as well
+ wanted = f'== {qt_dep.version}'
+
+ def gen_bins() -> T.Generator[T.Tuple[str, str], None, None]:
+ for b in self.tools:
+ if qt_dep.bindir:
+ yield os.path.join(qt_dep.bindir, b), b
+ # prefer the -qt of the tool to the plain one, as we
+ # don't know what the unsuffixed one points to without calling it.
+ yield f'{b}-qt{qt_dep.qtver}', b
+ yield b, b
+
+ for b, name in gen_bins():
+ if self.tools[name].found():
+ continue
+
+ if name == 'lrelease':
+ arg = ['-version']
+ elif version_compare(qt_dep.version, '>= 5'):
+ arg = ['--version']
+ else:
+ arg = ['-v']
- def _detect_tools(self, env, method):
- if self.tools_detected:
- return
- mlog.log('Detecting Qt{version} tools'.format(version=self.qt_version))
- # FIXME: We currently require QtX to exist while importing the module.
- # We should make it gracefully degrade and not create any targets if
- # the import is marked as 'optional' (not implemented yet)
- kwargs = {'required': 'true', 'modules': 'Core', 'silent': 'true', 'method': method}
- qt = _QT_DEPS_LUT[self.qt_version](env, kwargs)
- # Get all tools and then make sure that they are the right version
- self.moc, self.uic, self.rcc, self.lrelease = qt.compilers_detect(self.interpreter)
- # Moc, uic and rcc write their version strings to stderr.
- # Moc and rcc return a non-zero result when doing so.
- # What kind of an idiot thought that was a good idea?
- for compiler, compiler_name in ((self.moc, "Moc"), (self.uic, "Uic"), (self.rcc, "Rcc"), (self.lrelease, "lrelease")):
- if compiler.found():
- # Workaround since there is no easy way to know which tool/version support which flag
- for flag in ['-v', '-version']:
- p, stdout, stderr = Popen_safe(compiler.get_command() + [flag])[0:3]
- if p.returncode == 0:
- break
- stdout = stdout.strip()
- stderr = stderr.strip()
- if 'Qt {}'.format(self.qt_version) in stderr:
- compiler_ver = stderr
- elif 'version {}.'.format(self.qt_version) in stderr:
- compiler_ver = stderr
- elif ' {}.'.format(self.qt_version) in stdout:
- compiler_ver = stdout
+ # Ensure that the version of qt and each tool are the same
+ def get_version(p: ExternalProgram) -> str:
+ _, out, err = Popen_safe(p.get_command() + arg)
+ if b.startswith('lrelease') or not qt_dep.version.startswith('4'):
+ care = out
else:
- raise MesonException('{name} preprocessor is not for Qt {version}. Output:\n{stdo}\n{stderr}'.format(
- name=compiler_name, version=self.qt_version, stdo=stdout, stderr=stderr))
- mlog.log(' {}:'.format(compiler_name.lower()), mlog.green('YES'), '({path}, {version})'.format(
- path=compiler.get_path(), version=compiler_ver.split()[-1]))
- else:
- mlog.log(' {}:'.format(compiler_name.lower()), mlog.red('NO'))
- self.tools_detected = True
+ care = err
+ return care.split(' ')[-1].replace(')', '').strip()
- def parse_qrc(self, state, rcc_file):
- if type(rcc_file) is str:
+ p = state.find_program(b, required=False,
+ version_func=get_version,
+ wanted=wanted)
+ if p.found():
+ self.tools[name] = p
+
+ def _detect_tools(self, state: 'ModuleState', method: str, required: bool = True) -> None:
+ if self._tools_detected:
+ return
+ self._tools_detected = True
+ mlog.log(f'Detecting Qt{self.qt_version} tools')
+ kwargs = {'required': required, 'modules': 'Core', 'method': method}
+ # Just pick one to make mypy happy
+ qt = T.cast('QtPkgConfigDependency', find_external_dependency(f'qt{self.qt_version}', state.environment, kwargs))
+ if qt.found():
+ # Get all tools and then make sure that they are the right version
+ self.compilers_detect(state, qt)
+ if version_compare(qt.version, '>=5.15.0'):
+ self._moc_supports_depfiles = True
+ else:
+ mlog.warning('moc dependencies will not work properly until you move to Qt >= 5.15', fatal=False)
+ if version_compare(qt.version, '>=5.14.0'):
+ self._rcc_supports_depfiles = True
+ else:
+ mlog.warning('rcc dependencies will not work properly until you move to Qt >= 5.14:',
+ mlog.bold('https://bugreports.qt.io/browse/QTBUG-45460'), fatal=False)
+ else:
+ suffix = f'-qt{self.qt_version}'
+ self.tools['moc'] = NonExistingExternalProgram(name='moc' + suffix)
+ self.tools['uic'] = NonExistingExternalProgram(name='uic' + suffix)
+ self.tools['rcc'] = NonExistingExternalProgram(name='rcc' + suffix)
+ self.tools['lrelease'] = NonExistingExternalProgram(name='lrelease' + suffix)
+
+ @staticmethod
+ def _qrc_nodes(state: 'ModuleState', rcc_file: 'FileOrString') -> T.Tuple[str, T.List[str]]:
+ abspath: str
+ if isinstance(rcc_file, str):
abspath = os.path.join(state.environment.source_dir, state.subdir, rcc_file)
rcc_dirname = os.path.dirname(abspath)
- elif type(rcc_file) is File:
+ else:
abspath = rcc_file.absolute_path(state.environment.source_dir, state.environment.build_dir)
rcc_dirname = os.path.dirname(abspath)
+ # FIXME: what error are we actually trying to check here?
try:
tree = ET.parse(abspath)
root = tree.getroot()
- result = []
+ result: T.List[str] = []
for child in root[0]:
if child.tag != 'file':
- mlog.warning("malformed rcc file: ", os.path.join(state.subdir, rcc_file))
+ mlog.warning("malformed rcc file: ", os.path.join(state.subdir, str(rcc_file)))
break
else:
- resource_path = child.text
- # We need to guess if the pointed resource is:
- # a) in build directory -> implies a generated file
- # b) in source directory
- # c) somewhere else external dependency file to bundle
- #
- # Also from qrc documentation: relative path are always from qrc file
- # So relative path must always be computed from qrc file !
- if os.path.isabs(resource_path):
- # a)
- if resource_path.startswith(os.path.abspath(state.environment.build_dir)):
- resource_relpath = os.path.relpath(resource_path, state.environment.build_dir)
- result.append(File(is_built=True, subdir='', fname=resource_relpath))
- # either b) or c)
- else:
- result.append(File(is_built=False, subdir=state.subdir, fname=resource_path))
- else:
- path_from_rcc = os.path.normpath(os.path.join(rcc_dirname, resource_path))
- # a)
- if path_from_rcc.startswith(state.environment.build_dir):
- result.append(File(is_built=True, subdir=state.subdir, fname=resource_path))
- # b)
- else:
- result.append(File(is_built=False, subdir=state.subdir, fname=path_from_rcc))
- return result
+ result.append(child.text)
+
+ return rcc_dirname, result
except Exception:
- return []
+ raise MesonException(f'Unable to parse resource file {abspath}')
- @FeatureNewKwargs('qt.preprocess', '0.49.0', ['uic_extra_arguments'])
- @FeatureNewKwargs('qt.preprocess', '0.44.0', ['moc_extra_arguments'])
- @FeatureNewKwargs('qt.preprocess', '0.49.0', ['rcc_extra_arguments'])
- @permittedKwargs({'moc_headers', 'moc_sources', 'uic_extra_arguments', 'moc_extra_arguments', 'rcc_extra_arguments', 'include_directories', 'dependencies', 'ui_files', 'qresources', 'method'})
- def preprocess(self, state, args, kwargs):
- rcc_files, ui_files, moc_headers, moc_sources, uic_extra_arguments, moc_extra_arguments, rcc_extra_arguments, sources, include_directories, dependencies \
- = extract_as_list(kwargs, 'qresources', 'ui_files', 'moc_headers', 'moc_sources', 'uic_extra_arguments', 'moc_extra_arguments', 'rcc_extra_arguments', 'sources', 'include_directories', 'dependencies', pop = True)
- sources += args[1:]
+ def _parse_qrc_deps(self, state: 'ModuleState',
+ rcc_file_: T.Union['FileOrString', build.CustomTarget, build.CustomTargetIndex, build.GeneratedList]) -> T.List[File]:
+ result: T.List[File] = []
+ inputs: T.Sequence['FileOrString'] = []
+ if isinstance(rcc_file_, (str, File)):
+ inputs = [rcc_file_]
+ else:
+ inputs = rcc_file_.get_outputs()
+
+ for rcc_file in inputs:
+ rcc_dirname, nodes = self._qrc_nodes(state, rcc_file)
+ for resource_path in nodes:
+ # We need to guess if the pointed resource is:
+ # a) in build directory -> implies a generated file
+ # b) in source directory
+ # c) somewhere else external dependency file to bundle
+ #
+ # Also from qrc documentation: relative path are always from qrc file
+ # So relative path must always be computed from qrc file !
+ if os.path.isabs(resource_path):
+ # a)
+ if resource_path.startswith(os.path.abspath(state.environment.build_dir)):
+ resource_relpath = os.path.relpath(resource_path, state.environment.build_dir)
+ result.append(File(is_built=True, subdir='', fname=resource_relpath))
+ # either b) or c)
+ else:
+ result.append(File(is_built=False, subdir=state.subdir, fname=resource_path))
+ else:
+ path_from_rcc = os.path.normpath(os.path.join(rcc_dirname, resource_path))
+ # a)
+ if path_from_rcc.startswith(state.environment.build_dir):
+ result.append(File(is_built=True, subdir=state.subdir, fname=resource_path))
+ # b)
+ else:
+ result.append(File(is_built=False, subdir=state.subdir, fname=path_from_rcc))
+ return result
+
+ @FeatureNew('qt.has_tools', '0.54.0')
+ @noPosargs
+ @typed_kwargs(
+ 'qt.has_tools',
+ KwargInfo('required', (bool, coredata.UserFeatureOption), default=False),
+ KwargInfo('method', str, default='auto'),
+ )
+ def has_tools(self, state: 'ModuleState', args: T.Tuple, kwargs: 'HasToolKwArgs') -> bool:
method = kwargs.get('method', 'auto')
- self._detect_tools(state.environment, method)
- err_msg = "{0} sources specified and couldn't find {1}, " \
- "please check your qt{2} installation"
- if (moc_headers or moc_sources) and not self.moc.found():
- raise MesonException(err_msg.format('MOC', 'moc-qt{}'.format(self.qt_version), self.qt_version))
- if rcc_files:
- if not self.rcc.found():
- raise MesonException(err_msg.format('RCC', 'rcc-qt{}'.format(self.qt_version), self.qt_version))
+ # We have to cast here because TypedDicts are invariant, even though
+ # ExtractRequiredKwArgs is a subset of HasToolKwArgs, type checkers
+ # will insist this is wrong
+ disabled, required, feature = extract_required_kwarg(kwargs, state.subproject, default=False)
+ if disabled:
+ mlog.log('qt.has_tools skipped: feature', mlog.bold(feature), 'disabled')
+ return False
+ self._detect_tools(state, method, required=False)
+ for tool in self.tools.values():
+ if not tool.found():
+ if required:
+ raise MesonException('Qt tools not found')
+ return False
+ return True
+
+ @FeatureNew('qt.compile_resources', '0.59.0')
+ @noPosargs
+ @typed_kwargs(
+ 'qt.compile_resources',
+ KwargInfo('name', (str, NoneType)),
+ KwargInfo(
+ 'sources',
+ ContainerTypeInfo(list, (File, str, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList), allow_empty=False),
+ listify=True,
+ required=True,
+ ),
+ KwargInfo('extra_args', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('method', str, default='auto')
+ )
+ def compile_resources(self, state: 'ModuleState', args: T.Tuple, kwargs: 'ResourceCompilerKwArgs') -> ModuleReturnValue:
+ """Compile Qt resources files.
+
+ Uses CustomTargets to generate .cpp files from .qrc files.
+ """
+ if any(isinstance(s, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for s in kwargs['sources']):
+ FeatureNew.single_use('qt.compile_resources: custom_target or generator for "sources" keyword argument',
+ '0.60.0', state.subproject, location=state.current_node)
+ out = self._compile_resources_impl(state, kwargs)
+ return ModuleReturnValue(out, [out])
+
+ def _compile_resources_impl(self, state: 'ModuleState', kwargs: 'ResourceCompilerKwArgs') -> T.List[build.CustomTarget]:
+ # Avoid the FeatureNew when dispatching from preprocess
+ self._detect_tools(state, kwargs['method'])
+ if not self.tools['rcc'].found():
+ err_msg = ("{0} sources specified and couldn't find {1}, "
+ "please check your qt{2} installation")
+ raise MesonException(err_msg.format('RCC', f'rcc-qt{self.qt_version}', self.qt_version))
+
+ # List of generated CustomTargets
+ targets: T.List[build.CustomTarget] = []
+
+ # depfile arguments
+ DEPFILE_ARGS: T.List[str] = ['--depfile', '@DEPFILE@'] if self._rcc_supports_depfiles else []
+
+ name = kwargs['name']
+ sources: T.List['FileOrString'] = []
+ for s in kwargs['sources']:
+ if isinstance(s, (str, File)):
+ sources.append(s)
+ else:
+ sources.extend(s.get_outputs())
+ extra_args = kwargs['extra_args']
+
+ # If a name was set generate a single .cpp file from all of the qrc
+ # files, otherwise generate one .cpp file per qrc file.
+ if name:
+ qrc_deps: T.List[File] = []
+ for s in sources:
+ qrc_deps.extend(self._parse_qrc_deps(state, s))
+
+ rcc_kwargs: T.Dict[str, T.Any] = { # TODO: if CustomTarget had typing information we could use that here...
+ 'input': sources,
+ 'output': name + '.cpp',
+ 'command': self.tools['rcc'].get_command() + ['-name', name, '-o', '@OUTPUT@'] + extra_args + ['@INPUT@'] + DEPFILE_ARGS,
+ 'depend_files': qrc_deps,
+ 'depfile': f'{name}.d',
+ }
+ res_target = build.CustomTarget(name, state.subdir, state.subproject, rcc_kwargs)
+ targets.append(res_target)
+ else:
+ for rcc_file in sources:
+ qrc_deps = self._parse_qrc_deps(state, rcc_file)
+ if isinstance(rcc_file, str):
+ basename = os.path.basename(rcc_file)
+ else:
+ basename = os.path.basename(rcc_file.fname)
+ name = f'qt{self.qt_version}-{basename.replace(".", "_")}'
+ rcc_kwargs = {
+ 'input': rcc_file,
+ 'output': f'{name}.cpp',
+ 'command': self.tools['rcc'].get_command() + ['-name', '@BASENAME@', '-o', '@OUTPUT@'] + extra_args + ['@INPUT@'] + DEPFILE_ARGS,
+ 'depend_files': qrc_deps,
+ 'depfile': f'{name}.d',
+ }
+ res_target = build.CustomTarget(name, state.subdir, state.subproject, rcc_kwargs)
+ targets.append(res_target)
+
+ return targets
+
+ @FeatureNew('qt.compile_ui', '0.59.0')
+ @noPosargs
+ @typed_kwargs(
+ 'qt.compile_ui',
+ KwargInfo(
+ 'sources',
+ ContainerTypeInfo(list, (File, str, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList), allow_empty=False),
+ listify=True,
+ required=True,
+ ),
+ KwargInfo('extra_args', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('method', str, default='auto')
+ )
+ def compile_ui(self, state: 'ModuleState', args: T.Tuple, kwargs: 'UICompilerKwArgs') -> ModuleReturnValue:
+ """Compile UI resources into cpp headers."""
+ if any(isinstance(s, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for s in kwargs['sources']):
+ FeatureNew.single_use('qt.compile_ui: custom_target or generator for "sources" keyword argument',
+ '0.60.0', state.subproject, location=state.current_node)
+ out = self._compile_ui_impl(state, kwargs)
+ return ModuleReturnValue(out, [out])
+
+ def _compile_ui_impl(self, state: 'ModuleState', kwargs: 'UICompilerKwArgs') -> build.GeneratedList:
+ # Avoid the FeatureNew when dispatching from preprocess
+ self._detect_tools(state, kwargs['method'])
+ if not self.tools['uic'].found():
+ err_msg = ("{0} sources specified and couldn't find {1}, "
+ "please check your qt{2} installation")
+ raise MesonException(err_msg.format('UIC', f'uic-qt{self.qt_version}', self.qt_version))
+
+ # TODO: This generator isn't added to the generator list in the Interpreter
+ gen = build.Generator(
+ self.tools['uic'],
+ kwargs['extra_args'] + ['-o', '@OUTPUT@', '@INPUT@'],
+ ['ui_@BASENAME@.h'],
+ name=f'Qt{self.qt_version} ui')
+ return gen.process_files(kwargs['sources'], state)
+
+ @FeatureNew('qt.compile_moc', '0.59.0')
+ @noPosargs
+ @typed_kwargs(
+ 'qt.compile_moc',
+ KwargInfo(
+ 'sources',
+ ContainerTypeInfo(list, (File, str, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)),
+ listify=True,
+ default=[],
+ ),
+ KwargInfo(
+ 'headers',
+ ContainerTypeInfo(list, (File, str, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)),
+ listify=True,
+ default=[]
+ ),
+ KwargInfo('extra_args', ContainerTypeInfo(list, str), listify=True, default=[]),
+ KwargInfo('method', str, default='auto'),
+ KwargInfo('include_directories', ContainerTypeInfo(list, (build.IncludeDirs, str)), listify=True, default=[]),
+ KwargInfo('dependencies', ContainerTypeInfo(list, (Dependency, ExternalLibrary)), listify=True, default=[]),
+ )
+ def compile_moc(self, state: 'ModuleState', args: T.Tuple, kwargs: 'MocCompilerKwArgs') -> ModuleReturnValue:
+ if any(isinstance(s, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for s in kwargs['headers']):
+ FeatureNew.single_use('qt.compile_moc: custom_target or generator for "headers" keyword argument',
+ '0.60.0', state.subproject, location=state.current_node)
+ if any(isinstance(s, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for s in kwargs['sources']):
+ FeatureNew.single_use('qt.compile_moc: custom_target or generator for "sources" keyword argument',
+ '0.60.0', state.subproject, location=state.current_node)
+ out = self._compile_moc_impl(state, kwargs)
+ return ModuleReturnValue(out, [out])
+
+ def _compile_moc_impl(self, state: 'ModuleState', kwargs: 'MocCompilerKwArgs') -> T.List[build.GeneratedList]:
+ # Avoid the FeatureNew when dispatching from preprocess
+ self._detect_tools(state, kwargs['method'])
+ if not self.tools['moc'].found():
+ err_msg = ("{0} sources specified and couldn't find {1}, "
+ "please check your qt{2} installation")
+ raise MesonException(err_msg.format('MOC', f'uic-qt{self.qt_version}', self.qt_version))
+
+ if not (kwargs['headers'] or kwargs['sources']):
+ raise build.InvalidArguments('At least one of the "headers" or "sources" keyword arguments must be provided and not empty')
+
+ inc = state.get_include_args(include_dirs=kwargs['include_directories'])
+ compile_args: T.List[str] = []
+ for dep in kwargs['dependencies']:
+ compile_args.extend([a for a in dep.get_all_compile_args() if a.startswith(('-I', '-D'))])
+
+ output: T.List[build.GeneratedList] = []
+
+ # depfile arguments (defaults to .d)
+ DEPFILE_ARGS: T.List[str] = ['--output-dep-file'] if self._moc_supports_depfiles else []
+
+ arguments = kwargs['extra_args'] + DEPFILE_ARGS + inc + compile_args + ['@INPUT@', '-o', '@OUTPUT@']
+ if kwargs['headers']:
+ moc_gen = build.Generator(
+ self.tools['moc'], arguments, ['moc_@BASENAME@.cpp'],
+ depfile='moc_@BASENAME@.cpp.d',
+ name=f'Qt{self.qt_version} moc header')
+ output.append(moc_gen.process_files(kwargs['headers'], state))
+ if kwargs['sources']:
+ moc_gen = build.Generator(
+ self.tools['moc'], arguments, ['@BASENAME@.moc'],
+ depfile='@BASENAME.moc.d@',
+ name=f'Qt{self.qt_version} moc source')
+ output.append(moc_gen.process_files(kwargs['sources'], state))
+
+ return output
+
+ # We can't use typed_pos_args here, the signature is ambiguous
+ @typed_kwargs(
+ 'qt.preprocess',
+ KwargInfo('sources', ContainerTypeInfo(list, (File, str)), listify=True, default=[], deprecated='0.59.0'),
+ KwargInfo('qresources', ContainerTypeInfo(list, (File, str)), listify=True, default=[]),
+ KwargInfo('ui_files', ContainerTypeInfo(list, (File, str, build.CustomTarget)), listify=True, default=[]),
+ KwargInfo('moc_sources', ContainerTypeInfo(list, (File, str, build.CustomTarget)), listify=True, default=[]),
+ KwargInfo('moc_headers', ContainerTypeInfo(list, (File, str, build.CustomTarget)), listify=True, default=[]),
+ KwargInfo('moc_extra_arguments', ContainerTypeInfo(list, str), listify=True, default=[], since='0.44.0'),
+ KwargInfo('rcc_extra_arguments', ContainerTypeInfo(list, str), listify=True, default=[], since='0.49.0'),
+ KwargInfo('uic_extra_arguments', ContainerTypeInfo(list, str), listify=True, default=[], since='0.49.0'),
+ KwargInfo('method', str, default='auto'),
+ KwargInfo('include_directories', ContainerTypeInfo(list, (build.IncludeDirs, str)), listify=True, default=[]),
+ KwargInfo('dependencies', ContainerTypeInfo(list, (Dependency, ExternalLibrary)), listify=True, default=[]),
+ )
+ def preprocess(self, state: 'ModuleState', args: T.List[T.Union[str, File]], kwargs: 'PreprocessKwArgs') -> ModuleReturnValue:
+ _sources = args[1:]
+ if _sources:
+ FeatureDeprecated.single_use('qt.preprocess positional sources', '0.59', state.subproject, location=state.current_node)
+ # List is invariant, os we have to cast...
+ sources = T.cast(T.List[T.Union[str, File, build.GeneratedList, build.CustomTarget]],
+ _sources + kwargs['sources'])
+ for s in sources:
+ if not isinstance(s, (str, File)):
+ raise build.InvalidArguments('Variadic arguments to qt.preprocess must be Strings or Files')
+ method = kwargs['method']
+
+ if kwargs['qresources']:
# custom output name set? -> one output file, multiple otherwise
+ rcc_kwargs: 'ResourceCompilerKwArgs' = {'name': '', 'sources': kwargs['qresources'], 'extra_args': kwargs['rcc_extra_arguments'], 'method': method}
if args:
- qrc_deps = []
- for i in rcc_files:
- qrc_deps += self.parse_qrc(state, i)
name = args[0]
- rcc_kwargs = {'input': rcc_files,
- 'output': name + '.cpp',
- 'command': [self.rcc, '-name', name, '-o', '@OUTPUT@', rcc_extra_arguments, '@INPUT@'],
- 'depend_files': qrc_deps}
- res_target = build.CustomTarget(name, state.subdir, state.subproject, rcc_kwargs)
- sources.append(res_target)
- else:
- for rcc_file in rcc_files:
- qrc_deps = self.parse_qrc(state, rcc_file)
- if type(rcc_file) is str:
- basename = os.path.basename(rcc_file)
- elif type(rcc_file) is File:
- basename = os.path.basename(rcc_file.fname)
- name = 'qt' + str(self.qt_version) + '-' + basename.replace('.', '_')
- rcc_kwargs = {'input': rcc_file,
- 'output': name + '.cpp',
- 'command': [self.rcc, '-name', '@BASENAME@', '-o', '@OUTPUT@', rcc_extra_arguments, '@INPUT@'],
- 'depend_files': qrc_deps}
- res_target = build.CustomTarget(name, state.subdir, state.subproject, rcc_kwargs)
- sources.append(res_target)
- if ui_files:
- if not self.uic.found():
- raise MesonException(err_msg.format('UIC', 'uic-qt{}'.format(self.qt_version), self.qt_version))
- arguments = uic_extra_arguments + ['-o', '@OUTPUT@', '@INPUT@']
- ui_kwargs = {'output': 'ui_@BASENAME@.h',
- 'arguments': arguments}
- ui_gen = build.Generator([self.uic], ui_kwargs)
- ui_output = ui_gen.process_files('Qt{} ui'.format(self.qt_version), ui_files, state)
- sources.append(ui_output)
- inc = get_include_args(include_dirs=include_directories)
- compile_args = []
- for dep in dependencies:
- if hasattr(dep, 'held_object'):
- dep = dep.held_object
- if isinstance(dep, Dependency):
- for arg in dep.get_compile_args():
- if arg.startswith('-I') or arg.startswith('-D'):
- compile_args.append(arg)
- else:
- raise MesonException('Argument is of an unacceptable type {!r}.\nMust be '
- 'either an external dependency (returned by find_library() or '
- 'dependency()) or an internal dependency (returned by '
- 'declare_dependency()).'.format(type(dep).__name__))
- if moc_headers:
- arguments = moc_extra_arguments + inc + compile_args + ['@INPUT@', '-o', '@OUTPUT@']
- moc_kwargs = {'output': 'moc_@BASENAME@.cpp',
- 'arguments': arguments}
- moc_gen = build.Generator([self.moc], moc_kwargs)
- moc_output = moc_gen.process_files('Qt{} moc header'.format(self.qt_version), moc_headers, state)
- sources.append(moc_output)
- if moc_sources:
- arguments = moc_extra_arguments + inc + compile_args + ['@INPUT@', '-o', '@OUTPUT@']
- moc_kwargs = {'output': '@BASENAME@.moc',
- 'arguments': arguments}
- moc_gen = build.Generator([self.moc], moc_kwargs)
- moc_output = moc_gen.process_files('Qt{} moc source'.format(self.qt_version), moc_sources, state)
- sources.append(moc_output)
- return ModuleReturnValue(sources, sources)
+ if not isinstance(name, str):
+ raise build.InvalidArguments('First argument to qt.preprocess must be a string')
+ rcc_kwargs['name'] = name
+ sources.extend(self._compile_resources_impl(state, rcc_kwargs))
+
+ if kwargs['ui_files']:
+ ui_kwargs: 'UICompilerKwArgs' = {'sources': kwargs['ui_files'], 'extra_args': kwargs['uic_extra_arguments'], 'method': method}
+ sources.append(self._compile_ui_impl(state, ui_kwargs))
+
+ if kwargs['moc_headers'] or kwargs['moc_sources']:
+ moc_kwargs: 'MocCompilerKwArgs' = {
+ 'extra_args': kwargs['moc_extra_arguments'],
+ 'sources': kwargs['moc_sources'],
+ 'headers': kwargs['moc_headers'],
+ 'include_directories': kwargs['include_directories'],
+ 'dependencies': kwargs['dependencies'],
+ 'method': method,
+ }
+ sources.extend(self._compile_moc_impl(state, moc_kwargs))
+
+ return ModuleReturnValue(sources, [sources])
@FeatureNew('qt.compile_translations', '0.44.0')
- @permittedKwargs({'ts_files', 'install', 'install_dir', 'build_by_default', 'method'})
- def compile_translations(self, state, args, kwargs):
- ts_files, install_dir = extract_as_list(kwargs, 'ts_files', 'install_dir', pop=True)
- self._detect_tools(state.environment, kwargs.get('method', 'auto'))
- translations = []
+ @noPosargs
+ @typed_kwargs(
+ 'qt.compile_translations',
+ KwargInfo('build_by_default', bool, default=False),
+ KwargInfo('install', bool, default=False),
+ KwargInfo('install_dir', (str, NoneType)),
+ KwargInfo('method', str, default='auto'),
+ KwargInfo('qresource', (str, NoneType), since='0.56.0'),
+ KwargInfo('rcc_extra_arguments', ContainerTypeInfo(list, str), listify=True, default=[], since='0.56.0'),
+ KwargInfo('ts_files', ContainerTypeInfo(list, (str, File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)), listify=True, default=[]),
+ )
+ def compile_translations(self, state: 'ModuleState', args: T.Tuple, kwargs: 'CompileTranslationsKwArgs') -> ModuleReturnValue:
+ ts_files = kwargs['ts_files']
+ if any(isinstance(s, (build.CustomTarget, build.CustomTargetIndex, build.GeneratedList)) for s in ts_files):
+ FeatureNew.single_use('qt.compile_translations: custom_target or generator for "ts_files" keyword argument',
+ '0.60.0', state.subproject, location=state.current_node)
+ install_dir = kwargs['install_dir']
+ qresource = kwargs['qresource']
+ if qresource:
+ if ts_files:
+ raise MesonException('qt.compile_translations: Cannot specify both ts_files and qresource')
+ if os.path.dirname(qresource) != '':
+ raise MesonException('qt.compile_translations: qresource file name must not contain a subdirectory.')
+ qresource_file = File.from_built_file(state.subdir, qresource)
+ infile_abs = os.path.join(state.environment.source_dir, qresource_file.relative_name())
+ outfile_abs = os.path.join(state.environment.build_dir, qresource_file.relative_name())
+ os.makedirs(os.path.dirname(outfile_abs), exist_ok=True)
+ shutil.copy2(infile_abs, outfile_abs)
+ self.interpreter.add_build_def_file(infile_abs)
+
+ _, nodes = self._qrc_nodes(state, qresource_file)
+ for c in nodes:
+ if c.endswith('.qm'):
+ ts_files.append(c.rstrip('.qm') + '.ts')
+ else:
+ raise MesonException(f'qt.compile_translations: qresource can only contain qm files, found {c}')
+ results = self.preprocess(state, [], {'qresources': qresource_file, 'rcc_extra_arguments': kwargs['rcc_extra_arguments']})
+ self._detect_tools(state, kwargs['method'])
+ translations: T.List[build.CustomTarget] = []
for ts in ts_files:
- if not self.lrelease.found():
+ if not self.tools['lrelease'].found():
raise MesonException('qt.compile_translations: ' +
- self.lrelease.name + ' not found')
- cmd = [self.lrelease, '@INPUT@', '-qm', '@OUTPUT@']
- lrelease_kwargs = {'output': '@BASENAME@.qm',
- 'input': ts,
- 'install': kwargs.get('install', False),
- 'build_by_default': kwargs.get('build_by_default', False),
- 'command': cmd}
- if install_dir is not None:
- lrelease_kwargs['install_dir'] = install_dir
- lrelease_target = build.CustomTarget('qt{}-compile-{}'.format(self.qt_version, ts), state.subdir, state.subproject, lrelease_kwargs)
+ self.tools['lrelease'].name + ' not found')
+ if qresource:
+ # In this case we know that ts_files is always a List[str], as
+ # it's generated above and no ts_files are passed in. However,
+ # mypy can't figure that out so we use assert to assure it that
+ # what we're doing is safe
+ assert isinstance(ts, str), 'for mypy'
+ outdir = os.path.dirname(os.path.normpath(os.path.join(state.subdir, ts)))
+ ts = os.path.basename(ts)
+ else:
+ outdir = state.subdir
+ cmd = [self.tools['lrelease'], '@INPUT@', '-qm', '@OUTPUT@']
+ lrelease_kwargs: T.Dict[str, T.Any] = {
+ 'output': '@BASENAME@.qm',
+ 'input': ts,
+ 'install': kwargs['install'],
+ 'install_dir': install_dir or [],
+ 'install_tag': 'i18n',
+ 'build_by_default': kwargs['build_by_default'],
+ 'command': cmd}
+ lrelease_target = build.CustomTarget(f'qt{self.qt_version}-compile-{ts}', outdir, state.subproject, lrelease_kwargs)
translations.append(lrelease_target)
- return ModuleReturnValue(translations, translations)
+ if qresource:
+ return ModuleReturnValue(results.return_value[0], [results.new_objects, translations])
+ else:
+ return ModuleReturnValue(translations, [translations])
diff -Nru meson-0.53.2/mesonbuild/modules/rpm.py meson-0.61.2/mesonbuild/modules/rpm.py
--- meson-0.53.2/mesonbuild/modules/rpm.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/rpm.py 2022-01-17 10:50:45.000000000 +0000
@@ -20,25 +20,28 @@
import datetime
from .. import mlog
from . import GirTarget, TypelibTarget
-from . import ModuleReturnValue
from . import ExtensionModule
from ..interpreterbase import noKwargs
import os
class RPMModule(ExtensionModule):
+ def __init__(self, interpreter):
+ super().__init__(interpreter)
+ self.methods.update({
+ 'generate_spec_template': self.generate_spec_template,
+ })
@noKwargs
- def generate_spec_template(self, coredata, args, kwargs):
- self.coredata = coredata
- required_compilers = self.__get_required_compilers()
- proj = coredata.project_name.replace(' ', '_').replace('\t', '_')
+ def generate_spec_template(self, state, args, kwargs):
+ required_compilers = self.__get_required_compilers(state)
+ proj = state.project_name.replace(' ', '_').replace('\t', '_')
so_installed = False
devel_subpkg = False
files = set()
files_devel = set()
to_delete = set()
- for target in coredata.targets.values():
+ for target in state.targets.values():
if isinstance(target, build.Executable) and target.need_install:
files.add('%%{_bindir}/%s' % target.get_filename())
elif isinstance(target, build.SharedLibrary) and target.need_install:
@@ -57,21 +60,24 @@
files_devel.add('%%{_datadir}/gir-1.0/%s' % target.get_filename()[0])
elif isinstance(target, TypelibTarget) and target.should_install():
files.add('%%{_libdir}/girepository-1.0/%s' % target.get_filename()[0])
- for header in coredata.headers:
+ for header in state.headers:
if header.get_install_subdir():
files_devel.add('%%{_includedir}/%s/' % header.get_install_subdir())
else:
for hdr_src in header.get_sources():
files_devel.add('%%{_includedir}/%s' % hdr_src)
- for man in coredata.man:
+ for man in state.man:
for man_file in man.get_sources():
- files.add('%%{_mandir}/man%u/%s.*' % (int(man_file.split('.')[-1]), man_file))
+ if man.locale:
+ files.add('%%{_mandir}/%s/man%u/%s.*' % (man.locale, int(man_file.split('.')[-1]), man_file))
+ else:
+ files.add('%%{_mandir}/man%u/%s.*' % (int(man_file.split('.')[-1]), man_file))
if files_devel:
devel_subpkg = True
- filename = os.path.join(coredata.environment.get_build_dir(),
+ filename = os.path.join(state.environment.get_build_dir(),
'%s.spec' % proj)
- with open(filename, 'w+') as fn:
+ with open(filename, 'w+', encoding='utf-8') as fn:
fn.write('Name: %s\n' % proj)
fn.write('Version: # FIXME\n')
fn.write('Release: 1%{?dist}\n')
@@ -83,7 +89,7 @@
fn.write('BuildRequires: meson\n')
for compiler in required_compilers:
fn.write('BuildRequires: %s\n' % compiler)
- for dep in coredata.environment.coredata.deps.host:
+ for dep in state.environment.coredata.deps.host:
fn.write('BuildRequires: pkgconfig(%s)\n' % dep[0])
# ext_libs and ext_progs have been removed from coredata so the following code
# no longer works. It is kept as a reminder of the idea should anyone wish
@@ -147,11 +153,10 @@
fn.write('- \n')
fn.write('\n')
mlog.log('RPM spec template written to %s.spec.\n' % proj)
- return ModuleReturnValue(None, [])
- def __get_required_compilers(self):
+ def __get_required_compilers(self, state):
required_compilers = set()
- for compiler in self.coredata.environment.coredata.compilers.host.values():
+ for compiler in state.environment.coredata.compilers.host.values():
# Elbrus has one 'lcc' package for every compiler
if isinstance(compiler, compilers.GnuCCompiler):
required_compilers.add('gcc')
diff -Nru meson-0.53.2/mesonbuild/modules/sourceset.py meson-0.61.2/mesonbuild/modules/sourceset.py
--- meson-0.53.2/mesonbuild/modules/sourceset.py 2019-08-28 17:15:39.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/sourceset.py 2021-08-18 11:22:15.000000000 +0000
@@ -14,25 +14,21 @@
from collections import namedtuple
from .. import mesonlib
-from ..mesonlib import listify
-from . import ExtensionModule
+from .. import build
+from ..mesonlib import listify, OrderedSet
+from . import ExtensionModule, ModuleObject, MutableModuleObject
from ..interpreterbase import (
noPosargs, noKwargs, permittedKwargs,
- InterpreterObject, MutableInterpreterObject, ObjectHolder,
InterpreterException, InvalidArguments, InvalidCode, FeatureNew,
)
-from ..interpreter import (
- GeneratedListHolder, CustomTargetHolder,
- CustomTargetIndexHolder
-)
SourceSetRule = namedtuple('SourceSetRule', 'keys sources if_false sourcesets dependencies extra_deps')
SourceFiles = namedtuple('SourceFiles', 'sources dependencies')
-class SourceSetHolder(MutableInterpreterObject, ObjectHolder):
+class SourceSet(MutableModuleObject):
def __init__(self, interpreter):
- MutableInterpreterObject.__init__(self)
- ObjectHolder.__init__(self, list())
+ super().__init__()
+ self.rules = []
self.subproject = interpreter.subproject
self.environment = interpreter.environment
self.subdir = interpreter.subdir
@@ -50,8 +46,8 @@
deps = []
for x in arg:
if isinstance(x, (str, mesonlib.File,
- GeneratedListHolder, CustomTargetHolder,
- CustomTargetIndexHolder)):
+ build.GeneratedList, build.CustomTarget,
+ build.CustomTargetIndex)):
sources.append(x)
elif hasattr(x, 'found'):
if not allow_deps:
@@ -77,7 +73,7 @@
return keys, deps
@permittedKwargs(['when', 'if_false', 'if_true'])
- def add_method(self, args, kwargs):
+ def add_method(self, state, args, kwargs):
if self.frozen:
raise InvalidCode('Tried to use \'add\' after querying the source set')
when = listify(kwargs.get('when', []))
@@ -90,10 +86,10 @@
keys, dependencies = self.check_conditions(when)
sources, extra_deps = self.check_source_files(if_true, True)
if_false, _ = self.check_source_files(if_false, False)
- self.held_object.append(SourceSetRule(keys, sources, if_false, [], dependencies, extra_deps))
+ self.rules.append(SourceSetRule(keys, sources, if_false, [], dependencies, extra_deps))
@permittedKwargs(['when', 'if_true'])
- def add_all_method(self, args, kwargs):
+ def add_all_method(self, state, args, kwargs):
if self.frozen:
raise InvalidCode('Tried to use \'add_all\' after querying the source set')
when = listify(kwargs.get('when', []))
@@ -104,15 +100,15 @@
raise InterpreterException('add_all called with both positional and keyword arguments')
keys, dependencies = self.check_conditions(when)
for s in if_true:
- if not isinstance(s, SourceSetHolder):
+ if not isinstance(s, SourceSet):
raise InvalidCode('Arguments to \'add_all\' after the first must be source sets')
s.frozen = True
- self.held_object.append(SourceSetRule(keys, [], [], if_true, dependencies, []))
+ self.rules.append(SourceSetRule(keys, [], [], if_true, dependencies, []))
def collect(self, enabled_fn, all_sources, into=None):
if not into:
- into = SourceFiles(set(), set())
- for entry in self.held_object:
+ into = SourceFiles(OrderedSet(), OrderedSet())
+ for entry in self.rules:
if all(x.found() for x in entry.dependencies) and \
all(enabled_fn(key) for key in entry.keys):
into.sources.update(entry.sources)
@@ -127,7 +123,7 @@
@noKwargs
@noPosargs
- def all_sources_method(self, args, kwargs):
+ def all_sources_method(self, state, args, kwargs):
self.frozen = True
files = self.collect(lambda x: True, True)
return list(files.sources)
@@ -135,13 +131,13 @@
@noKwargs
@noPosargs
@FeatureNew('source_set.all_dependencies() method', '0.52.0')
- def all_dependencies_method(self, args, kwargs):
+ def all_dependencies_method(self, state, args, kwargs):
self.frozen = True
files = self.collect(lambda x: True, True)
return list(files.dependencies)
@permittedKwargs(['strict'])
- def apply_method(self, args, kwargs):
+ def apply_method(self, state, args, kwargs):
if len(args) != 1:
raise InterpreterException('Apply takes exactly one argument')
config_data = args[0]
@@ -150,7 +146,7 @@
if isinstance(config_data, dict):
def _get_from_config_data(key):
if strict and key not in config_data:
- raise InterpreterException('Entry %s not in configuration dictionary.' % key)
+ raise InterpreterException(f'Entry {key} not in configuration dictionary.')
return config_data.get(key, False)
else:
config_cache = dict()
@@ -163,13 +159,13 @@
return config_cache[key]
files = self.collect(_get_from_config_data, False)
- res = SourceFilesHolder(files)
+ res = SourceFilesObject(files)
return res
-class SourceFilesHolder(InterpreterObject, ObjectHolder):
+class SourceFilesObject(ModuleObject):
def __init__(self, files):
- InterpreterObject.__init__(self)
- ObjectHolder.__init__(self, files)
+ super().__init__()
+ self.files = files
self.methods.update({
'sources': self.sources_method,
'dependencies': self.dependencies_method,
@@ -177,24 +173,26 @@
@noPosargs
@noKwargs
- def sources_method(self, args, kwargs):
- return list(self.held_object.sources)
+ def sources_method(self, state, args, kwargs):
+ return list(self.files.sources)
@noPosargs
@noKwargs
- def dependencies_method(self, args, kwargs):
- return list(self.held_object.dependencies)
+ def dependencies_method(self, state, args, kwargs):
+ return list(self.files.dependencies)
class SourceSetModule(ExtensionModule):
@FeatureNew('SourceSet module', '0.51.0')
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
- self.snippets.add('source_set')
+ self.methods.update({
+ 'source_set': self.source_set,
+ })
@noKwargs
@noPosargs
- def source_set(self, interpreter, state, args, kwargs):
- return SourceSetHolder(interpreter)
+ def source_set(self, state, args, kwargs):
+ return SourceSet(self.interpreter)
def initialize(*args, **kwargs):
return SourceSetModule(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/unstable_cuda.py meson-0.61.2/mesonbuild/modules/unstable_cuda.py
--- meson-0.53.2/mesonbuild/modules/unstable_cuda.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/unstable_cuda.py 2021-11-02 19:58:07.000000000 +0000
@@ -12,38 +12,59 @@
# See the License for the specific language governing permissions and
# limitations under the License.
+import typing as T
import re
from ..mesonlib import version_compare
-from ..interpreter import CompilerHolder
-from ..compilers import CudaCompiler
+from ..compilers import CudaCompiler, Compiler
-from . import ExtensionModule, ModuleReturnValue
+from . import NewExtensionModule
from ..interpreterbase import (
flatten, permittedKwargs, noKwargs,
InvalidArguments, FeatureNew
)
-class CudaModule(ExtensionModule):
+if T.TYPE_CHECKING:
+ from . import ModuleState
+
+class CudaModule(NewExtensionModule):
@FeatureNew('CUDA module', '0.50.0')
def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
+ super().__init__()
+ self.methods.update({
+ "min_driver_version": self.min_driver_version,
+ "nvcc_arch_flags": self.nvcc_arch_flags,
+ "nvcc_arch_readable": self.nvcc_arch_readable,
+ })
@noKwargs
- def min_driver_version(self, state, args, kwargs):
+ def min_driver_version(self, state: 'ModuleState',
+ args: T.Tuple[str],
+ kwargs: T.Dict[str, T.Any]) -> str:
argerror = InvalidArguments('min_driver_version must have exactly one positional argument: ' +
- 'an NVCC compiler object, or its version string.')
+ 'a CUDA Toolkit version string. Beware that, since CUDA 11.0, ' +
+ 'the CUDA Toolkit\'s components (including NVCC) are versioned ' +
+ 'independently from each other (and the CUDA Toolkit as a whole).')
- if len(args) != 1:
+ if len(args) != 1 or not isinstance(args[0], str):
raise argerror
- else:
- cuda_version = self._version_from_compiler(args[0])
- if cuda_version == 'unknown':
- raise argerror
+ cuda_version = args[0]
driver_version_table = [
+ {'cuda_version': '>=11.5.0', 'windows': '496.04', 'linux': '495.29.05'},
+ {'cuda_version': '>=11.4.1', 'windows': '471.41', 'linux': '470.57.02'},
+ {'cuda_version': '>=11.4.0', 'windows': '471.11', 'linux': '470.42.01'},
+ {'cuda_version': '>=11.3.0', 'windows': '465.89', 'linux': '465.19.01'},
+ {'cuda_version': '>=11.2.2', 'windows': '461.33', 'linux': '460.32.03'},
+ {'cuda_version': '>=11.2.1', 'windows': '461.09', 'linux': '460.32.03'},
+ {'cuda_version': '>=11.2.0', 'windows': '460.82', 'linux': '460.27.03'},
+ {'cuda_version': '>=11.1.1', 'windows': '456.81', 'linux': '455.32'},
+ {'cuda_version': '>=11.1.0', 'windows': '456.38', 'linux': '455.23'},
+ {'cuda_version': '>=11.0.3', 'windows': '451.82', 'linux': '450.51.06'},
+ {'cuda_version': '>=11.0.2', 'windows': '451.48', 'linux': '450.51.05'},
+ {'cuda_version': '>=11.0.1', 'windows': '451.22', 'linux': '450.36.06'},
{'cuda_version': '>=10.2.89', 'windows': '441.22', 'linux': '440.33'},
{'cuda_version': '>=10.1.105', 'windows': '418.96', 'linux': '418.39'},
{'cuda_version': '>=10.0.130', 'windows': '411.31', 'linux': '410.48'},
@@ -63,19 +84,23 @@
driver_version = d.get(state.host_machine.system, d['linux'])
break
- return ModuleReturnValue(driver_version, [driver_version])
+ return driver_version
@permittedKwargs(['detected'])
- def nvcc_arch_flags(self, state, args, kwargs):
- nvcc_arch_args = self._validate_nvcc_arch_args(state, args, kwargs)
+ def nvcc_arch_flags(self, state: 'ModuleState',
+ args: T.Tuple[T.Union[Compiler, CudaCompiler, str]],
+ kwargs: T.Dict[str, T.Any]) -> T.List[str]:
+ nvcc_arch_args = self._validate_nvcc_arch_args(args, kwargs)
ret = self._nvcc_arch_flags(*nvcc_arch_args)[0]
- return ModuleReturnValue(ret, [ret])
+ return ret
@permittedKwargs(['detected'])
- def nvcc_arch_readable(self, state, args, kwargs):
- nvcc_arch_args = self._validate_nvcc_arch_args(state, args, kwargs)
+ def nvcc_arch_readable(self, state: 'ModuleState',
+ args: T.Tuple[T.Union[Compiler, CudaCompiler, str]],
+ kwargs: T.Dict[str, T.Any]) -> T.List[str]:
+ nvcc_arch_args = self._validate_nvcc_arch_args(args, kwargs)
ret = self._nvcc_arch_flags(*nvcc_arch_args)[1]
- return ModuleReturnValue(ret, [ret])
+ return ret
@staticmethod
def _break_arch_string(s):
@@ -85,23 +110,19 @@
@staticmethod
def _detected_cc_from_compiler(c):
- if isinstance(c, CompilerHolder):
- c = c.compiler
if isinstance(c, CudaCompiler):
return c.detected_cc
return ''
@staticmethod
def _version_from_compiler(c):
- if isinstance(c, CompilerHolder):
- c = c.compiler
if isinstance(c, CudaCompiler):
return c.version
if isinstance(c, str):
return c
return 'unknown'
- def _validate_nvcc_arch_args(self, state, args, kwargs):
+ def _validate_nvcc_arch_args(self, args, kwargs):
argerror = InvalidArguments('The first argument must be an NVCC compiler object, or its version string!')
if len(args) < 1:
@@ -128,19 +149,45 @@
return cuda_version, arch_list, detected
+ def _filter_cuda_arch_list(self, cuda_arch_list, lo=None, hi=None, saturate=None):
+ """
+ Filter CUDA arch list (no codenames) for >= low and < hi architecture
+ bounds, and deduplicate.
+ If saturate is provided, architectures >= hi are replaced with saturate.
+ """
+
+ filtered_cuda_arch_list = []
+ for arch in cuda_arch_list:
+ if arch:
+ if lo and version_compare(arch, '<' + lo):
+ continue
+ if hi and version_compare(arch, '>=' + hi):
+ if not saturate:
+ continue
+ arch = saturate
+ if arch not in filtered_cuda_arch_list:
+ filtered_cuda_arch_list.append(arch)
+ return filtered_cuda_arch_list
+
def _nvcc_arch_flags(self, cuda_version, cuda_arch_list='Auto', detected=''):
"""
- Using the CUDA Toolkit version (the NVCC version) and the target
- architectures, compute the NVCC architecture flags.
+ Using the CUDA Toolkit version and the target architectures, compute
+ the NVCC architecture flags.
"""
- cuda_known_gpu_architectures = ['Fermi', 'Kepler', 'Maxwell'] # noqa: E221
- cuda_common_gpu_architectures = ['3.0', '3.5', '5.0'] # noqa: E221
- cuda_limit_gpu_architecture = None # noqa: E221
- cuda_all_gpu_architectures = ['3.0', '3.2', '3.5', '5.0'] # noqa: E221
+ # Replicates much of the logic of
+ # https://github.com/Kitware/CMake/blob/master/Modules/FindCUDA/select_compute_arch.cmake
+ # except that a bug with cuda_arch_list="All" is worked around by
+ # tracking both lower and upper limits on GPU architectures.
+
+ cuda_known_gpu_architectures = ['Fermi', 'Kepler', 'Maxwell'] # noqa: E221
+ cuda_common_gpu_architectures = ['3.0', '3.5', '5.0'] # noqa: E221
+ cuda_hi_limit_gpu_architecture = None # noqa: E221
+ cuda_lo_limit_gpu_architecture = '2.0' # noqa: E221
+ cuda_all_gpu_architectures = ['3.0', '3.2', '3.5', '5.0'] # noqa: E221
if version_compare(cuda_version, '<7.0'):
- cuda_limit_gpu_architecture = '5.2'
+ cuda_hi_limit_gpu_architecture = '5.2'
if version_compare(cuda_version, '>=7.0'):
cuda_known_gpu_architectures += ['Kepler+Tegra', 'Kepler+Tesla', 'Maxwell+Tegra'] # noqa: E221
@@ -148,7 +195,7 @@
if version_compare(cuda_version, '<8.0'):
cuda_common_gpu_architectures += ['5.2+PTX'] # noqa: E221
- cuda_limit_gpu_architecture = '6.0' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '6.0' # noqa: E221
if version_compare(cuda_version, '>=8.0'):
cuda_known_gpu_architectures += ['Pascal', 'Pascal+Tegra'] # noqa: E221
@@ -157,23 +204,45 @@
if version_compare(cuda_version, '<9.0'):
cuda_common_gpu_architectures += ['6.1+PTX'] # noqa: E221
- cuda_limit_gpu_architecture = '7.0' # noqa: E221
+ cuda_hi_limit_gpu_architecture = '7.0' # noqa: E221
if version_compare(cuda_version, '>=9.0'):
- cuda_known_gpu_architectures += ['Volta', 'Xavier'] # noqa: E221
- cuda_common_gpu_architectures += ['7.0', '7.0+PTX'] # noqa: E221
- cuda_all_gpu_architectures += ['7.0', '7.0+PTX', '7.2', '7.2+PTX'] # noqa: E221
+ cuda_known_gpu_architectures += ['Volta', 'Xavier'] # noqa: E221
+ cuda_common_gpu_architectures += ['7.0'] # noqa: E221
+ cuda_all_gpu_architectures += ['7.0', '7.2'] # noqa: E221
+ # https://docs.nvidia.com/cuda/archive/9.0/cuda-toolkit-release-notes/index.html#unsupported-features
+ cuda_lo_limit_gpu_architecture = '3.0' # noqa: E221
if version_compare(cuda_version, '<10.0'):
- cuda_limit_gpu_architecture = '7.5'
+ cuda_common_gpu_architectures += ['7.2+PTX'] # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.0' # noqa: E221
if version_compare(cuda_version, '>=10.0'):
- cuda_known_gpu_architectures += ['Turing'] # noqa: E221
- cuda_common_gpu_architectures += ['7.5', '7.5+PTX'] # noqa: E221
- cuda_all_gpu_architectures += ['7.5', '7.5+PTX'] # noqa: E221
+ cuda_known_gpu_architectures += ['Turing'] # noqa: E221
+ cuda_common_gpu_architectures += ['7.5'] # noqa: E221
+ cuda_all_gpu_architectures += ['7.5'] # noqa: E221
if version_compare(cuda_version, '<11.0'):
- cuda_limit_gpu_architecture = '8.0'
+ cuda_common_gpu_architectures += ['7.5+PTX'] # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.0' # noqa: E221
+
+ if version_compare(cuda_version, '>=11.0'):
+ cuda_known_gpu_architectures += ['Ampere'] # noqa: E221
+ cuda_common_gpu_architectures += ['8.0'] # noqa: E221
+ cuda_all_gpu_architectures += ['8.0'] # noqa: E221
+ # https://docs.nvidia.com/cuda/archive/11.0/cuda-toolkit-release-notes/index.html#deprecated-features
+ cuda_lo_limit_gpu_architecture = '3.5' # noqa: E221
+
+ if version_compare(cuda_version, '<11.1'):
+ cuda_common_gpu_architectures += ['8.0+PTX'] # noqa: E221
+ cuda_hi_limit_gpu_architecture = '8.6' # noqa: E221
+
+ if version_compare(cuda_version, '>=11.1'):
+ cuda_common_gpu_architectures += ['8.6', '8.6+PTX'] # noqa: E221
+ cuda_all_gpu_architectures += ['8.6'] # noqa: E221
+
+ if version_compare(cuda_version, '<12.0'):
+ cuda_hi_limit_gpu_architecture = '9.0' # noqa: E221
if not cuda_arch_list:
cuda_arch_list = 'Auto'
@@ -188,22 +257,16 @@
cuda_arch_list = detected
else:
cuda_arch_list = self._break_arch_string(detected)
-
- if cuda_limit_gpu_architecture:
- filtered_cuda_arch_list = []
- for arch in cuda_arch_list:
- if arch:
- if version_compare(arch, '>=' + cuda_limit_gpu_architecture):
- arch = cuda_common_gpu_architectures[-1]
- if arch not in filtered_cuda_arch_list:
- filtered_cuda_arch_list.append(arch)
- cuda_arch_list = filtered_cuda_arch_list
+ cuda_arch_list = self._filter_cuda_arch_list(cuda_arch_list,
+ cuda_lo_limit_gpu_architecture,
+ cuda_hi_limit_gpu_architecture,
+ cuda_common_gpu_architectures[-1])
else:
cuda_arch_list = cuda_common_gpu_architectures
elif isinstance(cuda_arch_list, str):
cuda_arch_list = self._break_arch_string(cuda_arch_list)
- cuda_arch_list = sorted([x for x in set(cuda_arch_list) if x])
+ cuda_arch_list = sorted(x for x in set(cuda_arch_list) if x)
cuda_arch_bin = []
cuda_arch_ptx = []
@@ -229,11 +292,11 @@
'Volta': (['7.0'], ['7.0']),
'Xavier': (['7.2'], []),
'Turing': (['7.5'], ['7.5']),
+ 'Ampere': (['8.0'], ['8.0']),
}.get(arch_name, (None, None))
if arch_bin is None:
- raise InvalidArguments('Unknown CUDA Architecture Name {}!'
- .format(arch_name))
+ raise InvalidArguments(f'Unknown CUDA Architecture Name {arch_name}!')
cuda_arch_bin += arch_bin
@@ -242,10 +305,6 @@
arch_ptx = arch_bin
cuda_arch_ptx += arch_ptx
- cuda_arch_bin = re.sub('\\.', '', ' '.join(cuda_arch_bin))
- cuda_arch_ptx = re.sub('\\.', '', ' '.join(cuda_arch_ptx))
- cuda_arch_bin = re.findall('[0-9()]+', cuda_arch_bin)
- cuda_arch_ptx = re.findall('[0-9]+', cuda_arch_ptx)
cuda_arch_bin = sorted(list(set(cuda_arch_bin)))
cuda_arch_ptx = sorted(list(set(cuda_arch_ptx)))
@@ -253,15 +312,37 @@
nvcc_archs_readable = []
for arch in cuda_arch_bin:
- m = re.match('([0-9]+)\\(([0-9]+)\\)', arch)
- if m:
- nvcc_flags += ['-gencode', 'arch=compute_' + m[2] + ',code=sm_' + m[1]]
- nvcc_archs_readable += ['sm_' + m[1]]
+ arch, codev = re.fullmatch(
+ '([0-9]+\\.[0-9])(?:\\(([0-9]+\\.[0-9])\\))?', arch).groups()
+
+ if version_compare(arch, '<' + cuda_lo_limit_gpu_architecture):
+ continue
+ if version_compare(arch, '>=' + cuda_hi_limit_gpu_architecture):
+ continue
+
+ if codev:
+ arch = arch.replace('.', '')
+ codev = codev.replace('.', '')
+ nvcc_flags += ['-gencode', 'arch=compute_' + codev + ',code=sm_' + arch]
+ nvcc_archs_readable += ['sm_' + arch]
else:
+ arch = arch.replace('.', '')
nvcc_flags += ['-gencode', 'arch=compute_' + arch + ',code=sm_' + arch]
nvcc_archs_readable += ['sm_' + arch]
for arch in cuda_arch_ptx:
+ arch, codev = re.fullmatch(
+ '([0-9]+\\.[0-9])(?:\\(([0-9]+\\.[0-9])\\))?', arch).groups()
+
+ if codev:
+ arch = codev
+
+ if version_compare(arch, '<' + cuda_lo_limit_gpu_architecture):
+ continue
+ if version_compare(arch, '>=' + cuda_hi_limit_gpu_architecture):
+ continue
+
+ arch = arch.replace('.', '')
nvcc_flags += ['-gencode', 'arch=compute_' + arch + ',code=compute_' + arch]
nvcc_archs_readable += ['compute_' + arch]
diff -Nru meson-0.53.2/mesonbuild/modules/unstable_external_project.py meson-0.61.2/mesonbuild/modules/unstable_external_project.py
--- meson-0.53.2/mesonbuild/modules/unstable_external_project.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/unstable_external_project.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,297 @@
+# Copyright 2020 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 pathlib import Path
+import os
+import shlex
+import subprocess
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue, NewExtensionModule
+from .. import mlog, build
+from ..compilers.compilers import CFLAGS_MAPPING
+from ..envconfig import ENV_VAR_PROG_MAP
+from ..dependencies import InternalDependency, PkgConfigDependency
+from ..interpreterbase import FeatureNew
+from ..interpreter.type_checking import ENV_KW
+from ..interpreterbase.decorators import ContainerTypeInfo, KwargInfo, typed_kwargs, typed_pos_args
+from ..mesonlib import (EnvironmentException, MesonException, Popen_safe, MachineChoice,
+ get_variable_regex, do_replacement, join_args, OptionKey)
+
+if T.TYPE_CHECKING:
+ from typing_extensions import TypedDict
+
+ from . import ModuleState
+ from ..interpreter import Interpreter
+ from ..interpreterbase import TYPE_var
+
+ class Dependency(TypedDict):
+
+ subdir: str
+
+ class AddProject(TypedDict):
+
+ configure_options: T.List[str]
+ cross_configure_options: T.List[str]
+ verbose: bool
+ env: build.EnvironmentVariables
+
+
+class ExternalProject(NewExtensionModule):
+ def __init__(self,
+ state: 'ModuleState',
+ configure_command: str,
+ configure_options: T.List[str],
+ cross_configure_options: T.List[str],
+ env: build.EnvironmentVariables,
+ verbose: bool):
+ super().__init__()
+ self.methods.update({'dependency': self.dependency_method,
+ })
+
+ self.subdir = Path(state.subdir)
+ self.project_version = state.project_version
+ self.subproject = state.subproject
+ self.env = state.environment
+ self.build_machine = state.build_machine
+ self.host_machine = state.host_machine
+ self.configure_command = configure_command
+ self.configure_options = configure_options
+ self.cross_configure_options = cross_configure_options
+ self.verbose = verbose
+ self.user_env = env
+
+ self.src_dir = Path(self.env.get_source_dir(), self.subdir)
+ self.build_dir = Path(self.env.get_build_dir(), self.subdir, 'build')
+ self.install_dir = Path(self.env.get_build_dir(), self.subdir, 'dist')
+ _p = self.env.coredata.get_option(OptionKey('prefix'))
+ assert isinstance(_p, str), 'for mypy'
+ self.prefix = Path(_p)
+ _l = self.env.coredata.get_option(OptionKey('libdir'))
+ assert isinstance(_l, str), 'for mypy'
+ self.libdir = Path(_l)
+ _i = self.env.coredata.get_option(OptionKey('includedir'))
+ assert isinstance(_i, str), 'for mypy'
+ self.includedir = Path(_i)
+ self.name = self.src_dir.name
+
+ # On Windows if the prefix is "c:/foo" and DESTDIR is "c:/bar", `make`
+ # will install files into "c:/bar/c:/foo" which is an invalid path.
+ # Work around that issue by removing the drive from prefix.
+ if self.prefix.drive:
+ self.prefix = self.prefix.relative_to(self.prefix.drive)
+
+ # self.prefix is an absolute path, so we cannot append it to another path.
+ self.rel_prefix = self.prefix.relative_to(self.prefix.root)
+
+ self._configure(state)
+
+ self.targets = self._create_targets()
+
+ def _configure(self, state: 'ModuleState') -> None:
+ if self.configure_command == 'waf':
+ FeatureNew('Waf external project', '0.60.0', location=state.current_node).use(self.subproject)
+ waf = state.find_program('waf')
+ configure_cmd = waf.get_command()
+ configure_cmd += ['configure', '-o', str(self.build_dir)]
+ workdir = self.src_dir
+ self.make = waf.get_command() + ['build']
+ else:
+ # Assume it's the name of a script in source dir, like 'configure',
+ # 'autogen.sh', etc).
+ configure_path = Path(self.src_dir, self.configure_command)
+ configure_prog = state.find_program(configure_path.as_posix())
+ configure_cmd = configure_prog.get_command()
+ workdir = self.build_dir
+ self.make = state.find_program('make').get_command()
+
+ d = [('PREFIX', '--prefix=@PREFIX@', self.prefix.as_posix()),
+ ('LIBDIR', '--libdir=@PREFIX@/@LIBDIR@', self.libdir.as_posix()),
+ ('INCLUDEDIR', None, self.includedir.as_posix()),
+ ]
+ self._validate_configure_options(d, state)
+
+ configure_cmd += self._format_options(self.configure_options, d)
+
+ if self.env.is_cross_build():
+ host = '{}-{}-{}'.format(self.host_machine.cpu_family,
+ self.build_machine.system,
+ self.host_machine.system)
+ d = [('HOST', None, host)]
+ configure_cmd += self._format_options(self.cross_configure_options, d)
+
+ # Set common env variables like CFLAGS, CC, etc.
+ link_exelist: T.List[str] = []
+ link_args: T.List[str] = []
+ self.run_env = os.environ.copy()
+ for lang, compiler in self.env.coredata.compilers[MachineChoice.HOST].items():
+ if any(lang not in i for i in (ENV_VAR_PROG_MAP, CFLAGS_MAPPING)):
+ continue
+ cargs = self.env.coredata.get_external_args(MachineChoice.HOST, lang)
+ assert isinstance(cargs, list), 'for mypy'
+ self.run_env[ENV_VAR_PROG_MAP[lang]] = self._quote_and_join(compiler.get_exelist())
+ self.run_env[CFLAGS_MAPPING[lang]] = self._quote_and_join(cargs)
+ if not link_exelist:
+ link_exelist = compiler.get_linker_exelist()
+ _l = self.env.coredata.get_external_link_args(MachineChoice.HOST, lang)
+ assert isinstance(_l, list), 'for mypy'
+ link_args = _l
+ if link_exelist:
+ # FIXME: Do not pass linker because Meson uses CC as linker wrapper,
+ # but autotools often expects the real linker (e.h. GNU ld).
+ # self.run_env['LD'] = self._quote_and_join(link_exelist)
+ pass
+ self.run_env['LDFLAGS'] = self._quote_and_join(link_args)
+
+ self.run_env = self.user_env.get_env(self.run_env)
+
+ PkgConfigDependency.setup_env(self.run_env, self.env, MachineChoice.HOST,
+ Path(self.env.get_build_dir(), 'meson-uninstalled').as_posix())
+
+ self.build_dir.mkdir(parents=True, exist_ok=True)
+ self._run('configure', configure_cmd, workdir)
+
+ def _quote_and_join(self, array: T.List[str]) -> str:
+ return ' '.join([shlex.quote(i) for i in array])
+
+ def _validate_configure_options(self, variables: T.List[T.Tuple[str, str, str]], state: 'ModuleState') -> None:
+ # Ensure the user at least try to pass basic info to the build system,
+ # like the prefix, libdir, etc.
+ for key, default, val in variables:
+ if default is None:
+ continue
+ key_format = f'@{key}@'
+ for option in self.configure_options:
+ if key_format in option:
+ break
+ else:
+ FeatureNew('Default configure_option', '0.57.0', location=state.current_node).use(self.subproject)
+ self.configure_options.append(default)
+
+ def _format_options(self, options: T.List[str], variables: T.List[T.Tuple[str, str, str]]) -> T.List[str]:
+ out: T.List[str] = []
+ missing = set()
+ regex = get_variable_regex('meson')
+ confdata: T.Dict[str, T.Tuple[str, T.Optional[str]]] = {k: (v, None) for k, _, v in variables}
+ for o in options:
+ arg, missing_vars = do_replacement(regex, o, 'meson', confdata)
+ missing.update(missing_vars)
+ out.append(arg)
+ if missing:
+ var_list = ", ".join(map(repr, sorted(missing)))
+ raise EnvironmentException(
+ f"Variables {var_list} in configure options are missing.")
+ return out
+
+ def _run(self, step: str, command: T.List[str], workdir: Path) -> None:
+ mlog.log(f'External project {self.name}:', mlog.bold(step))
+ m = 'Running command ' + str(command) + ' in directory ' + str(workdir) + '\n'
+ log_filename = Path(mlog.log_dir, f'{self.name}-{step}.log')
+ output = None
+ if not self.verbose:
+ output = open(log_filename, 'w', encoding='utf-8')
+ output.write(m + '\n')
+ output.flush()
+ else:
+ mlog.log(m)
+ p, *_ = Popen_safe(command, cwd=str(workdir), env=self.run_env,
+ stderr=subprocess.STDOUT,
+ stdout=output)
+ if p.returncode != 0:
+ m = f'{step} step returned error code {p.returncode}.'
+ if not self.verbose:
+ m += '\nSee logs: ' + str(log_filename)
+ raise MesonException(m)
+
+ def _create_targets(self) -> T.List['TYPE_var']:
+ cmd = self.env.get_build_command()
+ cmd += ['--internal', 'externalproject',
+ '--name', self.name,
+ '--srcdir', self.src_dir.as_posix(),
+ '--builddir', self.build_dir.as_posix(),
+ '--installdir', self.install_dir.as_posix(),
+ '--logdir', mlog.log_dir,
+ '--make', join_args(self.make),
+ ]
+ if self.verbose:
+ cmd.append('--verbose')
+
+ target_kwargs = {'output': f'{self.name}.stamp',
+ 'depfile': f'{self.name}.d',
+ 'command': cmd + ['@OUTPUT@', '@DEPFILE@'],
+ 'console': True,
+ }
+ self.target = build.CustomTarget(self.name,
+ self.subdir.as_posix(),
+ self.subproject,
+ target_kwargs)
+
+ idir = build.InstallDir(self.subdir.as_posix(),
+ Path('dist', self.rel_prefix).as_posix(),
+ install_dir='.',
+ install_mode=None,
+ exclude=None,
+ strip_directory=True,
+ from_source_dir=False,
+ subproject=self.subproject)
+
+ return [self.target, idir]
+
+ @typed_pos_args('external_project.dependency', str)
+ @typed_kwargs('external_project.dependency', KwargInfo('subdir', str, default=''))
+ def dependency_method(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'Dependency') -> InternalDependency:
+ libname = args[0]
+
+ abs_includedir = Path(self.install_dir, self.rel_prefix, self.includedir)
+ if kwargs['subdir']:
+ abs_includedir = Path(abs_includedir, kwargs['subdir'])
+ abs_libdir = Path(self.install_dir, self.rel_prefix, self.libdir)
+
+ version = self.project_version
+ compile_args = [f'-I{abs_includedir}']
+ link_args = [f'-L{abs_libdir}', f'-l{libname}']
+ sources = self.target
+ dep = InternalDependency(version, [], compile_args, link_args, [],
+ [], [sources], [], {})
+ return dep
+
+
+class ExternalProjectModule(ExtensionModule):
+ @FeatureNew('External build system Module', '0.56.0')
+ def __init__(self, interpreter: 'Interpreter'):
+ super().__init__(interpreter)
+ self.methods.update({'add_project': self.add_project,
+ })
+
+ @typed_pos_args('external_project_mod.add_project', str)
+ @typed_kwargs(
+ 'external_project.add_project',
+ KwargInfo('configure_options', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('cross_configure_options', ContainerTypeInfo(list, str), default=['--host=@HOST@'], listify=True),
+ KwargInfo('verbose', bool, default=False),
+ ENV_KW,
+ )
+ def add_project(self, state: 'ModuleState', args: T.Tuple[str], kwargs: 'AddProject') -> ModuleReturnValue:
+ configure_command = args[0]
+ project = ExternalProject(state,
+ configure_command,
+ kwargs['configure_options'],
+ kwargs['cross_configure_options'],
+ kwargs['env'],
+ kwargs['verbose'])
+ return ModuleReturnValue(project, project.targets)
+
+
+def initialize(interp: 'Interpreter') -> ExternalProjectModule:
+ return ExternalProjectModule(interp)
diff -Nru meson-0.53.2/mesonbuild/modules/unstable_icestorm.py meson-0.61.2/mesonbuild/modules/unstable_icestorm.py
--- meson-0.53.2/mesonbuild/modules/unstable_icestorm.py 2019-05-02 18:59:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/unstable_icestorm.py 2021-08-18 11:22:15.000000000 +0000
@@ -23,19 +23,21 @@
@FeatureNew('FPGA/Icestorm Module', '0.45.0')
def __init__(self, interpreter):
super().__init__(interpreter)
- self.snippets.add('project')
self.yosys_bin = None
+ self.methods.update({
+ 'project': self.project,
+ })
+
+ def detect_binaries(self, state):
+ self.yosys_bin = state.find_program('yosys')
+ self.arachne_bin = state.find_program('arachne-pnr')
+ self.icepack_bin = state.find_program('icepack')
+ self.iceprog_bin = state.find_program('iceprog')
+ self.icetime_bin = state.find_program('icetime')
- def detect_binaries(self, interpreter):
- self.yosys_bin = interpreter.find_program_impl(['yosys'])
- self.arachne_bin = interpreter.find_program_impl(['arachne-pnr'])
- self.icepack_bin = interpreter.find_program_impl(['icepack'])
- self.iceprog_bin = interpreter.find_program_impl(['iceprog'])
- self.icetime_bin = interpreter.find_program_impl(['icetime'])
-
- def project(self, interpreter, state, args, kwargs):
+ def project(self, state, args, kwargs):
if not self.yosys_bin:
- self.detect_binaries(interpreter)
+ self.detect_binaries(state)
if not args:
raise mesonlib.MesonException('Project requires at least one argument, which is the project name.')
proj_name = args[0]
@@ -45,11 +47,11 @@
kwarg_sources = kwargs.get('sources', [])
if not isinstance(kwarg_sources, list):
kwarg_sources = [kwarg_sources]
- all_sources = interpreter.source_strings_to_files(flatten(arg_sources + kwarg_sources))
+ all_sources = self.interpreter.source_strings_to_files(flatten(arg_sources + kwarg_sources))
if 'constraint_file' not in kwargs:
raise mesonlib.MesonException('Constraint file not specified.')
- constraint_file = interpreter.source_strings_to_files(kwargs['constraint_file'])
+ constraint_file = self.interpreter.source_strings_to_files(kwargs['constraint_file'])
if len(constraint_file) != 1:
raise mesonlib.MesonException('Constraint file must contain one and only one entry.')
blif_name = proj_name + '_blif'
@@ -61,26 +63,26 @@
time_name = proj_name + '-time'
upload_name = proj_name + '-upload'
- blif_target = interpreter.func_custom_target(None, [blif_name], {
+ blif_target = self.interpreter.func_custom_target(None, [blif_name], {
'input': all_sources,
'output': blif_fname,
'command': [self.yosys_bin, '-q', '-p', 'synth_ice40 -blif @OUTPUT@', '@INPUT@']})
- asc_target = interpreter.func_custom_target(None, [asc_name], {
+ asc_target = self.interpreter.func_custom_target(None, [asc_name], {
'input': blif_target,
'output': asc_fname,
'command': [self.arachne_bin, '-q', '-d', '1k', '-p', constraint_file, '@INPUT@', '-o', '@OUTPUT@']})
- bin_target = interpreter.func_custom_target(None, [bin_name], {
+ bin_target = self.interpreter.func_custom_target(None, [bin_name], {
'input': asc_target,
'output': bin_fname,
'command': [self.icepack_bin, '@INPUT@', '@OUTPUT@'],
'build_by_default': True})
- interpreter.func_run_target(None, [upload_name], {
+ self.interpreter.func_run_target(None, [upload_name], {
'command': [self.iceprog_bin, bin_target]})
- interpreter.func_run_target(None, [time_name], {
+ self.interpreter.func_run_target(None, [time_name], {
'command': [self.icetime_bin, bin_target]})
def initialize(*args, **kwargs):
diff -Nru meson-0.53.2/mesonbuild/modules/unstable_kconfig.py meson-0.61.2/mesonbuild/modules/unstable_kconfig.py
--- meson-0.53.2/mesonbuild/modules/unstable_kconfig.py 2019-08-28 17:15:39.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/unstable_kconfig.py 1970-01-01 00:00:00.000000000 +0000
@@ -1,73 +0,0 @@
-# Copyright 2017, 2019 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 . import ExtensionModule
-
-from .. import mesonlib
-from ..mesonlib import typeslistify
-from ..interpreterbase import FeatureNew, noKwargs
-from ..interpreter import InvalidCode
-
-import os
-
-class KconfigModule(ExtensionModule):
-
- @FeatureNew('Kconfig Module', '0.51.0')
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self.snippets.add('load')
-
- def _load_file(self, path_to_config):
- result = dict()
- try:
- with open(path_to_config) as f:
- for line in f:
- if '#' in line:
- comment_idx = line.index('#')
- line = line[:comment_idx]
- line = line.strip()
- try:
- name, val = line.split('=', 1)
- except ValueError:
- continue
- result[name.strip()] = val.strip()
- except IOError as e:
- raise mesonlib.MesonException('Failed to load {}: {}'.format(path_to_config, e))
-
- return result
-
- @noKwargs
- def load(self, interpreter, state, args, kwargs):
- sources = typeslistify(args, (str, mesonlib.File))
- if len(sources) != 1:
- raise InvalidCode('load takes only one file input.')
-
- s = sources[0]
- is_built = False
- if isinstance(s, mesonlib.File):
- if s.is_built:
- FeatureNew('kconfig.load() of built files', '0.52.0').use(state.subproject)
- is_built = True
- s = s.absolute_path(interpreter.environment.source_dir, interpreter.environment.build_dir)
- else:
- s = os.path.join(interpreter.environment.source_dir, s)
-
- if s not in interpreter.build_def_files and not is_built:
- interpreter.build_def_files.append(s)
-
- return self._load_file(s)
-
-
-def initialize(*args, **kwargs):
- return KconfigModule(*args, **kwargs)
diff -Nru meson-0.53.2/mesonbuild/modules/unstable_rust.py meson-0.61.2/mesonbuild/modules/unstable_rust.py
--- meson-0.53.2/mesonbuild/modules/unstable_rust.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/unstable_rust.py 2021-11-25 22:00:46.000000000 +0000
@@ -0,0 +1,234 @@
+# Copyright © 2020 Intel Corporation
+
+# 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.
+
+import os
+import typing as T
+
+from . import ExtensionModule, ModuleReturnValue
+from .. import mlog
+from ..build import BothLibraries, BuildTarget, CustomTargetIndex, Executable, ExtractedObjects, GeneratedList, IncludeDirs, CustomTarget
+from ..dependencies import Dependency, ExternalLibrary
+from ..interpreter.interpreter import TEST_KWARGS
+from ..interpreterbase import ContainerTypeInfo, InterpreterException, KwargInfo, FeatureNew, typed_kwargs, typed_pos_args, noPosargs
+from ..mesonlib import File
+
+if T.TYPE_CHECKING:
+ from . import ModuleState
+ from ..interpreter import Interpreter
+ from ..interpreter import kwargs as _kwargs
+ from ..interpreter.interpreter import SourceInputs, SourceOutputs
+ from ..programs import ExternalProgram
+
+ from typing_extensions import TypedDict
+
+ class FuncTest(_kwargs.BaseTest):
+
+ dependencies: T.List[T.Union[Dependency, ExternalLibrary]]
+ is_parallel: bool
+
+ class FuncBindgen(TypedDict):
+
+ args: T.List[str]
+ c_args: T.List[str]
+ include_directories: T.List[IncludeDirs]
+ input: T.List[SourceInputs]
+ output: str
+
+
+class RustModule(ExtensionModule):
+
+ """A module that holds helper functions for rust."""
+
+ @FeatureNew('rust module', '0.57.0')
+ def __init__(self, interpreter: 'Interpreter') -> None:
+ super().__init__(interpreter)
+ self._bindgen_bin: T.Optional['ExternalProgram'] = None
+ self.methods.update({
+ 'test': self.test,
+ 'bindgen': self.bindgen,
+ })
+
+ @typed_pos_args('rust.test', str, BuildTarget)
+ @typed_kwargs(
+ 'rust.test',
+ *TEST_KWARGS,
+ KwargInfo('is_parallel', bool, default=False),
+ KwargInfo(
+ 'dependencies',
+ ContainerTypeInfo(list, (Dependency, ExternalLibrary)),
+ listify=True,
+ default=[]),
+ )
+ def test(self, state: 'ModuleState', args: T.Tuple[str, BuildTarget], kwargs: 'FuncTest') -> ModuleReturnValue:
+ """Generate a rust test target from a given rust target.
+
+ Rust puts it's unitests inside it's main source files, unlike most
+ languages that put them in external files. This means that normally
+ you have to define two separate targets with basically the same
+ arguments to get tests:
+
+ ```meson
+ rust_lib_sources = [...]
+ rust_lib = static_library(
+ 'rust_lib',
+ rust_lib_sources,
+ )
+
+ rust_lib_test = executable(
+ 'rust_lib_test',
+ rust_lib_sources,
+ rust_args : ['--test'],
+ )
+
+ test(
+ 'rust_lib_test',
+ rust_lib_test,
+ protocol : 'rust',
+ )
+ ```
+
+ This is all fine, but not very DRY. This method makes it much easier
+ to define rust tests:
+
+ ```meson
+ rust = import('unstable-rust')
+
+ rust_lib = static_library(
+ 'rust_lib',
+ [sources],
+ )
+
+ rust.test('rust_lib_test', rust_lib)
+ ```
+ """
+ name = args[0]
+ base_target: BuildTarget = args[1]
+ if not base_target.uses_rust():
+ raise InterpreterException('Second positional argument to rustmod.test() must be a rust based target')
+ extra_args = kwargs['args']
+
+ # Delete any arguments we don't want passed
+ if '--test' in extra_args:
+ mlog.warning('Do not add --test to rustmod.test arguments')
+ extra_args.remove('--test')
+ if '--format' in extra_args:
+ mlog.warning('Do not add --format to rustmod.test arguments')
+ i = extra_args.index('--format')
+ # Also delete the argument to --format
+ del extra_args[i + 1]
+ del extra_args[i]
+ for i, a in enumerate(extra_args):
+ if isinstance(a, str) and a.startswith('--format='):
+ del extra_args[i]
+ break
+
+ dependencies = [d for d in kwargs['dependencies']]
+
+ # We need to cast here, as currently these don't have protocol in them, but test itself does.
+ tkwargs = T.cast('_kwargs.FuncTest', kwargs.copy())
+
+ tkwargs['args'] = extra_args + ['--test', '--format', 'pretty']
+ tkwargs['protocol'] = 'rust'
+
+ new_target_kwargs = base_target.kwargs.copy()
+ # Don't mutate the shallow copied list, instead replace it with a new
+ # one
+ new_target_kwargs['rust_args'] = new_target_kwargs.get('rust_args', []) + ['--test']
+ new_target_kwargs['install'] = False
+ new_target_kwargs['dependencies'] = new_target_kwargs.get('dependencies', []) + dependencies
+
+ new_target = Executable(
+ name, base_target.subdir, state.subproject,
+ base_target.for_machine, base_target.sources,
+ base_target.objects, base_target.environment,
+ new_target_kwargs
+ )
+
+ test = self.interpreter.make_test(
+ self.interpreter.current_node, (name, new_target), tkwargs)
+
+ return ModuleReturnValue(None, [new_target, test])
+
+ @noPosargs
+ @typed_kwargs(
+ 'rust.bindgen',
+ KwargInfo('c_args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('args', ContainerTypeInfo(list, str), default=[], listify=True),
+ KwargInfo('include_directories', ContainerTypeInfo(list, IncludeDirs), default=[], listify=True),
+ KwargInfo(
+ 'input',
+ ContainerTypeInfo(list, (File, GeneratedList, BuildTarget, BothLibraries, ExtractedObjects, CustomTargetIndex, CustomTarget, str), allow_empty=False),
+ default=[],
+ listify=True,
+ required=True,
+ ),
+ KwargInfo('output', str, required=True),
+ )
+ def bindgen(self, state: 'ModuleState', args: T.List, kwargs: 'FuncBindgen') -> ModuleReturnValue:
+ """Wrapper around bindgen to simplify it's use.
+
+ The main thing this simplifies is the use of `include_directory`
+ objects, instead of having to pass a plethora of `-I` arguments.
+ """
+ header, *_deps = self.interpreter.source_strings_to_files(kwargs['input'])
+
+ # Split File and Target dependencies to add pass to CustomTarget
+ depends: T.List['SourceOutputs'] = []
+ depend_files: T.List[File] = []
+ for d in _deps:
+ if isinstance(d, File):
+ depend_files.append(d)
+ else:
+ depends.append(d)
+
+ inc_strs: T.List[str] = []
+ for i in kwargs['include_directories']:
+ # bindgen always uses clang, so it's safe to hardcode -I here
+ inc_strs.extend([f'-I{x}' for x in i.to_string_list(state.environment.get_source_dir())])
+
+ if self._bindgen_bin is None:
+ self._bindgen_bin = state.find_program('bindgen')
+
+ name: str
+ if isinstance(header, File):
+ name = header.fname
+ elif isinstance(header, (BuildTarget, BothLibraries, ExtractedObjects)):
+ raise InterpreterException('bindgen source file must be a C header, not an object or build target')
+ else:
+ name = header.get_outputs()[0]
+
+ target = CustomTarget(
+ f'rustmod-bindgen-{name}'.replace('/', '_'),
+ state.subdir,
+ state.subproject,
+ {
+ 'input': header,
+ 'output': kwargs['output'],
+ 'command': self._bindgen_bin.get_command() + [
+ '@INPUT@', '--output',
+ os.path.join(state.environment.build_dir, '@OUTPUT@')] +
+ kwargs['args'] + ['--'] + kwargs['c_args'] + inc_strs +
+ ['-MD', '-MQ', '@INPUT@', '-MF', '@DEPFILE@'],
+ 'depfile': '@PLAINNAME@.d',
+ 'depends': depends,
+ 'depend_files': depend_files,
+ },
+ backend=state.backend,
+ )
+
+ return ModuleReturnValue([target], [target])
+
+
+def initialize(interp: 'Interpreter') -> RustModule:
+ return RustModule(interp)
diff -Nru meson-0.53.2/mesonbuild/modules/unstable_simd.py meson-0.61.2/mesonbuild/modules/unstable_simd.py
--- meson-0.53.2/mesonbuild/modules/unstable_simd.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/unstable_simd.py 2021-08-18 11:22:15.000000000 +0000
@@ -23,7 +23,6 @@
@FeatureNew('SIMD module', '0.42.0')
def __init__(self, interpreter):
super().__init__(interpreter)
- self.snippets.add('check')
# FIXME add Altivec and AVX512.
self.isets = ('mmx',
'sse',
@@ -36,8 +35,11 @@
'avx2',
'neon',
)
+ self.methods.update({
+ 'check': self.check,
+ })
- def check(self, interpreter, state, args, kwargs):
+ def check(self, state, args, kwargs):
result = []
if len(args) != 1:
raise mesonlib.MesonException('Check requires one argument, a name prefix for checks.')
@@ -52,11 +54,11 @@
for key, value in kwargs.items():
if key not in self.isets and key != 'compiler':
basic_kwargs[key] = value
- compiler = kwargs['compiler'].compiler
+ compiler = kwargs['compiler']
if not isinstance(compiler, compilers.compilers.Compiler):
raise mesonlib.MesonException('Compiler argument must be a compiler object.')
- cdata = interpreter.func_configuration_data(None, [], {})
- conf = cdata.held_object
+ cdata = self.interpreter.func_configuration_data(None, [], {})
+ conf = cdata.conf_data
for iset in self.isets:
if iset not in kwargs:
continue
@@ -79,7 +81,7 @@
old_lang_args = mesonlib.extract_as_list(lib_kwargs, langarg_key)
all_lang_args = old_lang_args + args
lib_kwargs[langarg_key] = all_lang_args
- result.append(interpreter.func_static_lib(None, [libname], lib_kwargs))
+ result.append(self.interpreter.func_static_lib(None, [libname], lib_kwargs))
return [result, cdata]
def initialize(*args, **kwargs):
diff -Nru meson-0.53.2/mesonbuild/modules/windows.py meson-0.61.2/mesonbuild/modules/windows.py
--- meson-0.53.2/mesonbuild/modules/windows.py 2019-08-28 17:15:39.000000000 +0000
+++ meson-0.61.2/mesonbuild/modules/windows.py 2021-12-26 16:24:25.000000000 +0000
@@ -15,40 +15,70 @@
import enum
import os
import re
+import typing as T
+
-from .. import mlog
-from .. import mesonlib, build
-from ..mesonlib import MachineChoice, MesonException, extract_as_list
-from . import get_include_args
-from . import ModuleReturnValue
from . import ExtensionModule
-from ..interpreter import CustomTargetHolder
-from ..interpreterbase import permittedKwargs, FeatureNewKwargs, flatten
-from ..dependencies import ExternalProgram
+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):
+ 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):
+ 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):
+ 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 hasattr(self, '_rescomp'):
+ if self._rescomp:
return self._rescomp
# Will try cross / native file and then env var
- rescomp = ExternalProgram.from_bin_list(state.environment.binaries[for_machine], 'windres')
+ 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])
@@ -63,6 +93,7 @@
for (arg, match, rc_type) in [
('/?', '^.*Microsoft.*Resource Compiler.*$', 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)
@@ -75,20 +106,26 @@
return self._rescomp
- @FeatureNewKwargs('windows.compile_resources', '0.47.0', ['depend_files', 'depends'])
- @permittedKwargs({'args', 'include_directories', 'depend_files', 'depends'})
- def compile_resources(self, state, args, kwargs):
- extra_args = mesonlib.stringlistify(flatten(kwargs.get('args', [])))
- wrc_depend_files = extract_as_list(kwargs, 'depend_files', pop = True)
- wrc_depends = extract_as_list(kwargs, 'depends', pop = True)
+ @typed_pos_args('windows.compile_resources', varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex), min_varargs=1)
+ @typed_kwargs(
+ 'winddows.compile_resoures',
+ DEPEND_FILES_KW.evolve(since='0.47.0'),
+ DEPENDS_KW.evolve(since='0.47.0'),
+ INCLUDE_DIRECTORIES.evolve(name='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, CustomTargetHolder):
- extra_args += get_include_args([d.outdir_include()])
- inc_dirs = extract_as_list(kwargs, 'include_directories', pop = True)
- for incd in inc_dirs:
- if not isinstance(incd.held_object, (str, build.IncludeDirs)):
- raise MesonException('Resource include dirs should be include_directories().')
- extra_args += get_include_args(inc_dirs)
+ 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:
@@ -97,7 +134,7 @@
# CVTRES internally to convert this to a COFF object)
suffix = 'res'
res_args = extra_args + ['/nologo', '/fo@OUTPUT@', '@INPUT@']
- else:
+ elif rescomp_type == ResourceCompilerType.windres:
# ld only supports object files, so windres is used to generate a
# COFF object
suffix = 'o'
@@ -107,55 +144,65 @@
'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))
-
- res_targets = []
+ mlog.warning(m.format(arg), fatal=False)
+ else:
+ suffix = 'o'
+ res_args = extra_args + ['@INPUT@', '-o', '@OUTPUT@']
- def add_target(src):
- if isinstance(src, list):
- for subsrc in src:
- add_target(subsrc)
- return
-
- if hasattr(src, 'held_object'):
- src = src.held_object
-
- if isinstance(src, str):
- name_format = 'file {!r}'
- name = os.path.join(state.subdir, src)
- elif isinstance(src, mesonlib.File):
- name_format = 'file {!r}'
- name = src.relative_name()
- elif isinstance(src, build.CustomTarget):
- if len(src.get_outputs()) > 1:
- raise MesonException('windows.compile_resources does not accept custom targets with more than 1 output.')
+ res_targets: T.List[build.CustomTarget] = []
- name_format = 'target {!r}'
- name = src.get_id()
- else:
- raise MesonException('Unexpected source type {!r}. windows.compile_resources accepts only strings, files, custom targets, and lists thereof.'.format(src))
+ 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 indexs 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('\\', '_')
+ 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)
- res_kwargs = {
- 'output': name + '_@BASENAME@.' + suffix,
+ res_kwargs: 'RcKwargs' = {
+ 'output': output,
'input': [src],
- 'command': [rescomp] + res_args,
+ 'depfile': None,
'depend_files': wrc_depend_files,
'depends': wrc_depends,
+ 'command': [],
}
# instruct binutils windres to generate a preprocessor depfile
if rescomp_type == ResourceCompilerType.windres:
- res_kwargs['depfile'] = res_kwargs['output'] + '.d'
- res_kwargs['command'] += ['--preprocessor-arg=-MD', '--preprocessor-arg=-MQ@OUTPUT@', '--preprocessor-arg=-MF@DEPFILE@']
+ res_kwargs['depfile'] = f'{output}.d'
+ command.extend(['--preprocessor-arg=-MD',
+ '--preprocessor-arg=-MQ@OUTPUT@',
+ '--preprocessor-arg=-MF@DEPFILE@'])
- res_targets.append(build.CustomTarget('Windows resource for ' + name_format.format(name), state.subdir, state.subproject, res_kwargs))
+ res_kwargs['command'] = command
- add_target(args)
+ res_targets.append(build.CustomTarget(name_formatted, state.subdir, state.subproject, res_kwargs))
return ModuleReturnValue(res_targets, [res_targets])
-def initialize(*args, **kwargs):
- return WindowsModule(*args, **kwargs)
+def initialize(interp: 'Interpreter') -> WindowsModule:
+ return WindowsModule(interp)
diff -Nru meson-0.53.2/mesonbuild/mparser.py meson-0.61.2/mesonbuild/mparser.py
--- meson-0.53.2/mesonbuild/mparser.py 2019-12-29 22:47:27.000000000 +0000
+++ meson-0.61.2/mesonbuild/mparser.py 2022-01-17 10:50:45.000000000 +0000
@@ -14,10 +14,15 @@
import re
import codecs
+import textwrap
import types
+import typing as T
from .mesonlib import MesonException
from . import mlog
+if T.TYPE_CHECKING:
+ from .ast import AstVisitor
+
# This is the regex for the supported escape sequences of a regular string
# literal, like 'abc\x00'
ESCAPE_SEQUENCE_SINGLE_RE = re.compile(r'''
@@ -30,25 +35,34 @@
)''', re.UNICODE | re.VERBOSE)
class MesonUnicodeDecodeError(MesonException):
- def __init__(self, match):
- super().__init__("%s" % match)
+ def __init__(self, match: str) -> None:
+ super().__init__(match)
self.match = match
-def decode_match(match):
+def decode_match(match: T.Match[str]) -> str:
try:
- return codecs.decode(match.group(0), 'unicode_escape')
+ return codecs.decode(match.group(0).encode(), 'unicode_escape')
except UnicodeDecodeError:
raise MesonUnicodeDecodeError(match.group(0))
class ParseException(MesonException):
- def __init__(self, text, line, lineno, colno):
+ def __init__(self, text: str, line: str, lineno: int, colno: int) -> None:
# Format as error message, followed by the line with the error, followed by a caret to show the error column.
- super().__init__("%s\n%s\n%s" % (text, line, '%s^' % (' ' * colno)))
+ super().__init__("{}\n{}\n{}".format(text, line, '{}^'.format(' ' * colno)))
self.lineno = lineno
self.colno = colno
class BlockParseException(MesonException):
- def __init__(self, text, line, lineno, colno, start_line, start_lineno, start_colno):
+ def __init__(
+ self,
+ text: str,
+ line: str,
+ lineno: int,
+ colno: int,
+ start_line: str,
+ start_lineno: int,
+ start_colno: int,
+ ) -> None:
# This can be formatted in two ways - one if the block start and end are on the same line, and a different way if they are on different lines.
if lineno == start_lineno:
@@ -58,7 +72,7 @@
# Followed by a caret to show the block start
# Followed by underscores
# Followed by a caret to show the block end.
- super().__init__("%s\n%s\n%s" % (text, line, '%s^%s^' % (' ' * start_colno, '_' * (colno - start_colno - 1))))
+ super().__init__("{}\n{}\n{}".format(text, line, '{}^{}^'.format(' ' * start_colno, '_' * (colno - start_colno - 1))))
else:
# If block start and end are on different lines, it is formatted as:
# Error message
@@ -71,23 +85,27 @@
self.lineno = lineno
self.colno = colno
-class Token:
- def __init__(self, tid, subdir, line_start, lineno, colno, bytespan, value):
- self.tid = tid
- self.subdir = subdir
- self.line_start = line_start
- self.lineno = lineno
- self.colno = colno
- self.bytespan = bytespan
- self.value = value
+TV_TokenTypes = T.TypeVar('TV_TokenTypes', int, str, bool)
+
+class Token(T.Generic[TV_TokenTypes]):
+ def __init__(self, tid: str, filename: str, line_start: int, lineno: int, colno: int, bytespan: T.Tuple[int, int], value: TV_TokenTypes):
+ self.tid = tid # type: str
+ self.filename = filename # type: str
+ self.line_start = line_start # type: int
+ self.lineno = lineno # type: int
+ self.colno = colno # type: int
+ self.bytespan = bytespan # type: T.Tuple[int, int]
+ self.value = value # type: TV_TokenTypes
- def __eq__(self, other):
+ def __eq__(self, other: object) -> bool:
if isinstance(other, str):
return self.tid == other
- return self.tid == other.tid
+ elif isinstance(other, Token):
+ return self.tid == other.tid
+ return NotImplemented
class Lexer:
- def __init__(self, code):
+ def __init__(self, code: str):
self.code = code
self.keywords = {'true', 'false', 'if', 'else', 'elif',
'endif', 'and', 'or', 'not', 'foreach', 'endforeach',
@@ -96,6 +114,7 @@
self.token_specification = [
# Need to be sorted longest to shortest.
('ignore', re.compile(r'[ \t]')),
+ ('fstring', re.compile(r"f'([^'\\]|(\\.))*'")),
('id', re.compile('[_a-zA-Z][_0-9a-zA-Z]*')),
('number', re.compile(r'0[bB][01]+|0[oO][0-7]+|0[xX][0-9a-fA-F]+|0|[1-9]\d*')),
('eol_cont', re.compile(r'\\\n')),
@@ -129,10 +148,10 @@
('questionmark', re.compile(r'\?')),
]
- def getline(self, line_start):
+ def getline(self, line_start: int) -> str:
return self.code[line_start:self.code.find('\n', line_start)]
- def lex(self, subdir):
+ def lex(self, filename: str) -> T.Generator[Token, None, None]:
line_start = 0
lineno = 1
loc = 0
@@ -142,7 +161,7 @@
col = 0
while loc < len(self.code):
matched = False
- value = None
+ value = None # type: T.Union[str, bool, int]
for (tid, reg) in self.token_specification:
mo = reg.match(self.code, loc)
if mo:
@@ -171,16 +190,22 @@
curl_count -= 1
elif tid == 'dblquote':
raise ParseException('Double quotes are not supported. Use single quotes.', self.getline(line_start), lineno, col)
- elif tid == 'string':
+ elif tid in {'string', 'fstring'}:
# Handle here and not on the regexp to give a better error message.
if match_text.find("\n") != -1:
- mlog.warning("""Newline character in a string detected, use ''' (three single quotes) for multiline strings instead.
-This will become a hard error in a future Meson release.""", self.getline(line_start), lineno, col)
- value = match_text[1:-1]
+ mlog.warning(textwrap.dedent("""\
+ Newline character in a string detected, use ''' (three single quotes) for multiline strings instead.
+ This will become a hard error in a future Meson release.\
+ """),
+ self.getline(line_start),
+ str(lineno),
+ str(col)
+ )
+ value = match_text[2 if tid == 'fstring' else 1:-1]
try:
value = ESCAPE_SEQUENCE_SINGLE_RE.sub(decode_match, value)
except MesonUnicodeDecodeError as err:
- raise MesonException("Failed to parse escape sequence: '{}' in string:\n {}".format(err.match, match_text))
+ raise MesonException(f"Failed to parse escape sequence: '{err.match}' in string:\n {match_text}")
elif tid == 'multiline_string':
tid = 'string'
value = match_text[3:-3]
@@ -204,260 +229,237 @@
tid = match_text
else:
if match_text in self.future_keywords:
- mlog.warning("Identifier '{}' will become a reserved keyword in a future release. Please rename it.".format(match_text),
- location=types.SimpleNamespace(subdir=subdir, lineno=lineno))
+ mlog.warning(f"Identifier '{match_text}' will become a reserved keyword in a future release. Please rename it.",
+ location=types.SimpleNamespace(filename=filename, lineno=lineno))
value = match_text
- yield Token(tid, subdir, curline_start, curline, col, bytespan, value)
+ yield Token(tid, filename, curline_start, curline, col, bytespan, value)
break
if not matched:
raise ParseException('lexer', self.getline(line_start), lineno, col)
class BaseNode:
- def accept(self, visitor):
+ def __init__(self, lineno: int, colno: int, filename: str, end_lineno: T.Optional[int] = None, end_colno: T.Optional[int] = None):
+ self.lineno = lineno # type: int
+ self.colno = colno # type: int
+ self.filename = filename # type: str
+ self.end_lineno = end_lineno if end_lineno is not None else self.lineno
+ self.end_colno = end_colno if end_colno is not None else self.colno
+
+ # Attributes for the visitors
+ self.level = 0 # type: int
+ self.ast_id = '' # type: str
+ self.condition_level = 0 # type: int
+
+ def accept(self, visitor: 'AstVisitor') -> None:
fname = 'visit_{}'.format(type(self).__name__)
if hasattr(visitor, fname):
func = getattr(visitor, fname)
if callable(func):
func(self)
-class ElementaryNode(BaseNode):
- def __init__(self, token):
- self.lineno = token.lineno
- self.subdir = token.subdir
- self.colno = token.colno
- self.value = token.value
- self.bytespan = token.bytespan
+class ElementaryNode(T.Generic[TV_TokenTypes], BaseNode):
+ def __init__(self, token: Token[TV_TokenTypes]):
+ super().__init__(token.lineno, token.colno, token.filename)
+ self.value = token.value # type: TV_TokenTypes
+ self.bytespan = token.bytespan # type: T.Tuple[int, int]
-class BooleanNode(ElementaryNode):
- def __init__(self, token, value):
+class BooleanNode(ElementaryNode[bool]):
+ def __init__(self, token: Token[bool]):
super().__init__(token)
- self.value = value
- assert(isinstance(self.value, bool))
+ assert isinstance(self.value, bool)
-class IdNode(ElementaryNode):
- def __init__(self, token):
+class IdNode(ElementaryNode[str]):
+ def __init__(self, token: Token[str]):
super().__init__(token)
- assert(isinstance(self.value, str))
+ assert isinstance(self.value, str)
- def __str__(self):
+ def __str__(self) -> str:
return "Id node: '%s' (%d, %d)." % (self.value, self.lineno, self.colno)
-class NumberNode(ElementaryNode):
- def __init__(self, token):
+class NumberNode(ElementaryNode[int]):
+ def __init__(self, token: Token[int]):
super().__init__(token)
- assert(isinstance(self.value, int))
+ assert isinstance(self.value, int)
-class StringNode(ElementaryNode):
- def __init__(self, token):
+class StringNode(ElementaryNode[str]):
+ def __init__(self, token: Token[str]):
super().__init__(token)
- assert(isinstance(self.value, str))
+ assert isinstance(self.value, str)
- def __str__(self):
+ def __str__(self) -> str:
return "String node: '%s' (%d, %d)." % (self.value, self.lineno, self.colno)
+class FormatStringNode(ElementaryNode[str]):
+ def __init__(self, token: Token[str]):
+ super().__init__(token)
+ assert isinstance(self.value, str)
+
+ def __str__(self) -> str:
+ return "Format string node: '{self.value}' ({self.lineno}, {self.colno})."
+
class ContinueNode(ElementaryNode):
pass
class BreakNode(ElementaryNode):
pass
+class ArgumentNode(BaseNode):
+ def __init__(self, token: Token[TV_TokenTypes]):
+ super().__init__(token.lineno, token.colno, token.filename)
+ self.arguments = [] # type: T.List[BaseNode]
+ self.commas = [] # type: T.List[Token[TV_TokenTypes]]
+ self.kwargs = {} # type: T.Dict[BaseNode, BaseNode]
+ self.order_error = False
+
+ def prepend(self, statement: BaseNode) -> None:
+ if self.num_kwargs() > 0:
+ self.order_error = True
+ if not isinstance(statement, EmptyNode):
+ self.arguments = [statement] + self.arguments
+
+ def append(self, statement: BaseNode) -> None:
+ if self.num_kwargs() > 0:
+ self.order_error = True
+ if not isinstance(statement, EmptyNode):
+ self.arguments += [statement]
+
+ def set_kwarg(self, name: IdNode, value: BaseNode) -> None:
+ if any((isinstance(x, IdNode) and name.value == x.value) for x in self.kwargs):
+ mlog.warning(f'Keyword argument "{name.value}" defined multiple times.', location=self)
+ mlog.warning('This will be an error in future Meson releases.')
+ self.kwargs[name] = value
+
+ def set_kwarg_no_check(self, name: BaseNode, value: BaseNode) -> None:
+ self.kwargs[name] = value
+
+ def num_args(self) -> int:
+ return len(self.arguments)
+
+ def num_kwargs(self) -> int:
+ return len(self.kwargs)
+
+ def incorrect_order(self) -> bool:
+ return self.order_error
+
+ def __len__(self) -> int:
+ return self.num_args() # Fixme
+
class ArrayNode(BaseNode):
- def __init__(self, args, lineno, colno, end_lineno, end_colno):
- self.subdir = args.subdir
- self.lineno = lineno
- self.colno = colno
- self.end_lineno = end_lineno
- self.end_colno = end_colno
- self.args = args
+ def __init__(self, args: ArgumentNode, lineno: int, colno: int, end_lineno: int, end_colno: int):
+ super().__init__(lineno, colno, args.filename, end_lineno=end_lineno, end_colno=end_colno)
+ self.args = args # type: ArgumentNode
class DictNode(BaseNode):
- def __init__(self, args, lineno, colno, end_lineno, end_colno):
- self.subdir = args.subdir
- self.lineno = lineno
- self.colno = colno
- self.end_lineno = end_lineno
- self.end_colno = end_colno
+ def __init__(self, args: ArgumentNode, lineno: int, colno: int, end_lineno: int, end_colno: int):
+ super().__init__(lineno, colno, args.filename, end_lineno=end_lineno, end_colno=end_colno)
self.args = args
class EmptyNode(BaseNode):
- def __init__(self, lineno, colno):
- self.subdir = ''
- self.lineno = lineno
- self.colno = colno
+ def __init__(self, lineno: int, colno: int, filename: str):
+ super().__init__(lineno, colno, filename)
self.value = None
class OrNode(BaseNode):
- def __init__(self, left, right):
- self.subdir = left.subdir
- self.lineno = left.lineno
- self.colno = left.colno
- self.left = left
- self.right = right
+ def __init__(self, left: BaseNode, right: BaseNode):
+ super().__init__(left.lineno, left.colno, left.filename)
+ self.left = left # type: BaseNode
+ self.right = right # type: BaseNode
class AndNode(BaseNode):
- def __init__(self, left, right):
- self.subdir = left.subdir
- self.lineno = left.lineno
- self.colno = left.colno
- self.left = left
- self.right = right
+ def __init__(self, left: BaseNode, right: BaseNode):
+ super().__init__(left.lineno, left.colno, left.filename)
+ self.left = left # type: BaseNode
+ self.right = right # type: BaseNode
class ComparisonNode(BaseNode):
- def __init__(self, ctype, left, right):
- self.lineno = left.lineno
- self.colno = left.colno
- self.subdir = left.subdir
- self.left = left
- self.right = right
- self.ctype = ctype
+ def __init__(self, ctype: str, left: BaseNode, right: BaseNode):
+ super().__init__(left.lineno, left.colno, left.filename)
+ self.left = left # type: BaseNode
+ self.right = right # type: BaseNode
+ self.ctype = ctype # type: str
class ArithmeticNode(BaseNode):
- def __init__(self, operation, left, right):
- self.subdir = left.subdir
- self.lineno = left.lineno
- self.colno = left.colno
- self.left = left
- self.right = right
- self.operation = operation
+ def __init__(self, operation: str, left: BaseNode, right: BaseNode):
+ super().__init__(left.lineno, left.colno, left.filename)
+ self.left = left # type: BaseNode
+ self.right = right # type: BaseNode
+ self.operation = operation # type: str
class NotNode(BaseNode):
- def __init__(self, location_node, value):
- self.subdir = location_node.subdir
- self.lineno = location_node.lineno
- self.colno = location_node.colno
- self.value = value
+ def __init__(self, token: Token[TV_TokenTypes], value: BaseNode):
+ super().__init__(token.lineno, token.colno, token.filename)
+ self.value = value # type: BaseNode
class CodeBlockNode(BaseNode):
- def __init__(self, location_node):
- self.subdir = location_node.subdir
- self.lineno = location_node.lineno
- self.colno = location_node.colno
- self.lines = []
+ def __init__(self, token: Token[TV_TokenTypes]):
+ super().__init__(token.lineno, token.colno, token.filename)
+ self.lines = [] # type: T.List[BaseNode]
class IndexNode(BaseNode):
- def __init__(self, iobject, index):
- self.iobject = iobject
- self.index = index
- self.subdir = iobject.subdir
- self.lineno = iobject.lineno
- self.colno = iobject.colno
+ def __init__(self, iobject: BaseNode, index: BaseNode):
+ super().__init__(iobject.lineno, iobject.colno, iobject.filename)
+ self.iobject = iobject # type: BaseNode
+ self.index = index # type: BaseNode
class MethodNode(BaseNode):
- def __init__(self, subdir, lineno, colno, source_object, name, args):
- self.subdir = subdir
- self.lineno = lineno
- self.colno = colno
- self.source_object = source_object
- self.name = name
- assert(isinstance(self.name, str))
- self.args = args
+ def __init__(self, filename: str, lineno: int, colno: int, source_object: BaseNode, name: str, args: ArgumentNode):
+ super().__init__(lineno, colno, filename)
+ self.source_object = source_object # type: BaseNode
+ self.name = name # type: str
+ assert isinstance(self.name, str)
+ self.args = args # type: ArgumentNode
class FunctionNode(BaseNode):
- def __init__(self, subdir, lineno, colno, end_lineno, end_colno, func_name, args):
- self.subdir = subdir
- self.lineno = lineno
- self.colno = colno
- self.end_lineno = end_lineno
- self.end_colno = end_colno
- self.func_name = func_name
- assert(isinstance(func_name, str))
- self.args = args
+ def __init__(self, filename: str, lineno: int, colno: int, end_lineno: int, end_colno: int, func_name: str, args: ArgumentNode):
+ super().__init__(lineno, colno, filename, end_lineno=end_lineno, end_colno=end_colno)
+ self.func_name = func_name # type: str
+ assert isinstance(func_name, str)
+ self.args = args # type: ArgumentNode
class AssignmentNode(BaseNode):
- def __init__(self, subdir, lineno, colno, var_name, value):
- self.subdir = subdir
- self.lineno = lineno
- self.colno = colno
- self.var_name = var_name
- assert(isinstance(var_name, str))
- self.value = value
+ def __init__(self, filename: str, lineno: int, colno: int, var_name: str, value: BaseNode):
+ super().__init__(lineno, colno, filename)
+ self.var_name = var_name # type: str
+ assert isinstance(var_name, str)
+ self.value = value # type: BaseNode
class PlusAssignmentNode(BaseNode):
- def __init__(self, subdir, lineno, colno, var_name, value):
- self.subdir = subdir
- self.lineno = lineno
- self.colno = colno
- self.var_name = var_name
- assert(isinstance(var_name, str))
- self.value = value
+ def __init__(self, filename: str, lineno: int, colno: int, var_name: str, value: BaseNode):
+ super().__init__(lineno, colno, filename)
+ self.var_name = var_name # type: str
+ assert isinstance(var_name, str)
+ self.value = value # type: BaseNode
class ForeachClauseNode(BaseNode):
- def __init__(self, lineno, colno, varnames, items, block):
- self.lineno = lineno
- self.colno = colno
- self.varnames = varnames
- self.items = items
- self.block = block
+ def __init__(self, token: Token, varnames: T.List[str], items: BaseNode, block: CodeBlockNode):
+ super().__init__(token.lineno, token.colno, token.filename)
+ self.varnames = varnames # type: T.List[str]
+ self.items = items # type: BaseNode
+ self.block = block # type: CodeBlockNode
+
+class IfNode(BaseNode):
+ def __init__(self, linenode: BaseNode, condition: BaseNode, block: CodeBlockNode):
+ super().__init__(linenode.lineno, linenode.colno, linenode.filename)
+ self.condition = condition # type: BaseNode
+ self.block = block # type: CodeBlockNode
class IfClauseNode(BaseNode):
- def __init__(self, lineno, colno):
- self.lineno = lineno
- self.colno = colno
- self.ifs = []
- self.elseblock = EmptyNode(lineno, colno)
+ def __init__(self, linenode: BaseNode):
+ super().__init__(linenode.lineno, linenode.colno, linenode.filename)
+ self.ifs = [] # type: T.List[IfNode]
+ self.elseblock = None # type: T.Union[EmptyNode, CodeBlockNode]
class UMinusNode(BaseNode):
- def __init__(self, current_location, value):
- self.subdir = current_location.subdir
- self.lineno = current_location.lineno
- self.colno = current_location.colno
- self.value = value
-
-class IfNode(BaseNode):
- def __init__(self, lineno, colno, condition, block):
- self.lineno = lineno
- self.colno = colno
- self.condition = condition
- self.block = block
+ def __init__(self, current_location: Token, value: BaseNode):
+ super().__init__(current_location.lineno, current_location.colno, current_location.filename)
+ self.value = value # type: BaseNode
class TernaryNode(BaseNode):
- def __init__(self, subdir, lineno, colno, condition, trueblock, falseblock):
- self.subdir = subdir
- self.lineno = lineno
- self.colno = colno
- self.condition = condition
- self.trueblock = trueblock
- self.falseblock = falseblock
-
-class ArgumentNode(BaseNode):
- def __init__(self, token):
- self.lineno = token.lineno
- self.colno = token.colno
- self.subdir = token.subdir
- self.arguments = []
- self.commas = []
- self.kwargs = {}
- self.order_error = False
-
- def prepend(self, statement):
- if self.num_kwargs() > 0:
- self.order_error = True
- if not isinstance(statement, EmptyNode):
- self.arguments = [statement] + self.arguments
-
- def append(self, statement):
- if self.num_kwargs() > 0:
- self.order_error = True
- if not isinstance(statement, EmptyNode):
- self.arguments += [statement]
-
- def set_kwarg(self, name, value):
- if name in self.kwargs:
- mlog.warning('Keyword argument "{}" defined multiple times.'.format(name), location=self)
- mlog.warning('This will be an error in future Meson releases.')
- self.kwargs[name] = value
-
- def num_args(self):
- return len(self.arguments)
-
- def num_kwargs(self):
- return len(self.kwargs)
-
- def incorrect_order(self):
- return self.order_error
-
- def __len__(self):
- return self.num_args() # Fixme
+ def __init__(self, condition: BaseNode, trueblock: BaseNode, falseblock: BaseNode):
+ super().__init__(condition.lineno, condition.colno, condition.filename)
+ self.condition = condition # type: BaseNode
+ self.trueblock = trueblock # type: BaseNode
+ self.falseblock = falseblock # type: BaseNode
comparison_map = {'equal': '==',
'nequal': '!=',
@@ -485,59 +487,68 @@
# 9 plain token
class Parser:
- def __init__(self, code, subdir):
+ def __init__(self, code: str, filename: str):
self.lexer = Lexer(code)
- self.stream = self.lexer.lex(subdir)
- self.current = Token('eof', '', 0, 0, 0, (0, 0), None)
+ self.stream = self.lexer.lex(filename)
+ self.current = Token('eof', '', 0, 0, 0, (0, 0), None) # type: Token
self.getsym()
self.in_ternary = False
- def getsym(self):
+ def getsym(self) -> None:
try:
self.current = next(self.stream)
except StopIteration:
self.current = Token('eof', '', self.current.line_start, self.current.lineno, self.current.colno + self.current.bytespan[1] - self.current.bytespan[0], (0, 0), None)
- def getline(self):
+ def getline(self) -> str:
return self.lexer.getline(self.current.line_start)
- def accept(self, s):
+ def accept(self, s: str) -> bool:
if self.current.tid == s:
self.getsym()
return True
return False
- def expect(self, s):
+ def accept_any(self, tids: T.Sequence[str]) -> str:
+ tid = self.current.tid
+ if tid in tids:
+ self.getsym()
+ return tid
+ return ''
+
+ def expect(self, s: str) -> bool:
if self.accept(s):
return True
- raise ParseException('Expecting %s got %s.' % (s, self.current.tid), self.getline(), self.current.lineno, self.current.colno)
+ raise ParseException(f'Expecting {s} got {self.current.tid}.', self.getline(), self.current.lineno, self.current.colno)
- def block_expect(self, s, block_start):
+ def block_expect(self, s: str, block_start: Token) -> bool:
if self.accept(s):
return True
- raise BlockParseException('Expecting %s got %s.' % (s, self.current.tid), self.getline(), self.current.lineno, self.current.colno, self.lexer.getline(block_start.line_start), block_start.lineno, block_start.colno)
+ raise BlockParseException(f'Expecting {s} got {self.current.tid}.', self.getline(), self.current.lineno, self.current.colno, self.lexer.getline(block_start.line_start), block_start.lineno, block_start.colno)
- def parse(self):
+ def parse(self) -> CodeBlockNode:
block = self.codeblock()
self.expect('eof')
return block
- def statement(self):
+ def statement(self) -> BaseNode:
return self.e1()
- def e1(self):
+ def e1(self) -> BaseNode:
left = self.e2()
if self.accept('plusassign'):
value = self.e1()
if not isinstance(left, IdNode):
raise ParseException('Plusassignment target must be an id.', self.getline(), left.lineno, left.colno)
- return PlusAssignmentNode(left.subdir, left.lineno, left.colno, left.value, value)
+ assert isinstance(left.value, str)
+ return PlusAssignmentNode(left.filename, left.lineno, left.colno, left.value, value)
elif self.accept('assign'):
value = self.e1()
if not isinstance(left, IdNode):
raise ParseException('Assignment target must be an id.',
self.getline(), left.lineno, left.colno)
- return AssignmentNode(left.subdir, left.lineno, left.colno, left.value, value)
+ assert isinstance(left.value, str)
+ return AssignmentNode(left.filename, left.lineno, left.colno, left.value, value)
elif self.accept('questionmark'):
if self.in_ternary:
raise ParseException('Nested ternary operators are not allowed.',
@@ -547,10 +558,10 @@
self.expect('colon')
falseblock = self.e1()
self.in_ternary = False
- return TernaryNode(left.subdir, left.lineno, left.colno, left, trueblock, falseblock)
+ return TernaryNode(left, trueblock, falseblock)
return left
- def e2(self):
+ def e2(self) -> BaseNode:
left = self.e3()
while self.accept('or'):
if isinstance(left, EmptyNode):
@@ -559,7 +570,7 @@
left = OrNode(left, self.e3())
return left
- def e3(self):
+ def e3(self) -> BaseNode:
left = self.e4()
while self.accept('and'):
if isinstance(left, EmptyNode):
@@ -568,7 +579,7 @@
left = AndNode(left, self.e4())
return left
- def e4(self):
+ def e4(self) -> BaseNode:
left = self.e5()
for nodename, operator_type in comparison_map.items():
if self.accept(nodename):
@@ -577,47 +588,46 @@
return ComparisonNode('notin', left, self.e5())
return left
- def e5(self):
- return self.e5add()
+ def e5(self) -> BaseNode:
+ return self.e5addsub()
- def e5add(self):
- left = self.e5sub()
- if self.accept('plus'):
- return ArithmeticNode('add', left, self.e5add())
- return left
-
- def e5sub(self):
- left = self.e5mod()
- if self.accept('dash'):
- return ArithmeticNode('sub', left, self.e5sub())
- return left
-
- def e5mod(self):
- left = self.e5mul()
- if self.accept('percent'):
- return ArithmeticNode('mod', left, self.e5mod())
- return left
-
- def e5mul(self):
- left = self.e5div()
- if self.accept('star'):
- return ArithmeticNode('mul', left, self.e5mul())
+ def e5addsub(self) -> BaseNode:
+ op_map = {
+ 'plus': 'add',
+ 'dash': 'sub',
+ }
+ left = self.e5muldiv()
+ while True:
+ op = self.accept_any(tuple(op_map.keys()))
+ if op:
+ left = ArithmeticNode(op_map[op], left, self.e5muldiv())
+ else:
+ break
return left
- def e5div(self):
+ def e5muldiv(self) -> BaseNode:
+ op_map = {
+ 'percent': 'mod',
+ 'star': 'mul',
+ 'fslash': 'div',
+ }
left = self.e6()
- if self.accept('fslash'):
- return ArithmeticNode('div', left, self.e5div())
+ while True:
+ op = self.accept_any(tuple(op_map.keys()))
+ if op:
+ left = ArithmeticNode(op_map[op], left, self.e6())
+ else:
+ break
return left
- def e6(self):
+ def e6(self) -> BaseNode:
if self.accept('not'):
return NotNode(self.current, self.e7())
if self.accept('dash'):
return UMinusNode(self.current, self.e7())
return self.e7()
- def e7(self):
+ def e7(self) -> BaseNode:
left = self.e8()
block_start = self.current
if self.accept('lparen'):
@@ -626,7 +636,8 @@
if not isinstance(left, IdNode):
raise ParseException('Function call must be applied to plain id',
self.getline(), left.lineno, left.colno)
- left = FunctionNode(left.subdir, left.lineno, left.colno, self.current.lineno, self.current.colno, left.value, args)
+ assert isinstance(left.value, str)
+ left = FunctionNode(left.filename, left.lineno, left.colno, self.current.lineno, self.current.colno, left.value, args)
go_again = True
while go_again:
go_again = False
@@ -638,7 +649,7 @@
left = self.index_call(left)
return left
- def e8(self):
+ def e8(self) -> BaseNode:
block_start = self.current
if self.accept('lparen'):
e = self.statement()
@@ -655,27 +666,31 @@
else:
return self.e9()
- def e9(self):
+ def e9(self) -> BaseNode:
t = self.current
if self.accept('true'):
- return BooleanNode(t, True)
+ t.value = True
+ return BooleanNode(t)
if self.accept('false'):
- return BooleanNode(t, False)
+ t.value = False
+ return BooleanNode(t)
if self.accept('id'):
return IdNode(t)
if self.accept('number'):
return NumberNode(t)
if self.accept('string'):
return StringNode(t)
- return EmptyNode(self.current.lineno, self.current.colno)
-
- def key_values(self):
- s = self.statement()
- a = ArgumentNode(s)
+ if self.accept('fstring'):
+ return FormatStringNode(t)
+ return EmptyNode(self.current.lineno, self.current.colno, self.current.filename)
+
+ def key_values(self) -> ArgumentNode:
+ s = self.statement() # type: BaseNode
+ a = ArgumentNode(self.current)
while not isinstance(s, EmptyNode):
if self.accept('colon'):
- a.set_kwarg(s, self.statement())
+ a.set_kwarg_no_check(s, self.statement())
potential = self.current
if not self.accept('comma'):
return a
@@ -686,9 +701,9 @@
s = self.statement()
return a
- def args(self):
- s = self.statement()
- a = ArgumentNode(s)
+ def args(self) -> ArgumentNode:
+ s = self.statement() # type: BaseNode
+ a = ArgumentNode(self.current)
while not isinstance(s, EmptyNode):
potential = self.current
@@ -699,7 +714,7 @@
if not isinstance(s, IdNode):
raise ParseException('Dictionary key must be a plain identifier.',
self.getline(), s.lineno, s.colno)
- a.set_kwarg(s.value, self.statement())
+ a.set_kwarg(s, self.statement())
potential = self.current
if not self.accept('comma'):
return a
@@ -710,81 +725,85 @@
s = self.statement()
return a
- def method_call(self, source_object):
+ def method_call(self, source_object: BaseNode) -> MethodNode:
methodname = self.e9()
- if not(isinstance(methodname, IdNode)):
+ if not isinstance(methodname, IdNode):
raise ParseException('Method name must be plain id',
self.getline(), self.current.lineno, self.current.colno)
+ assert isinstance(methodname.value, str)
self.expect('lparen')
args = self.args()
self.expect('rparen')
- method = MethodNode(methodname.subdir, methodname.lineno, methodname.colno, source_object, methodname.value, args)
+ method = MethodNode(methodname.filename, methodname.lineno, methodname.colno, source_object, methodname.value, args)
if self.accept('dot'):
return self.method_call(method)
return method
- def index_call(self, source_object):
+ def index_call(self, source_object: BaseNode) -> IndexNode:
index_statement = self.statement()
self.expect('rbracket')
return IndexNode(source_object, index_statement)
- def foreachblock(self):
+ def foreachblock(self) -> ForeachClauseNode:
t = self.current
self.expect('id')
+ assert isinstance(t.value, str)
varname = t
- varnames = [t]
+ varnames = [t.value] # type: T.List[str]
if self.accept('comma'):
t = self.current
self.expect('id')
- varnames.append(t)
+ assert isinstance(t.value, str)
+ varnames.append(t.value)
self.expect('colon')
items = self.statement()
block = self.codeblock()
- return ForeachClauseNode(varname.lineno, varname.colno, varnames, items, block)
+ return ForeachClauseNode(varname, varnames, items, block)
- def ifblock(self):
+ def ifblock(self) -> IfClauseNode:
condition = self.statement()
- clause = IfClauseNode(condition.lineno, condition.colno)
+ clause = IfClauseNode(condition)
self.expect('eol')
block = self.codeblock()
- clause.ifs.append(IfNode(clause.lineno, clause.colno, condition, block))
+ clause.ifs.append(IfNode(clause, condition, block))
self.elseifblock(clause)
clause.elseblock = self.elseblock()
return clause
- def elseifblock(self, clause):
+ def elseifblock(self, clause: IfClauseNode) -> None:
while self.accept('elif'):
s = self.statement()
self.expect('eol')
b = self.codeblock()
- clause.ifs.append(IfNode(s.lineno, s.colno, s, b))
+ clause.ifs.append(IfNode(s, s, b))
- def elseblock(self):
+ def elseblock(self) -> T.Union[CodeBlockNode, EmptyNode]:
if self.accept('else'):
self.expect('eol')
return self.codeblock()
+ return EmptyNode(self.current.lineno, self.current.colno, self.current.filename)
- def line(self):
+ def line(self) -> BaseNode:
block_start = self.current
if self.current == 'eol':
- return EmptyNode(self.current.lineno, self.current.colno)
+ return EmptyNode(self.current.lineno, self.current.colno, self.current.filename)
if self.accept('if'):
- block = self.ifblock()
+ ifblock = self.ifblock()
self.block_expect('endif', block_start)
- return block
+ return ifblock
if self.accept('foreach'):
- block = self.foreachblock()
+ forblock = self.foreachblock()
self.block_expect('endforeach', block_start)
- return block
+ return forblock
if self.accept('continue'):
return ContinueNode(self.current)
if self.accept('break'):
return BreakNode(self.current)
return self.statement()
- def codeblock(self):
+ def codeblock(self) -> CodeBlockNode:
block = CodeBlockNode(self.current)
cond = True
while cond:
diff -Nru meson-0.53.2/mesonbuild/msetup.py meson-0.61.2/mesonbuild/msetup.py
--- meson-0.53.2/mesonbuild/msetup.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/msetup.py 2021-11-02 19:58:07.000000000 +0000
@@ -28,10 +28,19 @@
from . import build
from . import mlog, coredata
from . import mintro
-from .mconf import make_lower_case
from .mesonlib import MesonException
-def add_arguments(parser):
+git_ignore_file = '''# This file is autogenerated by Meson. If you change or delete it, it won't be recreated.
+*
+'''
+
+hg_ignore_file = '''# This file is autogenerated by Meson. If you change or delete it, it won't be recreated.
+syntax: glob
+**/*
+'''
+
+
+def add_arguments(parser: argparse.ArgumentParser) -> None:
coredata.register_builtin_arguments(parser)
parser.add_argument('--native-file',
default=[],
@@ -41,6 +50,10 @@
default=[],
action='append',
help='File describing cross compilation environment.')
+ parser.add_argument('--vsenv', action='store_true',
+ help='Setup Visual Studio environment even when other compilers are found, ' +
+ 'abort if Visual Studio is not found. This option has no effect on other ' +
+ 'platforms than Windows. Defaults to True when using "vs" backend.')
parser.add_argument('-v', '--version', action='version',
version=coredata.version)
parser.add_argument('--profile-self', action='store_true', dest='profile',
@@ -53,13 +66,13 @@
'is not working.')
parser.add_argument('--wipe', action='store_true',
help='Wipe build directory and reconfigure using previous command line options. ' +
- 'Userful when build directory got corrupted, or when rebuilding with a ' +
+ 'Useful when build directory got corrupted, or when rebuilding with a ' +
'newer version of meson.')
parser.add_argument('builddir', nargs='?', default=None)
parser.add_argument('sourcedir', nargs='?', default=None)
class MesonApp:
- def __init__(self, options):
+ def __init__(self, options: argparse.Namespace) -> None:
(self.source_dir, self.build_dir) = self.validate_dirs(options.builddir,
options.sourcedir,
options.reconfigure,
@@ -86,11 +99,12 @@
# will cause a crash
for l in os.listdir(self.build_dir):
l = os.path.join(self.build_dir, l)
- if os.path.isdir(l):
+ if os.path.isdir(l) and not os.path.islink(l):
mesonlib.windows_proof_rmtree(l)
else:
mesonlib.windows_proof_rm(l)
finally:
+ self.add_vcs_ignore_files(self.build_dir)
for b, f in restore:
os.makedirs(os.path.dirname(f), exist_ok=True)
shutil.move(b, f)
@@ -118,21 +132,33 @@
if not os.path.exists(ndir2):
os.makedirs(ndir2)
if not stat.S_ISDIR(os.stat(ndir1).st_mode):
- raise MesonException('%s is not a directory' % dir1)
+ raise MesonException(f'{dir1} is not a directory')
if not stat.S_ISDIR(os.stat(ndir2).st_mode):
- raise MesonException('%s is not a directory' % dir2)
- if os.path.samefile(dir1, dir2):
- raise MesonException('Source and build directories must not be the same. Create a pristine build directory.')
+ raise MesonException(f'{dir2} is not a directory')
+ if os.path.samefile(ndir1, ndir2):
+ # Fallback to textual compare if undefined entries found
+ has_undefined = any((s.st_ino == 0 and s.st_dev == 0) for s in (os.stat(ndir1), os.stat(ndir2)))
+ if not has_undefined or ndir1 == ndir2:
+ raise MesonException('Source and build directories must not be the same. Create a pristine build directory.')
if self.has_build_file(ndir1):
if self.has_build_file(ndir2):
- raise MesonException('Both directories contain a build file %s.' % environment.build_filename)
+ raise MesonException(f'Both directories contain a build file {environment.build_filename}.')
return ndir1, ndir2
if self.has_build_file(ndir2):
return ndir2, ndir1
- raise MesonException('Neither directory contains a build file %s.' % environment.build_filename)
+ raise MesonException(f'Neither directory contains a build file {environment.build_filename}.')
+
+ def add_vcs_ignore_files(self, build_dir: str) -> None:
+ if os.listdir(build_dir):
+ return
+ with open(os.path.join(build_dir, '.gitignore'), 'w', encoding='utf-8') as ofile:
+ ofile.write(git_ignore_file)
+ with open(os.path.join(build_dir, '.hgignore'), 'w', encoding='utf-8') as ofile:
+ ofile.write(hg_ignore_file)
def validate_dirs(self, dir1: str, dir2: str, reconfigure: bool, wipe: bool) -> T.Tuple[str, str]:
(src_dir, build_dir) = self.validate_core_dirs(dir1, dir2)
+ self.add_vcs_ignore_files(build_dir)
priv_dir = os.path.join(build_dir, 'meson-private/coredata.dat')
if os.path.exists(priv_dir):
if not reconfigure and not wipe:
@@ -147,10 +173,10 @@
else:
has_cmd_line_file = os.path.exists(coredata.get_cmd_line_file(build_dir))
if (wipe and not has_cmd_line_file) or (not wipe and reconfigure):
- raise SystemExit('Directory does not contain a valid build tree:\n{}'.format(build_dir))
+ raise SystemExit(f'Directory does not contain a valid build tree:\n{build_dir}')
return src_dir, build_dir
- def generate(self):
+ def generate(self) -> None:
env = environment.Environment(self.source_dir, self.build_dir, self.options)
mlog.initialize(env.get_log_dir(), self.options.fatal_warnings)
if self.options.profile:
@@ -158,10 +184,15 @@
with mesonlib.BuildDirLock(self.build_dir):
self._generate(env)
- def _generate(self, env):
+ def _generate(self, env: environment.Environment) -> None:
+ # Get all user defined options, including options that have been defined
+ # during a previous invocation or using meson configure.
+ user_defined_options = argparse.Namespace(**vars(self.options))
+ coredata.read_cmd_line_file(self.build_dir, user_defined_options)
+
mlog.debug('Build started at', datetime.datetime.now().isoformat())
mlog.debug('Main binary:', sys.executable)
- mlog.debug('Build Options:', coredata.get_cmd_line_options(self.build_dir, self.options))
+ mlog.debug('Build Options:', coredata.format_cmd_line_options(user_defined_options))
mlog.debug('Python system:', platform.system())
mlog.log(mlog.bold('The Meson build system'))
mlog.log('Version:', coredata.version)
@@ -173,17 +204,23 @@
mlog.log('Build type:', mlog.bold('native build'))
b = build.Build(env)
- intr = interpreter.Interpreter(b)
+ intr = interpreter.Interpreter(b, user_defined_options=user_defined_options)
if env.is_cross_build():
logger_fun = mlog.log
else:
logger_fun = mlog.debug
- logger_fun('Build machine cpu family:', mlog.bold(intr.builtin['build_machine'].cpu_family_method([], {})))
- logger_fun('Build machine cpu:', mlog.bold(intr.builtin['build_machine'].cpu_method([], {})))
- mlog.log('Host machine cpu family:', mlog.bold(intr.builtin['host_machine'].cpu_family_method([], {})))
- mlog.log('Host machine cpu:', mlog.bold(intr.builtin['host_machine'].cpu_method([], {})))
- logger_fun('Target machine cpu family:', mlog.bold(intr.builtin['target_machine'].cpu_family_method([], {})))
- logger_fun('Target machine cpu:', mlog.bold(intr.builtin['target_machine'].cpu_method([], {})))
+ build_machine = intr.builtin['build_machine']
+ host_machine = intr.builtin['host_machine']
+ target_machine = intr.builtin['target_machine']
+ assert isinstance(build_machine, interpreter.MachineHolder)
+ assert isinstance(host_machine, interpreter.MachineHolder)
+ assert isinstance(target_machine, interpreter.MachineHolder)
+ logger_fun('Build machine cpu family:', mlog.bold(build_machine.cpu_family_method([], {})))
+ logger_fun('Build machine cpu:', mlog.bold(build_machine.cpu_method([], {})))
+ mlog.log('Host machine cpu family:', mlog.bold(host_machine.cpu_family_method([], {})))
+ mlog.log('Host machine cpu:', mlog.bold(host_machine.cpu_method([], {})))
+ logger_fun('Target machine cpu family:', mlog.bold(target_machine.cpu_family_method([], {})))
+ logger_fun('Target machine cpu:', mlog.bold(target_machine.cpu_method([], {})))
try:
if self.options.profile:
fname = os.path.join(self.build_dir, 'meson-private', 'profile-interpreter.log')
@@ -193,11 +230,6 @@
except Exception as e:
mintro.write_meson_info_file(b, [e])
raise
- # Print all default option values that don't match the current value
- for def_opt_name, def_opt_value, cur_opt_value in intr.get_non_matching_default_options():
- mlog.log('Option', mlog.bold(def_opt_name), 'is:',
- mlog.bold('{}'.format(make_lower_case(cur_opt_value.printable_value()))),
- '[default: {}]'.format(make_lower_case(def_opt_value)))
try:
dumpfile = os.path.join(env.get_scratch_dir(), 'build.dat')
# We would like to write coredata as late as possible since we use the existence of
@@ -208,13 +240,18 @@
# possible, but before build files, and if any error occurs, delete it.
cdf = env.dump_coredata()
if self.options.profile:
- fname = 'profile-{}-backend.log'.format(intr.backend.name)
+ fname = f'profile-{intr.backend.name}-backend.log'
fname = os.path.join(self.build_dir, 'meson-private', fname)
- profile.runctx('intr.backend.generate(intr)', globals(), locals(), filename=fname)
+ profile.runctx('intr.backend.generate()', globals(), locals(), filename=fname)
else:
- intr.backend.generate(intr)
+ intr.backend.generate()
+ b.devenv.append(intr.backend.get_devenv())
build.save(b, dumpfile)
if env.first_invocation:
+ # Use path resolved by coredata because they could have been
+ # read from a pipe and wrote into a private file.
+ self.options.cross_file = env.coredata.cross_files
+ self.options.native_file = env.coredata.config_files
coredata.write_cmd_line_file(self.build_dir, self.options)
else:
coredata.update_cmd_line_file(self.build_dir, self.options)
@@ -229,6 +266,18 @@
# Post-conf scripts must be run after writing coredata or else introspection fails.
intr.backend.run_postconf_scripts()
+
+ # collect warnings about unsupported build configurations; must be done after full arg processing
+ # by Interpreter() init, but this is most visible at the end
+ if env.coredata.options[mesonlib.OptionKey('backend')].value == 'xcode':
+ mlog.warning('xcode backend is currently unmaintained, patches welcome')
+ if env.coredata.options[mesonlib.OptionKey('layout')].value == 'flat':
+ mlog.warning('-Dlayout=flat is unsupported and probably broken. It was a failed experiment at '
+ 'making Windows build artifacts runnable while uninstalled, due to PATH considerations, '
+ 'but was untested by CI and anyways breaks reasonable use of conflicting targets in different subdirs. '
+ 'Please consider using `meson devenv` instead. See https://github.com/mesonbuild/meson/pull/9243 '
+ 'for details.')
+
except Exception as e:
mintro.write_meson_info_file(b, [e])
if 'cdf' in locals():
@@ -239,7 +288,7 @@
os.unlink(cdf)
raise
-def run(options) -> int:
+def run(options: argparse.Namespace) -> int:
coredata.parse_cmd_line_options(options)
app = MesonApp(options)
app.generate()
diff -Nru meson-0.53.2/mesonbuild/msubprojects.py meson-0.61.2/mesonbuild/msubprojects.py
--- meson-0.53.2/mesonbuild/msubprojects.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/msubprojects.py 2022-01-17 10:50:45.000000000 +0000
@@ -1,206 +1,593 @@
import os, subprocess
import argparse
+import asyncio
+import threading
+import copy
+import shutil
+from concurrent.futures.thread import ThreadPoolExecutor
+from pathlib import Path
+import typing as T
+import tarfile
+import zipfile
from . import mlog
-from .mesonlib import git, Popen_safe
-from .wrap.wrap import API_ROOT, PackageDefinition, Resolver, WrapException
+from .mesonlib import quiet_git, GitException, Popen_safe, MesonException, windows_proof_rmtree
+from .wrap.wrap import PackageDefinition, Resolver, WrapException, ALL_TYPES
from .wrap import wraptool
-def update_wrapdb_file(wrap, repo_dir, options):
- patch_url = wrap.get('patch_url')
- branch, revision = wraptool.parse_patch_url(patch_url)
- new_branch, new_revision = wraptool.get_latest_version(wrap.name)
- if new_branch == branch and new_revision == revision:
- mlog.log(' -> Up to date.')
- return
- wraptool.update_wrap_file(wrap.filename, wrap.name, new_branch, new_revision)
- msg = [' -> New wrap file downloaded.']
- # Meson reconfigure won't use the new wrap file as long as the source
- # directory exists. We don't delete it ourself to avoid data loss in case
- # user has changes in their copy.
- if os.path.isdir(repo_dir):
- msg += ['To use it, delete', mlog.bold(repo_dir), 'and run', mlog.bold('meson --reconfigure')]
- mlog.log(*msg)
-
-def update_file(wrap, repo_dir, options):
- patch_url = wrap.values.get('patch_url', '')
- if patch_url.startswith(API_ROOT):
- update_wrapdb_file(wrap, repo_dir, options)
- elif not os.path.isdir(repo_dir):
- # The subproject is not needed, or it is a tarball extracted in
- # 'libfoo-1.0' directory and the version has been bumped and the new
- # directory is 'libfoo-2.0'. In that case forcing a meson
- # reconfigure will download and use the new tarball.
- mlog.log(' -> Subproject has not been checked out. Run', mlog.bold('meson --reconfigure'), 'to fetch it if needed.')
+if T.TYPE_CHECKING:
+ from typing_extensions import Protocol
+
+ class Arguments(Protocol):
+ sourcedir: str
+ num_processes: int
+ subprojects: T.List[str]
+ types: str
+ subprojects_func: T.Callable[[], bool]
+
+ class UpdateArguments(Arguments):
+ rebase: bool
+ reset: bool
+
+ class CheckoutArguments(Arguments):
+ b: bool
+ branch_name: str
+
+ class ForeachArguments(Arguments):
+ command: str
+ args: T.List[str]
+
+ class PurgeArguments(Arguments):
+ confirm: bool
+ include_cache: bool
+
+ class PackagefilesArguments(Arguments):
+ apply: bool
+ save: bool
+
+ALL_TYPES_STRING = ', '.join(ALL_TYPES)
+
+def read_archive_files(path: Path, base_path: Path) -> T.Set[Path]:
+ if path.suffix == '.zip':
+ with zipfile.ZipFile(path, 'r') as zip_archive:
+ archive_files = set(base_path / i.filename for i in zip_archive.infolist())
else:
- # The subproject has not changed, or the new source and/or patch
- # tarballs should be extracted in the same directory than previous
- # version.
- mlog.log(' -> Subproject has not changed, or the new source/patch needs to be extracted on the same location.\n' +
- ' In that case, delete', mlog.bold(repo_dir), 'and run', mlog.bold('meson --reconfigure'))
-
-def git_output(cmd, workingdir):
- return git(cmd, workingdir, check=True, universal_newlines=True,
- stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout
-
-def git_show(repo_dir):
- commit_message = git_output(['show', '--quiet', '--pretty=format:%h%n%d%n%s%n[%an]'], repo_dir)
- parts = [s.strip() for s in commit_message.split('\n')]
- mlog.log(' ->', mlog.yellow(parts[0]), mlog.red(parts[1]), parts[2], mlog.blue(parts[3]))
-
-def update_git(wrap, repo_dir, options):
- if not os.path.isdir(repo_dir):
- mlog.log(' -> Not used.')
- return
- revision = wrap.get('revision')
- ret = git_output(['rev-parse', '--abbrev-ref', 'HEAD'], repo_dir).strip()
- if ret == 'HEAD':
- try:
- # We are currently in detached mode, just checkout the new revision
- git_output(['fetch'], repo_dir)
- git_output(['checkout', revision], repo_dir)
- except subprocess.CalledProcessError as e:
- out = e.output.decode().strip()
- mlog.log(' -> Could not checkout revision', mlog.cyan(revision))
- mlog.log(mlog.red(out))
- mlog.log(mlog.red(str(e)))
- return
- elif ret == revision:
+ with tarfile.open(path) as tar_archive: # [ignore encoding]
+ archive_files = set(base_path / i.name for i in tar_archive)
+ return archive_files
+
+class Logger:
+ def __init__(self, total_tasks: int) -> None:
+ self.lock = threading.Lock()
+ self.total_tasks = total_tasks
+ self.completed_tasks = 0
+ self.running_tasks: T.Set[str] = set()
+ self.should_erase_line = ''
+
+ def flush(self) -> None:
+ if self.should_erase_line:
+ print(self.should_erase_line, end='\r')
+ self.should_erase_line = ''
+
+ def print_progress(self) -> None:
+ line = f'Progress: {self.completed_tasks} / {self.total_tasks}'
+ max_len = shutil.get_terminal_size().columns - len(line)
+ running = ', '.join(self.running_tasks)
+ if len(running) + 3 > max_len:
+ running = running[:max_len - 6] + '...'
+ line = line + f' ({running})'
+ print(self.should_erase_line, line, sep='', end='\r')
+ self.should_erase_line = '\x1b[K'
+
+ def start(self, wrap_name: str) -> None:
+ with self.lock:
+ self.running_tasks.add(wrap_name)
+ self.print_progress()
+
+ def done(self, wrap_name: str, log_queue: T.List[T.Tuple[mlog.TV_LoggableList, T.Any]]) -> None:
+ with self.lock:
+ self.flush()
+ for args, kwargs in log_queue:
+ mlog.log(*args, **kwargs)
+ self.running_tasks.remove(wrap_name)
+ self.completed_tasks += 1
+ self.print_progress()
+
+
+class Runner:
+ def __init__(self, logger: Logger, r: Resolver, wrap: PackageDefinition, repo_dir: str, options: 'Arguments') -> None:
+ # FIXME: Do a copy because Resolver.resolve() is stateful method that
+ # cannot be called from multiple threads.
+ self.wrap_resolver = copy.copy(r)
+ self.wrap_resolver.dirname = os.path.join(r.subdir_root, wrap.directory)
+ self.wrap = self.wrap_resolver.wrap = wrap
+ self.repo_dir = repo_dir
+ self.options = options
+ self.run_method: T.Callable[[], bool] = options.subprojects_func.__get__(self) # type: ignore
+ self.log_queue: T.List[T.Tuple[mlog.TV_LoggableList, T.Any]] = []
+ self.logger = logger
+
+ def log(self, *args: mlog.TV_Loggable, **kwargs: T.Any) -> None:
+ self.log_queue.append((list(args), kwargs))
+
+ def run(self) -> bool:
+ self.logger.start(self.wrap.name)
try:
- # We are in the same branch, pull latest commits
- git_output(['-c', 'rebase.autoStash=true', 'pull', '--rebase'], repo_dir)
- except subprocess.CalledProcessError as e:
- out = e.output.decode().strip()
- mlog.log(' -> Could not rebase', mlog.bold(repo_dir), 'please fix and try again.')
- mlog.log(mlog.red(out))
- mlog.log(mlog.red(str(e)))
+ result = self.run_method()
+ except MesonException as e:
+ self.log(mlog.red('Error:'), str(e))
+ result = False
+ self.logger.done(self.wrap.name, self.log_queue)
+ return result
+
+ def update_wrapdb_file(self) -> None:
+ try:
+ patch_url = self.wrap.get('patch_url')
+ branch, revision = wraptool.parse_patch_url(patch_url)
+ except WrapException:
return
- else:
- # We are in another branch, probably user created their own branch and
- # we should rebase it on top of wrap's branch.
- if options.rebase:
- try:
- git_output(['fetch'], repo_dir)
- git_output(['-c', 'rebase.autoStash=true', 'rebase', revision], repo_dir)
- except subprocess.CalledProcessError as e:
- out = e.output.decode().strip()
- mlog.log(' -> Could not rebase', mlog.bold(repo_dir), 'please fix and try again.')
- mlog.log(mlog.red(out))
- mlog.log(mlog.red(str(e)))
- return
+ new_branch, new_revision = wraptool.get_latest_version(self.wrap.name)
+ if new_branch != branch or new_revision != revision:
+ wraptool.update_wrap_file(self.wrap.filename, self.wrap.name, new_branch, new_revision)
+ self.log(' -> New wrap file downloaded.')
+
+ def update_file(self) -> bool:
+ options = T.cast('UpdateArguments', self.options)
+
+ self.update_wrapdb_file()
+ if not os.path.isdir(self.repo_dir):
+ # The subproject is not needed, or it is a tarball extracted in
+ # 'libfoo-1.0' directory and the version has been bumped and the new
+ # directory is 'libfoo-2.0'. In that case forcing a meson
+ # reconfigure will download and use the new tarball.
+ self.log(' -> Not used.')
+ return True
+ elif options.reset:
+ # Delete existing directory and redownload. It is possible that nothing
+ # changed but we have no way to know. Hopefully tarballs are still
+ # cached.
+ windows_proof_rmtree(self.repo_dir)
+ try:
+ self.wrap_resolver.resolve(self.wrap.name, 'meson')
+ self.log(' -> New version extracted')
+ return True
+ except WrapException as e:
+ self.log(' ->', mlog.red(str(e)))
+ return False
else:
- mlog.log(' -> Target revision is', mlog.bold(revision), 'but currently in branch is', mlog.bold(ret), '\n' +
- ' To rebase your branch on top of', mlog.bold(revision), 'use', mlog.bold('--rebase'), 'option.')
- return
+ # The subproject has not changed, or the new source and/or patch
+ # tarballs should be extracted in the same directory than previous
+ # version.
+ self.log(' -> Subproject has not changed, or the new source/patch needs to be extracted on the same location.')
+ self.log(' Pass --reset option to delete directory and redownload.')
+ return False
+
+ def git_output(self, cmd: T.List[str]) -> str:
+ return quiet_git(cmd, self.repo_dir, check=True)[1]
+
+ def git_verbose(self, cmd: T.List[str]) -> None:
+ self.log(self.git_output(cmd))
+
+ def git_stash(self) -> None:
+ # That git command return 1 (failure) when there is something to stash.
+ # We don't want to stash when there is nothing to stash because that would
+ # print spurious "No local changes to save".
+ if not quiet_git(['diff', '--quiet', 'HEAD'], self.repo_dir)[0]:
+ # Don't pipe stdout here because we want the user to see their changes have
+ # been saved.
+ self.git_verbose(['stash'])
+
+ def git_show(self) -> None:
+ commit_message = self.git_output(['show', '--quiet', '--pretty=format:%h%n%d%n%s%n[%an]'])
+ parts = [s.strip() for s in commit_message.split('\n')]
+ self.log(' ->', mlog.yellow(parts[0]), mlog.red(parts[1]), parts[2], mlog.blue(parts[3]))
- git_output(['submodule', 'update', '--checkout', '--recursive'], repo_dir)
- git_show(repo_dir)
+ def git_rebase(self, revision: str) -> bool:
+ try:
+ self.git_output(['-c', 'rebase.autoStash=true', 'rebase', 'FETCH_HEAD'])
+ except GitException as e:
+ self.log(' -> Could not rebase', mlog.bold(self.repo_dir), 'onto', mlog.bold(revision))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+ return True
-def update_hg(wrap, repo_dir, options):
- if not os.path.isdir(repo_dir):
- mlog.log(' -> Not used.')
- return
- revno = wrap.get('revision')
- if revno.lower() == 'tip':
- # Failure to do pull is not a fatal error,
- # because otherwise you can't develop without
- # a working net connection.
- subprocess.call(['hg', 'pull'], cwd=repo_dir)
- else:
- if subprocess.call(['hg', 'checkout', revno], cwd=repo_dir) != 0:
- subprocess.check_call(['hg', 'pull'], cwd=repo_dir)
- subprocess.check_call(['hg', 'checkout', revno], cwd=repo_dir)
-
-def update_svn(wrap, repo_dir, options):
- if not os.path.isdir(repo_dir):
- mlog.log(' -> Not used.')
- return
- revno = wrap.get('revision')
- p, out, _ = Popen_safe(['svn', 'info', '--show-item', 'revision', repo_dir])
- current_revno = out
- if current_revno == revno:
- return
- if revno.lower() == 'head':
- # Failure to do pull is not a fatal error,
- # because otherwise you can't develop without
- # a working net connection.
- subprocess.call(['svn', 'update'], cwd=repo_dir)
- else:
- subprocess.check_call(['svn', 'update', '-r', revno], cwd=repo_dir)
+ def git_reset(self, revision: str) -> bool:
+ try:
+ # Stash local changes, commits can always be found back in reflog, to
+ # avoid any data lost by mistake.
+ self.git_stash()
+ self.git_output(['reset', '--hard', 'FETCH_HEAD'])
+ self.wrap_resolver.apply_patch()
+ except GitException as e:
+ self.log(' -> Could not reset', mlog.bold(self.repo_dir), 'to', mlog.bold(revision))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+ return True
+
+ def git_checkout(self, revision: str, create: bool = False) -> bool:
+ cmd = ['checkout', '--ignore-other-worktrees', revision, '--']
+ if create:
+ cmd.insert(1, '-b')
+ try:
+ # Stash local changes, commits can always be found back in reflog, to
+ # avoid any data lost by mistake.
+ self.git_stash()
+ self.git_output(cmd)
+ except GitException as e:
+ self.log(' -> Could not checkout', mlog.bold(revision), 'in', mlog.bold(self.repo_dir))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+ return True
+
+ def git_checkout_and_reset(self, revision: str) -> bool:
+ # revision could be a branch that already exists but is outdated, so we still
+ # have to reset after the checkout.
+ success = self.git_checkout(revision)
+ if success:
+ success = self.git_reset(revision)
+ return success
+
+ def git_checkout_and_rebase(self, revision: str) -> bool:
+ # revision could be a branch that already exists but is outdated, so we still
+ # have to rebase after the checkout.
+ success = self.git_checkout(revision)
+ if success:
+ success = self.git_rebase(revision)
+ return success
+
+ def update_git(self) -> bool:
+ options = T.cast('UpdateArguments', self.options)
+
+ if not os.path.isdir(self.repo_dir):
+ self.log(' -> Not used.')
+ return True
+ if not os.path.exists(os.path.join(self.repo_dir, '.git')):
+ if options.reset:
+ # Delete existing directory and redownload
+ windows_proof_rmtree(self.repo_dir)
+ try:
+ self.wrap_resolver.resolve(self.wrap.name, 'meson')
+ self.update_git_done()
+ return True
+ except WrapException as e:
+ self.log(' ->', mlog.red(str(e)))
+ return False
+ else:
+ self.log(' -> Not a git repository.')
+ self.log('Pass --reset option to delete directory and redownload.')
+ return False
+ revision = self.wrap.values.get('revision')
+ url = self.wrap.values.get('url')
+ push_url = self.wrap.values.get('push-url')
+ if not revision or not url:
+ # It could be a detached git submodule for example.
+ self.log(' -> No revision or URL specified.')
+ return True
+ try:
+ origin_url = self.git_output(['remote', 'get-url', 'origin']).strip()
+ except GitException as e:
+ self.log(' -> Failed to determine current origin URL in', mlog.bold(self.repo_dir))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+ if options.reset:
+ try:
+ self.git_output(['remote', 'set-url', 'origin', url])
+ if push_url:
+ self.git_output(['remote', 'set-url', '--push', 'origin', push_url])
+ except GitException as e:
+ self.log(' -> Failed to reset origin URL in', mlog.bold(self.repo_dir))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+ elif url != origin_url:
+ self.log(f' -> URL changed from {origin_url!r} to {url!r}')
+ return False
+ try:
+ # Same as `git branch --show-current` but compatible with older git version
+ branch = self.git_output(['rev-parse', '--abbrev-ref', 'HEAD']).strip()
+ branch = branch if branch != 'HEAD' else ''
+ except GitException as e:
+ self.log(' -> Failed to determine current branch in', mlog.bold(self.repo_dir))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+ if self.wrap_resolver.is_git_full_commit_id(revision) and \
+ quiet_git(['rev-parse', '--verify', revision + '^{commit}'], self.repo_dir)[0]:
+ # The revision we need is both a commit and available. So we do not
+ # need to fetch it because it cannot be updated. Instead, trick
+ # git into setting FETCH_HEAD just in case, from the local commit.
+ self.git_output(['fetch', '.', revision])
+ else:
+ try:
+ # Fetch only the revision we need, this avoids fetching useless branches.
+ # revision can be either a branch, tag or commit id. In all cases we want
+ # FETCH_HEAD to be set to the desired commit and "git checkout "
+ # to to either switch to existing/new branch, or detach to tag/commit.
+ # It is more complicated than it first appear, see discussion there:
+ # https://github.com/mesonbuild/meson/pull/7723#discussion_r488816189.
+ heads_refmap = '+refs/heads/*:refs/remotes/origin/*'
+ tags_refmap = '+refs/tags/*:refs/tags/*'
+ self.git_output(['fetch', '--refmap', heads_refmap, '--refmap', tags_refmap, 'origin', revision])
+ except GitException as e:
+ self.log(' -> Could not fetch revision', mlog.bold(revision), 'in', mlog.bold(self.repo_dir))
+ self.log(mlog.red(e.output))
+ self.log(mlog.red(str(e)))
+ return False
+
+ if branch == '':
+ # We are currently in detached mode
+ if options.reset:
+ success = self.git_checkout_and_reset(revision)
+ else:
+ success = self.git_checkout_and_rebase(revision)
+ elif branch == revision:
+ # We are in the same branch. A reset could still be needed in the case
+ # a force push happened on remote repository.
+ if options.reset:
+ success = self.git_reset(revision)
+ else:
+ success = self.git_rebase(revision)
+ else:
+ # We are in another branch, either the user created their own branch and
+ # we should rebase it, or revision changed in the wrap file and we need
+ # to checkout the new branch.
+ if options.reset:
+ success = self.git_checkout_and_reset(revision)
+ else:
+ success = self.git_rebase(revision)
+ if success:
+ self.update_git_done()
+ return success
+
+ def update_git_done(self) -> None:
+ self.git_output(['submodule', 'update', '--checkout', '--recursive'])
+ self.git_show()
+
+ def update_hg(self) -> bool:
+ if not os.path.isdir(self.repo_dir):
+ self.log(' -> Not used.')
+ return True
+ revno = self.wrap.get('revision')
+ if revno.lower() == 'tip':
+ # Failure to do pull is not a fatal error,
+ # because otherwise you can't develop without
+ # a working net connection.
+ subprocess.call(['hg', 'pull'], cwd=self.repo_dir)
+ else:
+ if subprocess.call(['hg', 'checkout', revno], cwd=self.repo_dir) != 0:
+ subprocess.check_call(['hg', 'pull'], cwd=self.repo_dir)
+ subprocess.check_call(['hg', 'checkout', revno], cwd=self.repo_dir)
+ return True
+
+ def update_svn(self) -> bool:
+ if not os.path.isdir(self.repo_dir):
+ self.log(' -> Not used.')
+ return True
+ revno = self.wrap.get('revision')
+ _, out, _ = Popen_safe(['svn', 'info', '--show-item', 'revision', self.repo_dir])
+ current_revno = out
+ if current_revno == revno:
+ return True
+ if revno.lower() == 'head':
+ # Failure to do pull is not a fatal error,
+ # because otherwise you can't develop without
+ # a working net connection.
+ subprocess.call(['svn', 'update'], cwd=self.repo_dir)
+ else:
+ subprocess.check_call(['svn', 'update', '-r', revno], cwd=self.repo_dir)
+ return True
-def update(wrap, repo_dir, options):
- mlog.log('Updating %s...' % wrap.name)
- if wrap.type == 'file':
- update_file(wrap, repo_dir, options)
- elif wrap.type == 'git':
- update_git(wrap, repo_dir, options)
- elif wrap.type == 'hg':
- update_hg(wrap, repo_dir, options)
- elif wrap.type == 'svn':
- update_svn(wrap, repo_dir, options)
- else:
- mlog.log(' -> Cannot update', wrap.type, 'subproject')
+ def update(self) -> bool:
+ self.log(f'Updating {self.wrap.name}...')
+ if self.wrap.type == 'file':
+ return self.update_file()
+ elif self.wrap.type == 'git':
+ return self.update_git()
+ elif self.wrap.type == 'hg':
+ return self.update_hg()
+ elif self.wrap.type == 'svn':
+ return self.update_svn()
+ elif self.wrap.type is None:
+ self.log(' -> Cannot update subproject with no wrap file')
+ else:
+ self.log(' -> Cannot update', self.wrap.type, 'subproject')
+ return True
+
+ def checkout(self) -> bool:
+ options = T.cast('CheckoutArguments', self.options)
+
+ if self.wrap.type != 'git' or not os.path.isdir(self.repo_dir):
+ return True
+ branch_name = options.branch_name if options.branch_name else self.wrap.get('revision')
+ if not branch_name:
+ # It could be a detached git submodule for example.
+ return True
+ self.log(f'Checkout {branch_name} in {self.wrap.name}...')
+ if self.git_checkout(branch_name, create=options.b):
+ self.git_show()
+ return True
+ return False
+
+ def download(self) -> bool:
+ self.log(f'Download {self.wrap.name}...')
+ if os.path.isdir(self.repo_dir):
+ self.log(' -> Already downloaded')
+ return True
+ try:
+ self.wrap_resolver.resolve(self.wrap.name, 'meson')
+ self.log(' -> done')
+ except WrapException as e:
+ self.log(' ->', mlog.red(str(e)))
+ return False
+ return True
+
+ def foreach(self) -> bool:
+ options = T.cast('ForeachArguments', self.options)
+
+ self.log(f'Executing command in {self.repo_dir}')
+ if not os.path.isdir(self.repo_dir):
+ self.log(' -> Not downloaded yet')
+ return True
+ cmd = [options.command] + options.args
+ p, out, _ = Popen_safe(cmd, stderr=subprocess.STDOUT, cwd=self.repo_dir)
+ if p.returncode != 0:
+ err_message = "Command '{}' returned non-zero exit status {}.".format(" ".join(cmd), p.returncode)
+ self.log(' -> ', mlog.red(err_message))
+ self.log(out, end='')
+ return False
+
+ self.log(out, end='')
+ return True
+
+ def purge(self) -> bool:
+ options = T.cast('PurgeArguments', self.options)
+
+ # if subproject is not wrap-based, then don't remove it
+ if not self.wrap.type:
+ return True
+
+ if self.wrap.redirected:
+ redirect_file = Path(self.wrap.original_filename).resolve()
+ if options.confirm:
+ redirect_file.unlink()
+ mlog.log(f'Deleting {redirect_file}')
+
+ if self.wrap.type == 'redirect':
+ redirect_file = Path(self.wrap.filename).resolve()
+ if options.confirm:
+ redirect_file.unlink()
+ self.log(f'Deleting {redirect_file}')
+
+ if options.include_cache:
+ packagecache = Path(self.wrap_resolver.cachedir).resolve()
+ try:
+ subproject_cache_file = packagecache / self.wrap.get("source_filename")
+ if subproject_cache_file.is_file():
+ if options.confirm:
+ subproject_cache_file.unlink()
+ self.log(f'Deleting {subproject_cache_file}')
+ except WrapException:
+ pass
+
+ try:
+ subproject_patch_file = packagecache / self.wrap.get("patch_filename")
+ if subproject_patch_file.is_file():
+ if options.confirm:
+ subproject_patch_file.unlink()
+ self.log(f'Deleting {subproject_patch_file}')
+ except WrapException:
+ pass
+
+ # Don't log that we will remove an empty directory. Since purge is
+ # parallelized, another thread could have deleted it already.
+ try:
+ if not any(packagecache.iterdir()):
+ windows_proof_rmtree(str(packagecache))
+ except FileNotFoundError:
+ pass
+
+ # NOTE: Do not use .resolve() here; the subproject directory may be a symlink
+ subproject_source_dir = Path(self.repo_dir)
+ # Resolve just the parent, just to print out the full path
+ subproject_source_dir = subproject_source_dir.parent.resolve() / subproject_source_dir.name
+
+ # Don't follow symlink. This is covered by the next if statement, but why
+ # not be doubly sure.
+ if subproject_source_dir.is_symlink():
+ if options.confirm:
+ subproject_source_dir.unlink()
+ self.log(f'Deleting {subproject_source_dir}')
+ return True
+ if not subproject_source_dir.is_dir():
+ return True
+
+ try:
+ if options.confirm:
+ windows_proof_rmtree(str(subproject_source_dir))
+ self.log(f'Deleting {subproject_source_dir}')
+ except OSError as e:
+ mlog.error(f'Unable to remove: {subproject_source_dir}: {e}')
+ return False
+
+ return True
+
+ @staticmethod
+ def post_purge(options: 'PurgeArguments') -> None:
+ if not options.confirm:
+ mlog.log('')
+ mlog.log('Nothing has been deleted, run again with --confirm to apply.')
+
+ def packagefiles(self) -> bool:
+ options = T.cast('PackagefilesArguments', self.options)
+
+ if options.apply and options.save:
+ # not quite so nice as argparse failure
+ print('error: --apply and --save are mutually exclusive')
+ return False
+ if options.apply:
+ self.log(f'Re-applying patchfiles overlay for {self.wrap.name}...')
+ if not os.path.isdir(self.repo_dir):
+ self.log(' -> Not downloaded yet')
+ return True
+ self.wrap_resolver.apply_patch()
+ return True
+ if options.save:
+ if 'patch_directory' not in self.wrap.values:
+ mlog.error('can only save packagefiles to patch_directory')
+ return False
+ if 'source_filename' not in self.wrap.values:
+ mlog.error('can only save packagefiles from a [wrap-file]')
+ return False
+ archive_path = Path(self.wrap_resolver.cachedir, self.wrap.values['source_filename'])
+ lead_directory_missing = bool(self.wrap.values.get('lead_directory_missing', False))
+ directory = Path(self.repo_dir)
+ packagefiles = Path(self.wrap.filesdir, self.wrap.values['patch_directory'])
+
+ base_path = directory if lead_directory_missing else directory.parent
+ archive_files = read_archive_files(archive_path, base_path)
+ directory_files = set(directory.glob('**/*'))
+
+ self.log(f'Saving {self.wrap.name} to {packagefiles}...')
+ shutil.rmtree(packagefiles)
+ for src_path in directory_files - archive_files:
+ if not src_path.is_file():
+ continue
+ rel_path = src_path.relative_to(directory)
+ dst_path = packagefiles / rel_path
+ dst_path.parent.mkdir(parents=True, exist_ok=True)
+ shutil.copyfile(src_path, dst_path)
+ return True
-def checkout(wrap, repo_dir, options):
- if wrap.type != 'git' or not os.path.isdir(repo_dir):
- return
- branch_name = options.branch_name if options.branch_name else wrap.get('revision')
- cmd = ['checkout', branch_name, '--']
- if options.b:
- cmd.insert(1, '-b')
- mlog.log('Checkout %s in %s...' % (branch_name, wrap.name))
- try:
- git_output(cmd, repo_dir)
- git_show(repo_dir)
- except subprocess.CalledProcessError as e:
- out = e.output.decode().strip()
- mlog.log(' -> ', mlog.red(out))
-
-def download(wrap, repo_dir, options):
- mlog.log('Download %s...' % wrap.name)
- if os.path.isdir(repo_dir):
- mlog.log(' -> Already downloaded')
- return
- try:
- r = Resolver(os.path.dirname(repo_dir))
- r.resolve(wrap.name, 'meson')
- mlog.log(' -> done')
- except WrapException as e:
- mlog.log(' ->', mlog.red(str(e)))
-
-def foreach(wrap, repo_dir, options):
- mlog.log('Executing command in %s' % repo_dir)
- if not os.path.isdir(repo_dir):
- mlog.log(' -> Not downloaded yet')
- return
- try:
- out = subprocess.check_output([options.command] + options.args,
- stderr=subprocess.STDOUT,
- cwd=repo_dir).decode()
- mlog.log(out, end='')
- except subprocess.CalledProcessError as e:
- err_message = "Command '%s' returned non-zero exit status %d." % (" ".join(e.cmd), e.returncode)
- out = e.output.decode()
- mlog.log(' -> ', mlog.red(err_message))
- mlog.log(out, end='')
- except Exception as e:
- mlog.log(' -> ', mlog.red(str(e)))
-def add_common_arguments(p):
+def add_common_arguments(p: argparse.ArgumentParser) -> None:
p.add_argument('--sourcedir', default='.',
help='Path to source directory')
+ p.add_argument('--types', default='',
+ help=f'Comma-separated list of subproject types. Supported types are: {ALL_TYPES_STRING} (default: all)')
+ p.add_argument('--num-processes', default=None, type=int,
+ help='How many parallel processes to use (Since 0.59.0).')
+
+def add_subprojects_argument(p: argparse.ArgumentParser) -> None:
p.add_argument('subprojects', nargs='*',
help='List of subprojects (default: all)')
-def add_arguments(parser):
+def add_arguments(parser: argparse.ArgumentParser) -> None:
subparsers = parser.add_subparsers(title='Commands', dest='command')
subparsers.required = True
p = subparsers.add_parser('update', help='Update all subprojects from wrap files')
- p.add_argument('--rebase', default=False, action='store_true',
- help='Rebase your branch on top of wrap\'s revision (git only)')
+ p.add_argument('--rebase', default=True, action='store_true',
+ help='Rebase your branch on top of wrap\'s revision. ' + \
+ 'Deprecated, it is now the default behaviour. (git only)')
+ p.add_argument('--reset', default=False, action='store_true',
+ help='Checkout wrap\'s revision and hard reset to that commit. (git only)')
add_common_arguments(p)
- p.set_defaults(subprojects_func=update)
+ add_subprojects_argument(p)
+ p.set_defaults(subprojects_func=Runner.update)
p = subparsers.add_parser('checkout', help='Checkout a branch (git only)')
p.add_argument('-b', default=False, action='store_true',
@@ -208,24 +595,41 @@
p.add_argument('branch_name', nargs='?',
help='Name of the branch to checkout or create (default: revision set in wrap file)')
add_common_arguments(p)
- p.set_defaults(subprojects_func=checkout)
+ add_subprojects_argument(p)
+ p.set_defaults(subprojects_func=Runner.checkout)
p = subparsers.add_parser('download', help='Ensure subprojects are fetched, even if not in use. ' +
'Already downloaded subprojects are not modified. ' +
'This can be used to pre-fetch all subprojects and avoid downloads during configure.')
add_common_arguments(p)
- p.set_defaults(subprojects_func=download)
+ add_subprojects_argument(p)
+ p.set_defaults(subprojects_func=Runner.download)
p = subparsers.add_parser('foreach', help='Execute a command in each subproject directory.')
p.add_argument('command', metavar='command ...',
help='Command to execute in each subproject directory')
p.add_argument('args', nargs=argparse.REMAINDER,
help=argparse.SUPPRESS)
- p.add_argument('--sourcedir', default='.',
- help='Path to source directory')
- p.set_defaults(subprojects_func=foreach)
+ add_common_arguments(p)
+ p.set_defaults(subprojects=[])
+ p.set_defaults(subprojects_func=Runner.foreach)
-def run(options):
+ p = subparsers.add_parser('purge', help='Remove all wrap-based subproject artifacts')
+ add_common_arguments(p)
+ add_subprojects_argument(p)
+ p.add_argument('--include-cache', action='store_true', default=False, help='Remove the package cache as well')
+ p.add_argument('--confirm', action='store_true', default=False, help='Confirm the removal of subproject artifacts')
+ p.set_defaults(subprojects_func=Runner.purge)
+ p.set_defaults(post_func=Runner.post_purge)
+
+ p = subparsers.add_parser('packagefiles', help='Manage the packagefiles overlay')
+ add_common_arguments(p)
+ add_subprojects_argument(p)
+ p.add_argument('--apply', action='store_true', default=False, help='Apply packagefiles to the subproject')
+ p.add_argument('--save', action='store_true', default=False, help='Save packagefiles from the subproject')
+ p.set_defaults(subprojects_func=Runner.packagefiles)
+
+def run(options: 'Arguments') -> int:
src_dir = os.path.relpath(os.path.realpath(options.sourcedir))
if not os.path.isfile(os.path.join(src_dir, 'meson.build')):
mlog.error('Directory', mlog.bold(src_dir), 'does not seem to be a Meson source directory.')
@@ -234,22 +638,36 @@
if not os.path.isdir(subprojects_dir):
mlog.log('Directory', mlog.bold(src_dir), 'does not seem to have subprojects.')
return 0
- files = []
- if hasattr(options, 'subprojects'):
- for name in options.subprojects:
- f = os.path.join(subprojects_dir, name + '.wrap')
- if not os.path.isfile(f):
- mlog.error('Subproject', mlog.bold(name), 'not found.')
- return 1
- else:
- files.append(f)
- if not files:
- for f in os.listdir(subprojects_dir):
- if f.endswith('.wrap'):
- files.append(os.path.join(subprojects_dir, f))
- for f in files:
- wrap = PackageDefinition(f)
- directory = wrap.values.get('directory', wrap.name)
- repo_dir = os.path.join(subprojects_dir, directory)
- options.subprojects_func(wrap, repo_dir, options)
- return 0
+ r = Resolver(src_dir, 'subprojects')
+ if options.subprojects:
+ wraps = [wrap for name, wrap in r.wraps.items() if name in options.subprojects]
+ else:
+ wraps = list(r.wraps.values())
+ types = [t.strip() for t in options.types.split(',')] if options.types else []
+ for t in types:
+ if t not in ALL_TYPES:
+ raise MesonException(f'Unknown subproject type {t!r}, supported types are: {ALL_TYPES_STRING}')
+ tasks: T.List[T.Awaitable[bool]] = []
+ task_names: T.List[str] = []
+ loop = asyncio.get_event_loop()
+ executor = ThreadPoolExecutor(options.num_processes)
+ if types:
+ wraps = [wrap for wrap in wraps if wrap.type in types]
+ logger = Logger(len(wraps))
+ for wrap in wraps:
+ dirname = Path(subprojects_dir, wrap.directory).as_posix()
+ runner = Runner(logger, r, wrap, dirname, options)
+ task = loop.run_in_executor(executor, runner.run)
+ tasks.append(task)
+ task_names.append(wrap.name)
+ results = loop.run_until_complete(asyncio.gather(*tasks))
+ logger.flush()
+ post_func = getattr(options, 'post_func', None)
+ if post_func:
+ post_func(options)
+ failures = [name for name, success in zip(task_names, results) if not success]
+ if failures:
+ m = 'Please check logs above as command failed in some subprojects which could have been left in conflict state: '
+ m += ', '.join(failures)
+ mlog.warning(m)
+ return len(failures)
diff -Nru meson-0.53.2/mesonbuild/mtest.py meson-0.61.2/mesonbuild/mtest.py
--- meson-0.53.2/mesonbuild/mtest.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/mtest.py 2021-12-26 16:24:25.000000000 +0000
@@ -15,13 +15,12 @@
# A tool to run tests in many different ways.
from pathlib import Path
-from collections import namedtuple
+from collections import deque
from copy import deepcopy
import argparse
-import concurrent.futures as conc
+import asyncio
import datetime
import enum
-import io
import json
import multiprocessing
import os
@@ -31,19 +30,24 @@
import re
import signal
import subprocess
+import shlex
import sys
-import tempfile
+import textwrap
import time
import typing as T
+import unicodedata
+import xml.etree.ElementTree as et
from . import build
from . import environment
from . import mlog
-from .dependencies import ExternalProgram
-from .mesonlib import MesonException, get_wine_shortpath, split_args
-
-if T.TYPE_CHECKING:
- from .backend.backends import TestSerialisation
+from .coredata import major_versions_differ, MesonVersionMismatchException
+from .coredata import version as coredata_version
+from .mesonlib import (MesonException, OrderedSet, RealPathAction,
+ get_wine_shortpath, join_args, split_args, setup_vsenv)
+from .mintro import get_infodir, load_info_file
+from .programs import ExternalProgram
+from .backend.backends import TestProtocol, TestSerialisation
# GNU autotools interprets a return code of 77 from tests it executes to
# mean that the test should be skipped.
@@ -53,13 +57,23 @@
# mean that the test failed even before testing what it is supposed to test.
GNU_ERROR_RETURNCODE = 99
+# Exit if 3 Ctrl-C's are received within one second
+MAX_CTRLC = 3
+
def is_windows() -> bool:
platname = platform.system().lower()
- return platname == 'windows' or 'mingw' in platname
+ return platname == 'windows'
def is_cygwin() -> bool:
- platname = platform.system().lower()
- return 'cygwin' in platname
+ return sys.platform == 'cygwin'
+
+UNIWIDTH_MAPPING = {'F': 2, 'H': 1, 'W': 2, 'Na': 1, 'N': 1, 'A': 1}
+def uniwidth(s: str) -> int:
+ result = 0
+ for c in s:
+ w = unicodedata.east_asian_width(c)
+ result += UNIWIDTH_MAPPING[w]
+ return result
def determine_worker_count() -> int:
varname = 'MESON_TESTTHREADS'
@@ -67,7 +81,7 @@
try:
num_workers = int(os.environ[varname])
except ValueError:
- print('Invalid value in %s, using 1 thread.' % varname)
+ print(f'Invalid value in {varname}, using 1 thread.')
num_workers = 1
else:
try:
@@ -91,7 +105,10 @@
help='List available tests.')
parser.add_argument('--wrapper', default=None, dest='wrapper', type=split_args,
help='wrapper to run tests with (e.g. Valgrind)')
- parser.add_argument('-C', default='.', dest='wd',
+ parser.add_argument('-C', dest='wd', action=RealPathAction,
+ # https://github.com/python/typeshed/issues/3107
+ # https://github.com/python/mypy/issues/7177
+ type=os.path.abspath, # type: ignore
help='directory to cd into before running')
parser.add_argument('--suite', default=[], dest='include_suites', action='append', metavar='SUITE',
help='Only run tests belonging to the given suite.')
@@ -114,15 +131,41 @@
parser.add_argument('-t', '--timeout-multiplier', type=float, default=None,
help='Define a multiplier for test timeout, for example '
' when running tests in particular conditions they might take'
- ' more time to execute.')
+ ' more time to execute. (<= 0 to disable timeout)')
parser.add_argument('--setup', default=None, dest='setup',
help='Which test setup to use.')
parser.add_argument('--test-args', default=[], type=split_args,
help='Arguments to pass to the specified test(s) or all tests')
parser.add_argument('args', nargs='*',
- help='Optional list of tests to run')
+ help='Optional list of test names to run. "testname" to run all tests with that name, '
+ '"subprojname:testname" to specifically run "testname" from "subprojname", '
+ '"subprojname:" to run all tests defined by "subprojname".')
+def print_safe(s: str) -> None:
+ end = '' if s[-1] == '\n' else '\n'
+ try:
+ print(s, end=end)
+ except UnicodeEncodeError:
+ s = s.encode('ascii', errors='backslashreplace').decode('ascii')
+ print(s, end=end)
+
+def join_lines(a: str, b: str) -> str:
+ if not a:
+ return b
+ if not b:
+ return a
+ return a + '\n' + b
+
+def dashes(s: str, dash: str, cols: int) -> str:
+ if not s:
+ return dash * cols
+ s = ' ' + s + ' '
+ width = uniwidth(s)
+ first = (cols - width) // 2
+ s = dash * first + s
+ return s + dash * (cols - first - width)
+
def returncode_to_status(retcode: int) -> str:
# Note: We can't use `os.WIFSIGNALED(result.returncode)` and the related
# functions here because the status returned by subprocess is munged. It
@@ -136,20 +179,25 @@
signame = signal.Signals(signum).name
except ValueError:
signame = 'SIGinvalid'
- return '(killed by signal %d %s)' % (signum, signame)
+ return f'killed by signal {signum} {signame}'
if retcode <= 128:
- return '(exit status %d)' % (retcode,)
+ return f'exit status {retcode}'
signum = retcode - 128
try:
signame = signal.Signals(signum).name
except ValueError:
signame = 'SIGinvalid'
- return '(exit status %d or signal %d %s)' % (retcode, signum, signame)
+ return f'(exit status {retcode} or signal {signum} {signame})'
+
+# TODO for Windows
+sh_quote: T.Callable[[str], str] = lambda x: x
+if not is_windows():
+ sh_quote = shlex.quote
def env_tuple_to_str(env: T.Iterable[T.Tuple[str, str]]) -> str:
- return ''.join(["%s='%s' " % (k, v) for k, v in env])
+ return ''.join(["{}={} ".format(k, sh_quote(v)) for k, v in env])
class TestException(MesonException):
@@ -157,23 +205,94 @@
@enum.unique
+class ConsoleUser(enum.Enum):
+
+ # the logger can use the console
+ LOGGER = 0
+
+ # the console is used by gdb
+ GDB = 1
+
+ # the console is used to write stdout/stderr
+ STDOUT = 2
+
+
+@enum.unique
class TestResult(enum.Enum):
+ PENDING = 'PENDING'
+ RUNNING = 'RUNNING'
OK = 'OK'
TIMEOUT = 'TIMEOUT'
+ INTERRUPT = 'INTERRUPT'
SKIP = 'SKIP'
FAIL = 'FAIL'
EXPECTEDFAIL = 'EXPECTEDFAIL'
UNEXPECTEDPASS = 'UNEXPECTEDPASS'
ERROR = 'ERROR'
+ @staticmethod
+ def maxlen() -> int:
+ return 14 # len(UNEXPECTEDPASS)
+
+ def is_ok(self) -> bool:
+ return self in {TestResult.OK, TestResult.EXPECTEDFAIL}
+
+ def is_bad(self) -> bool:
+ return self in {TestResult.FAIL, TestResult.TIMEOUT, TestResult.INTERRUPT,
+ TestResult.UNEXPECTEDPASS, TestResult.ERROR}
+
+ def is_finished(self) -> bool:
+ return self not in {TestResult.PENDING, TestResult.RUNNING}
+
+ def was_killed(self) -> bool:
+ return self in (TestResult.TIMEOUT, TestResult.INTERRUPT)
+
+ def colorize(self, s: str) -> mlog.AnsiDecorator:
+ if self.is_bad():
+ decorator = mlog.red
+ elif self in (TestResult.SKIP, TestResult.EXPECTEDFAIL):
+ decorator = mlog.yellow
+ elif self.is_finished():
+ decorator = mlog.green
+ else:
+ decorator = mlog.blue
+ return decorator(s)
+
+ def get_text(self, colorize: bool) -> str:
+ result_str = '{res:{reslen}}'.format(res=self.value, reslen=self.maxlen())
+ return self.colorize(result_str).get_text(colorize)
+
+ def get_command_marker(self) -> str:
+ return str(self.colorize('>>> '))
+
+
+TYPE_TAPResult = T.Union['TAPParser.Test', 'TAPParser.Error', 'TAPParser.Version', 'TAPParser.Plan', 'TAPParser.Bailout']
class TAPParser:
- Plan = namedtuple('Plan', ['count', 'late', 'skipped', 'explanation'])
- Bailout = namedtuple('Bailout', ['message'])
- Test = namedtuple('Test', ['number', 'name', 'result', 'explanation'])
- Error = namedtuple('Error', ['message'])
- Version = namedtuple('Version', ['version'])
+ class Plan(T.NamedTuple):
+ num_tests: int
+ late: bool
+ skipped: bool
+ explanation: T.Optional[str]
+
+ class Bailout(T.NamedTuple):
+ message: str
+
+ class Test(T.NamedTuple):
+ number: int
+ name: str
+ result: TestResult
+ explanation: T.Optional[str]
+
+ def __str__(self) -> str:
+ return f'{self.number} {self.name}'.strip()
+
+ class Error(T.NamedTuple):
+ message: str
+
+ class Version(T.NamedTuple):
+ version: int
_MAIN = 1
_AFTER_TEST = 2
@@ -187,8 +306,15 @@
_RE_YAML_START = re.compile(r'(\s+)---.*')
_RE_YAML_END = re.compile(r'\s+\.\.\.\s*')
- def __init__(self, io: T.Iterator[str]):
- self.io = io
+ found_late_test = False
+ bailed_out = False
+ plan: T.Optional[Plan] = None
+ lineno = 0
+ num_tests = 0
+ yaml_lineno: T.Optional[int] = None
+ yaml_indent = ''
+ state = _MAIN
+ version = 12
def parse_test(self, ok: bool, num: int, name: str, directive: T.Optional[str], explanation: T.Optional[str]) -> \
T.Generator[T.Union['TAPParser.Test', 'TAPParser.Error'], None, None]:
@@ -196,7 +322,7 @@
explanation = explanation.strip() if explanation else None
if directive is not None:
directive = directive.upper()
- if directive == 'SKIP':
+ if directive.startswith('SKIP'):
if ok:
yield self.Test(num, name, TestResult.SKIP, explanation)
return
@@ -204,211 +330,758 @@
yield self.Test(num, name, TestResult.UNEXPECTEDPASS if ok else TestResult.EXPECTEDFAIL, explanation)
return
else:
- yield self.Error('invalid directive "%s"' % (directive,))
+ yield self.Error(f'invalid directive "{directive}"')
yield self.Test(num, name, TestResult.OK if ok else TestResult.FAIL, explanation)
- def parse(self) -> T.Generator[T.Union['TAPParser.Test', 'TAPParser.Error', 'TAPParser.Version', 'TAPParser.Plan', 'TAPParser.Bailout'], None, None]:
- found_late_test = False
- bailed_out = False
- plan = None
- lineno = 0
- num_tests = 0
- yaml_lineno = None
- yaml_indent = ''
- state = self._MAIN
- version = 12
- while True:
- lineno += 1
- try:
- line = next(self.io).rstrip()
- except StopIteration:
- break
+ async def parse_async(self, lines: T.AsyncIterator[str]) -> T.AsyncIterator[TYPE_TAPResult]:
+ async for line in lines:
+ for event in self.parse_line(line):
+ yield event
+ for event in self.parse_line(None):
+ yield event
+
+ def parse(self, io: T.Iterator[str]) -> T.Iterator[TYPE_TAPResult]:
+ for line in io:
+ yield from self.parse_line(line)
+ yield from self.parse_line(None)
+
+ def parse_line(self, line: T.Optional[str]) -> T.Iterator[TYPE_TAPResult]:
+ if line is not None:
+ self.lineno += 1
+ line = line.rstrip()
# YAML blocks are only accepted after a test
- if state == self._AFTER_TEST:
- if version >= 13:
+ if self.state == self._AFTER_TEST:
+ if self.version >= 13:
m = self._RE_YAML_START.match(line)
if m:
- state = self._YAML
- yaml_lineno = lineno
- yaml_indent = m.group(1)
- continue
- state = self._MAIN
+ self.state = self._YAML
+ self.yaml_lineno = self.lineno
+ self.yaml_indent = m.group(1)
+ return
+ self.state = self._MAIN
- elif state == self._YAML:
+ elif self.state == self._YAML:
if self._RE_YAML_END.match(line):
- state = self._MAIN
- continue
- if line.startswith(yaml_indent):
- continue
- yield self.Error('YAML block not terminated (started on line {})'.format(yaml_lineno))
- state = self._MAIN
+ self.state = self._MAIN
+ return
+ if line.startswith(self.yaml_indent):
+ return
+ yield self.Error(f'YAML block not terminated (started on line {self.yaml_lineno})')
+ self.state = self._MAIN
- assert state == self._MAIN
+ assert self.state == self._MAIN
if line.startswith('#'):
- continue
+ return
m = self._RE_TEST.match(line)
if m:
- if plan and plan.late and not found_late_test:
+ if self.plan and self.plan.late and not self.found_late_test:
yield self.Error('unexpected test after late plan')
- found_late_test = True
- num_tests += 1
- num = num_tests if m.group(2) is None else int(m.group(2))
- if num != num_tests:
+ self.found_late_test = True
+ self.num_tests += 1
+ num = self.num_tests if m.group(2) is None else int(m.group(2))
+ if num != self.num_tests:
yield self.Error('out of order test numbers')
yield from self.parse_test(m.group(1) == 'ok', num,
m.group(3), m.group(4), m.group(5))
- state = self._AFTER_TEST
- continue
+ self.state = self._AFTER_TEST
+ return
m = self._RE_PLAN.match(line)
if m:
- if plan:
+ if self.plan:
yield self.Error('more than one plan found')
else:
- count = int(m.group(1))
- skipped = (count == 0)
+ num_tests = int(m.group(1))
+ skipped = (num_tests == 0)
if m.group(2):
if m.group(2).upper().startswith('SKIP'):
- if count > 0:
+ if num_tests > 0:
yield self.Error('invalid SKIP directive for plan')
skipped = True
else:
yield self.Error('invalid directive for plan')
- plan = self.Plan(count=count, late=(num_tests > 0),
- skipped=skipped, explanation=m.group(3))
- yield plan
- continue
+ self.plan = self.Plan(num_tests=num_tests, late=(self.num_tests > 0),
+ skipped=skipped, explanation=m.group(3))
+ yield self.plan
+ return
m = self._RE_BAILOUT.match(line)
if m:
yield self.Bailout(m.group(1))
- bailed_out = True
- continue
+ self.bailed_out = True
+ return
m = self._RE_VERSION.match(line)
if m:
# The TAP version is only accepted as the first line
- if lineno != 1:
+ if self.lineno != 1:
yield self.Error('version number must be on the first line')
- continue
- version = int(m.group(1))
- if version < 13:
+ return
+ self.version = int(m.group(1))
+ if self.version < 13:
yield self.Error('version number should be at least 13')
else:
- yield self.Version(version=version)
- continue
+ yield self.Version(version=self.version)
+ return
- if len(line) == 0:
- continue
+ if not line:
+ return
+
+ yield self.Error(f'unexpected input at line {self.lineno}')
+ else:
+ # end of file
+ if self.state == self._YAML:
+ yield self.Error(f'YAML block not terminated (started on line {self.yaml_lineno})')
+
+ if not self.bailed_out and self.plan and self.num_tests != self.plan.num_tests:
+ if self.num_tests < self.plan.num_tests:
+ yield self.Error(f'Too few tests run (expected {self.plan.num_tests}, got {self.num_tests})')
+ else:
+ yield self.Error(f'Too many tests run (expected {self.plan.num_tests}, got {self.num_tests})')
- yield self.Error('unexpected input at line %d' % (lineno,))
+class TestLogger:
+ def flush(self) -> None:
+ pass
+
+ def start(self, harness: 'TestHarness') -> None:
+ pass
+
+ def start_test(self, harness: 'TestHarness', test: 'TestRun') -> None:
+ pass
+
+ def log_subtest(self, harness: 'TestHarness', test: 'TestRun', s: str, res: TestResult) -> None:
+ pass
+
+ def log(self, harness: 'TestHarness', result: 'TestRun') -> None:
+ pass
+
+ async def finish(self, harness: 'TestHarness') -> None:
+ pass
+
+ def close(self) -> None:
+ pass
+
+
+class TestFileLogger(TestLogger):
+ def __init__(self, filename: str, errors: str = 'replace') -> None:
+ self.filename = filename
+ self.file = open(filename, 'w', encoding='utf-8', errors=errors)
+
+ def close(self) -> None:
+ if self.file:
+ self.file.close()
+ self.file = None
+
+
+class ConsoleLogger(TestLogger):
+ ASCII_SPINNER = ['..', ':.', '.:']
+ SPINNER = ["\U0001f311", "\U0001f312", "\U0001f313", "\U0001f314",
+ "\U0001f315", "\U0001f316", "\U0001f317", "\U0001f318"]
+
+ SCISSORS = "\u2700 "
+ HLINE = "\u2015"
+ RTRI = "\u25B6 "
+
+ def __init__(self) -> None:
+ self.update = asyncio.Event()
+ self.running_tests = OrderedSet() # type: OrderedSet['TestRun']
+ self.progress_test = None # type: T.Optional['TestRun']
+ self.progress_task = None # type: T.Optional[asyncio.Future]
+ self.max_left_width = 0 # type: int
+ self.stop = False
+ self.update = asyncio.Event()
+ self.should_erase_line = ''
+ self.test_count = 0
+ self.started_tests = 0
+ self.spinner_index = 0
+ try:
+ self.cols, _ = os.get_terminal_size(1)
+ self.is_tty = True
+ except OSError:
+ self.cols = 80
+ self.is_tty = False
+
+ self.output_start = dashes(self.SCISSORS, self.HLINE, self.cols - 2)
+ self.output_end = dashes('', self.HLINE, self.cols - 2)
+ self.sub = self.RTRI
+ self.spinner = self.SPINNER
+ try:
+ self.output_start.encode(sys.stdout.encoding or 'ascii')
+ except UnicodeEncodeError:
+ self.output_start = dashes('8<', '-', self.cols - 2)
+ self.output_end = dashes('', '-', self.cols - 2)
+ self.sub = '| '
+ self.spinner = self.ASCII_SPINNER
+
+ def flush(self) -> None:
+ if self.should_erase_line:
+ print(self.should_erase_line, end='')
+ self.should_erase_line = ''
+
+ def print_progress(self, line: str) -> None:
+ print(self.should_erase_line, line, sep='', end='\r')
+ self.should_erase_line = '\x1b[K'
+
+ def request_update(self) -> None:
+ self.update.set()
+
+ def emit_progress(self, harness: 'TestHarness') -> None:
+ if self.progress_test is None:
+ self.flush()
+ return
+
+ if len(self.running_tests) == 1:
+ count = f'{self.started_tests}/{self.test_count}'
+ else:
+ count = '{}-{}/{}'.format(self.started_tests - len(self.running_tests) + 1,
+ self.started_tests, self.test_count)
+
+ left = '[{}] {} '.format(count, self.spinner[self.spinner_index])
+ self.spinner_index = (self.spinner_index + 1) % len(self.spinner)
+
+ right = '{spaces} {dur:{durlen}}'.format(
+ spaces=' ' * TestResult.maxlen(),
+ dur=int(time.time() - self.progress_test.starttime),
+ durlen=harness.duration_max_len)
+ if self.progress_test.timeout:
+ right += '/{timeout:{durlen}}'.format(
+ timeout=self.progress_test.timeout,
+ durlen=harness.duration_max_len)
+ right += 's'
+ detail = self.progress_test.detail
+ if detail:
+ right += ' ' + detail
+
+ line = harness.format(self.progress_test, colorize=True,
+ max_left_width=self.max_left_width,
+ left=left, right=right)
+ self.print_progress(line)
+
+ def start(self, harness: 'TestHarness') -> None:
+ async def report_progress() -> None:
+ loop = asyncio.get_event_loop()
+ next_update = 0.0
+ self.request_update()
+ while not self.stop:
+ await self.update.wait()
+ self.update.clear()
+
+ # We may get here simply because the progress line has been
+ # overwritten, so do not always switch. Only do so every
+ # second, or if the printed test has finished
+ if loop.time() >= next_update:
+ self.progress_test = None
+ next_update = loop.time() + 1
+ loop.call_at(next_update, self.request_update)
+
+ if (self.progress_test and
+ self.progress_test.res is not TestResult.RUNNING):
+ self.progress_test = None
+
+ if not self.progress_test:
+ if not self.running_tests:
+ continue
+ # Pick a test in round robin order
+ self.progress_test = self.running_tests.pop(last=False)
+ self.running_tests.add(self.progress_test)
+
+ self.emit_progress(harness)
+ self.flush()
+
+ self.test_count = harness.test_count
+ self.cols = max(self.cols, harness.max_left_width + 30)
+
+ if self.is_tty and not harness.need_console:
+ # Account for "[aa-bb/cc] OO " in the progress report
+ self.max_left_width = 3 * len(str(self.test_count)) + 8
+ self.progress_task = asyncio.ensure_future(report_progress())
+
+ def start_test(self, harness: 'TestHarness', test: 'TestRun') -> None:
+ if harness.options.verbose and test.cmdline:
+ self.flush()
+ print(harness.format(test, mlog.colorize_console(),
+ max_left_width=self.max_left_width,
+ right=test.res.get_text(mlog.colorize_console())))
+ print(test.res.get_command_marker() + test.cmdline)
+ if test.needs_parsing:
+ pass
+ elif not test.is_parallel:
+ print(self.output_start, flush=True)
+ else:
+ print(flush=True)
+
+ self.started_tests += 1
+ self.running_tests.add(test)
+ self.running_tests.move_to_end(test, last=False)
+ self.request_update()
+
+ def shorten_log(self, harness: 'TestHarness', result: 'TestRun') -> str:
+ if not harness.options.verbose and not harness.options.print_errorlogs:
+ return ''
+
+ log = result.get_log(mlog.colorize_console(),
+ stderr_only=result.needs_parsing)
+ if harness.options.verbose:
+ return log
+
+ lines = log.splitlines()
+ if len(lines) < 100:
+ return log
+ else:
+ return str(mlog.bold('Listing only the last 100 lines from a long log.\n')) + '\n'.join(lines[-100:])
+
+ def print_log(self, harness: 'TestHarness', result: 'TestRun') -> None:
+ if not harness.options.verbose:
+ cmdline = result.cmdline
+ if not cmdline:
+ print(result.res.get_command_marker() + result.stdo)
+ return
+ print(result.res.get_command_marker() + cmdline)
+
+ log = self.shorten_log(harness, result)
+ if log:
+ print(self.output_start)
+ print_safe(log)
+ print(self.output_end)
+
+ def log_subtest(self, harness: 'TestHarness', test: 'TestRun', s: str, result: TestResult) -> None:
+ if harness.options.verbose or (harness.options.print_errorlogs and result.is_bad()):
+ self.flush()
+ print(harness.format(test, mlog.colorize_console(), max_left_width=self.max_left_width,
+ prefix=self.sub,
+ middle=s,
+ right=result.get_text(mlog.colorize_console())), flush=True)
+
+ self.request_update()
+
+ def log(self, harness: 'TestHarness', result: 'TestRun') -> None:
+ self.running_tests.remove(result)
+ if result.res is TestResult.TIMEOUT and harness.options.verbose:
+ self.flush()
+ print(f'{result.name} time out (After {result.timeout} seconds)')
+
+ if not harness.options.quiet or not result.res.is_ok():
+ self.flush()
+ if harness.options.verbose and not result.is_parallel and result.cmdline:
+ if not result.needs_parsing:
+ print(self.output_end)
+ print(harness.format(result, mlog.colorize_console(), max_left_width=self.max_left_width))
+ else:
+ print(harness.format(result, mlog.colorize_console(), max_left_width=self.max_left_width),
+ flush=True)
+ if harness.options.verbose or result.res.is_bad():
+ self.print_log(harness, result)
+ if harness.options.verbose or result.res.is_bad():
+ print(flush=True)
+
+ self.request_update()
+
+ async def finish(self, harness: 'TestHarness') -> None:
+ self.stop = True
+ self.request_update()
+ if self.progress_task:
+ await self.progress_task
+
+ if harness.collected_failures and \
+ (harness.options.print_errorlogs or harness.options.verbose):
+ print("\nSummary of Failures:\n")
+ for i, result in enumerate(harness.collected_failures, 1):
+ print(harness.format(result, mlog.colorize_console()))
+
+ print(harness.summary())
+
+
+class TextLogfileBuilder(TestFileLogger):
+ def start(self, harness: 'TestHarness') -> None:
+ self.file.write(f'Log of Meson test suite run on {datetime.datetime.now().isoformat()}\n\n')
+ inherit_env = env_tuple_to_str(os.environ.items())
+ self.file.write(f'Inherited environment: {inherit_env}\n\n')
+
+ def log(self, harness: 'TestHarness', result: 'TestRun') -> None:
+ self.file.write(harness.format(result, False) + '\n')
+ cmdline = result.cmdline
+ if cmdline:
+ starttime_str = time.strftime("%H:%M:%S", time.gmtime(result.starttime))
+ self.file.write(starttime_str + ' ' + cmdline + '\n')
+ self.file.write(dashes('output', '-', 78) + '\n')
+ self.file.write(result.get_log())
+ self.file.write(dashes('', '-', 78) + '\n\n')
+
+ async def finish(self, harness: 'TestHarness') -> None:
+ if harness.collected_failures:
+ self.file.write("\nSummary of Failures:\n\n")
+ for i, result in enumerate(harness.collected_failures, 1):
+ self.file.write(harness.format(result, False) + '\n')
+ self.file.write(harness.summary())
+
+ print(f'Full log written to {self.filename}')
+
+
+class JsonLogfileBuilder(TestFileLogger):
+ def log(self, harness: 'TestHarness', result: 'TestRun') -> None:
+ jresult = {'name': result.name,
+ 'stdout': result.stdo,
+ 'result': result.res.value,
+ 'starttime': result.starttime,
+ 'duration': result.duration,
+ 'returncode': result.returncode,
+ 'env': result.env,
+ 'command': result.cmd} # type: T.Dict[str, T.Any]
+ if result.stde:
+ jresult['stderr'] = result.stde
+ self.file.write(json.dumps(jresult) + '\n')
+
+
+class JunitBuilder(TestLogger):
+
+ """Builder for Junit test results.
+
+ Junit is impossible to stream out, it requires attributes counting the
+ total number of tests, failures, skips, and errors in the root element
+ and in each test suite. As such, we use a builder class to track each
+ test case, and calculate all metadata before writing it out.
+
+ For tests with multiple results (like from a TAP test), we record the
+ test as a suite with the project_name.test_name. This allows us to track
+ each result separately. For tests with only one result (such as exit-code
+ tests) we record each one into a suite with the name project_name. The use
+ of the project_name allows us to sort subproject tests separately from
+ the root project.
+ """
+
+ def __init__(self, filename: str) -> None:
+ self.filename = filename
+ self.root = et.Element(
+ 'testsuites', tests='0', errors='0', failures='0')
+ self.suites = {} # type: T.Dict[str, et.Element]
+
+ def log(self, harness: 'TestHarness', test: 'TestRun') -> None:
+ """Log a single test case."""
+ if test.junit is not None:
+ for suite in test.junit.findall('.//testsuite'):
+ # Assume that we don't need to merge anything here...
+ suite.attrib['name'] = '{}.{}.{}'.format(test.project, test.name, suite.attrib['name'])
+
+ # GTest can inject invalid attributes
+ for case in suite.findall('.//testcase[@result]'):
+ del case.attrib['result']
+ for case in suite.findall('.//testcase[@timestamp]'):
+ del case.attrib['timestamp']
+ self.root.append(suite)
+ return
- if state == self._YAML:
- yield self.Error('YAML block not terminated (started on line {})'.format(yaml_lineno))
+ # In this case we have a test binary with multiple results.
+ # We want to record this so that each result is recorded
+ # separately
+ if test.results:
+ suitename = f'{test.project}.{test.name}'
+ assert suitename not in self.suites or harness.options.repeat > 1, 'duplicate suite'
+
+ suite = self.suites[suitename] = et.Element(
+ 'testsuite',
+ name=suitename,
+ tests=str(len(test.results)),
+ errors=str(sum(1 for r in test.results if r.result in
+ {TestResult.INTERRUPT, TestResult.ERROR})),
+ failures=str(sum(1 for r in test.results if r.result in
+ {TestResult.FAIL, TestResult.UNEXPECTEDPASS, TestResult.TIMEOUT})),
+ skipped=str(sum(1 for r in test.results if r.result is TestResult.SKIP)),
+ time=str(test.duration),
+ )
- if not bailed_out and plan and num_tests != plan.count:
- if num_tests < plan.count:
- yield self.Error('Too few tests run (expected %d, got %d)' % (plan.count, num_tests))
+ for subtest in test.results:
+ # Both name and classname are required. Use the suite name as
+ # the class name, so that e.g. GitLab groups testcases correctly.
+ testcase = et.SubElement(suite, 'testcase', name=str(subtest), classname=suitename)
+ if subtest.result is TestResult.SKIP:
+ et.SubElement(testcase, 'skipped')
+ elif subtest.result is TestResult.ERROR:
+ et.SubElement(testcase, 'error')
+ elif subtest.result is TestResult.FAIL:
+ et.SubElement(testcase, 'failure')
+ elif subtest.result is TestResult.UNEXPECTEDPASS:
+ fail = et.SubElement(testcase, 'failure')
+ fail.text = 'Test unexpected passed.'
+ elif subtest.result is TestResult.INTERRUPT:
+ fail = et.SubElement(testcase, 'error')
+ fail.text = 'Test was interrupted by user.'
+ elif subtest.result is TestResult.TIMEOUT:
+ fail = et.SubElement(testcase, 'error')
+ fail.text = 'Test did not finish before configured timeout.'
+ if subtest.explanation:
+ et.SubElement(testcase, 'system-out').text = subtest.explanation
+ if test.stdo:
+ out = et.SubElement(suite, 'system-out')
+ out.text = test.stdo.rstrip()
+ if test.stde:
+ err = et.SubElement(suite, 'system-err')
+ err.text = test.stde.rstrip()
+ else:
+ if test.project not in self.suites:
+ suite = self.suites[test.project] = et.Element(
+ 'testsuite', name=test.project, tests='1', errors='0',
+ failures='0', skipped='0', time=str(test.duration))
else:
- yield self.Error('Too many tests run (expected %d, got %d)' % (plan.count, num_tests))
+ suite = self.suites[test.project]
+ suite.attrib['tests'] = str(int(suite.attrib['tests']) + 1)
+
+ testcase = et.SubElement(suite, 'testcase', name=test.name,
+ classname=test.project, time=str(test.duration))
+ if test.res is TestResult.SKIP:
+ et.SubElement(testcase, 'skipped')
+ suite.attrib['skipped'] = str(int(suite.attrib['skipped']) + 1)
+ elif test.res is TestResult.ERROR:
+ et.SubElement(testcase, 'error')
+ suite.attrib['errors'] = str(int(suite.attrib['errors']) + 1)
+ elif test.res is TestResult.FAIL:
+ et.SubElement(testcase, 'failure')
+ suite.attrib['failures'] = str(int(suite.attrib['failures']) + 1)
+ if test.stdo:
+ out = et.SubElement(testcase, 'system-out')
+ out.text = test.stdo.rstrip()
+ if test.stde:
+ err = et.SubElement(testcase, 'system-err')
+ err.text = test.stde.rstrip()
+
+ async def finish(self, harness: 'TestHarness') -> None:
+ """Calculate total test counts and write out the xml result."""
+ for suite in self.suites.values():
+ self.root.append(suite)
+ # Skipped is really not allowed in the "testsuits" element
+ for attr in ['tests', 'errors', 'failures']:
+ self.root.attrib[attr] = str(int(self.root.attrib[attr]) + int(suite.attrib[attr]))
+
+ tree = et.ElementTree(self.root)
+ with open(self.filename, 'wb') as f:
+ tree.write(f, encoding='utf-8', xml_declaration=True)
class TestRun:
+ TEST_NUM = 0
+ PROTOCOL_TO_CLASS: T.Dict[TestProtocol, T.Type['TestRun']] = {}
- @classmethod
- def make_exitcode(cls, test: 'TestSerialisation', test_env: T.Dict[str, str],
- returncode: int, starttime: float, duration: float,
- stdo: T.Optional[str], stde: T.Optional[str],
- cmd: T.Optional[T.List[str]]) -> 'TestRun':
- if returncode == GNU_SKIP_RETURNCODE:
+ def __new__(cls, test: TestSerialisation, *args: T.Any, **kwargs: T.Any) -> T.Any:
+ return super().__new__(TestRun.PROTOCOL_TO_CLASS[test.protocol])
+
+ def __init__(self, test: TestSerialisation, test_env: T.Dict[str, str],
+ name: str, timeout: T.Optional[int], is_parallel: bool):
+ self.res = TestResult.PENDING
+ self.test = test
+ self._num = None # type: T.Optional[int]
+ self.name = name
+ self.timeout = timeout
+ self.results = list() # type: T.List[TAPParser.Test]
+ self.returncode = 0
+ self.starttime = None # type: T.Optional[float]
+ self.duration = None # type: T.Optional[float]
+ self.stdo = None # type: T.Optional[str]
+ self.stde = None # type: T.Optional[str]
+ self.cmd = None # type: T.Optional[T.List[str]]
+ self.env = test_env # type: T.Dict[str, str]
+ self.should_fail = test.should_fail
+ self.project = test.project_name
+ self.junit = None # type: T.Optional[et.ElementTree]
+ self.is_parallel = is_parallel
+
+ def start(self, cmd: T.List[str]) -> None:
+ self.res = TestResult.RUNNING
+ self.starttime = time.time()
+ self.cmd = cmd
+
+ @property
+ def num(self) -> int:
+ if self._num is None:
+ TestRun.TEST_NUM += 1
+ self._num = TestRun.TEST_NUM
+ return self._num
+
+ @property
+ def detail(self) -> str:
+ if self.res is TestResult.PENDING:
+ return ''
+ if self.returncode:
+ return returncode_to_status(self.returncode)
+ if self.results:
+ # running or succeeded
+ passed = sum(x.result.is_ok() for x in self.results)
+ ran = sum(x.result is not TestResult.SKIP for x in self.results)
+ if passed == ran:
+ return f'{passed} subtests passed'
+ else:
+ return f'{passed}/{ran} subtests passed'
+ return ''
+
+ def _complete(self, returncode: int, res: TestResult,
+ stdo: T.Optional[str], stde: T.Optional[str]) -> None:
+ assert isinstance(res, TestResult)
+ if self.should_fail and res in (TestResult.OK, TestResult.FAIL):
+ res = TestResult.UNEXPECTEDPASS if res.is_ok() else TestResult.EXPECTEDFAIL
+
+ self.res = res
+ self.returncode = returncode
+ self.duration = time.time() - self.starttime
+ self.stdo = stdo
+ self.stde = stde
+
+ @property
+ def cmdline(self) -> T.Optional[str]:
+ if not self.cmd:
+ return None
+ test_only_env = set(self.env.items()) - set(os.environ.items())
+ return env_tuple_to_str(test_only_env) + \
+ ' '.join(sh_quote(x) for x in self.cmd)
+
+ def complete_skip(self, message: str) -> None:
+ self.starttime = time.time()
+ self._complete(GNU_SKIP_RETURNCODE, TestResult.SKIP, message, None)
+
+ def complete(self, returncode: int, res: TestResult,
+ stdo: T.Optional[str], stde: T.Optional[str]) -> None:
+ self._complete(returncode, res, stdo, stde)
+
+ def get_log(self, colorize: bool = False, stderr_only: bool = False) -> str:
+ stdo = '' if stderr_only else self.stdo
+ if self.stde:
+ res = ''
+ if stdo:
+ res += mlog.cyan('stdout:').get_text(colorize) + '\n'
+ res += stdo
+ if res[-1:] != '\n':
+ res += '\n'
+ res += mlog.cyan('stderr:').get_text(colorize) + '\n'
+ res += self.stde
+ else:
+ res = stdo
+ if res and res[-1:] != '\n':
+ res += '\n'
+ return res
+
+ @property
+ def needs_parsing(self) -> bool:
+ return False
+
+ async def parse(self, harness: 'TestHarness', lines: T.AsyncIterator[str]) -> T.Tuple[TestResult, str]:
+ async for l in lines:
+ pass
+ return TestResult.OK, ''
+
+
+class TestRunExitCode(TestRun):
+
+ def complete(self, returncode: int, res: TestResult,
+ stdo: T.Optional[str], stde: T.Optional[str]) -> None:
+ if res:
+ pass
+ elif returncode == GNU_SKIP_RETURNCODE:
res = TestResult.SKIP
elif returncode == GNU_ERROR_RETURNCODE:
res = TestResult.ERROR
- elif test.should_fail:
- res = TestResult.EXPECTEDFAIL if bool(returncode) else TestResult.UNEXPECTEDPASS
else:
res = TestResult.FAIL if bool(returncode) else TestResult.OK
- return cls(test, test_env, res, returncode, starttime, duration, stdo, stde, cmd)
+ super().complete(returncode, res, stdo, stde)
+
+TestRun.PROTOCOL_TO_CLASS[TestProtocol.EXITCODE] = TestRunExitCode
+
+
+class TestRunGTest(TestRunExitCode):
+ def complete(self, returncode: int, res: TestResult,
+ stdo: T.Optional[str], stde: T.Optional[str]) -> None:
+ filename = f'{self.test.name}.xml'
+ if self.test.workdir:
+ filename = os.path.join(self.test.workdir, filename)
+
+ try:
+ self.junit = et.parse(filename)
+ except FileNotFoundError:
+ # This can happen if the test fails to run or complete for some
+ # reason, like the rpath for libgtest isn't properly set. ExitCode
+ # will handle the failure, don't generate a stacktrace.
+ pass
+
+ super().complete(returncode, res, stdo, stde)
+
+TestRun.PROTOCOL_TO_CLASS[TestProtocol.GTEST] = TestRunGTest
+
+
+class TestRunTAP(TestRun):
+ @property
+ def needs_parsing(self) -> bool:
+ return True
+
+ def complete(self, returncode: int, res: TestResult,
+ stdo: str, stde: str) -> None:
+ if returncode != 0 and not res.was_killed():
+ res = TestResult.ERROR
+ stde = stde or ''
+ stde += f'\n(test program exited with status code {returncode})'
+
+ super().complete(returncode, res, stdo, stde)
- @classmethod
- def make_tap(cls, test: 'TestSerialisation', test_env: T.Dict[str, str],
- returncode: int, starttime: float, duration: float,
- stdo: str, stde: str,
- cmd: T.Optional[T.List[str]]) -> 'TestRun':
- res = None
- num_tests = 0
- failed = False
- num_skipped = 0
+ async def parse(self, harness: 'TestHarness', lines: T.AsyncIterator[str]) -> T.Tuple[TestResult, str]:
+ res = TestResult.OK
+ error = ''
- for i in TAPParser(io.StringIO(stdo)).parse():
+ async for i in TAPParser().parse_async(lines):
if isinstance(i, TAPParser.Bailout):
res = TestResult.ERROR
+ harness.log_subtest(self, i.message, res)
elif isinstance(i, TAPParser.Test):
- if i.result == TestResult.SKIP:
- num_skipped += 1
- elif i.result in (TestResult.FAIL, TestResult.UNEXPECTEDPASS):
- failed = True
- num_tests += 1
+ self.results.append(i)
+ if i.result.is_bad():
+ res = TestResult.FAIL
+ harness.log_subtest(self, i.name or f'subtest {i.number}', i.result)
elif isinstance(i, TAPParser.Error):
+ error = '\nTAP parsing error: ' + i.message
res = TestResult.ERROR
- stde += '\nTAP parsing error: ' + i.message
- if returncode != 0:
- res = TestResult.ERROR
- stde += '\n(test program exited with status code %d)' % (returncode,)
+ if all(t.result is TestResult.SKIP for t in self.results):
+ # This includes the case where self.results is empty
+ res = TestResult.SKIP
+ return res, error
- if res is None:
- # Now determine the overall result of the test based on the outcome of the subcases
- if num_skipped == num_tests:
- # This includes the case where num_tests is zero
- res = TestResult.SKIP
- elif test.should_fail:
- res = TestResult.EXPECTEDFAIL if failed else TestResult.UNEXPECTEDPASS
- else:
- res = TestResult.FAIL if failed else TestResult.OK
+TestRun.PROTOCOL_TO_CLASS[TestProtocol.TAP] = TestRunTAP
- return cls(test, test_env, res, returncode, starttime, duration, stdo, stde, cmd)
- def __init__(self, test: 'TestSerialisation', test_env: T.Dict[str, str],
- res: TestResult, returncode: int, starttime: float, duration: float,
- stdo: T.Optional[str], stde: T.Optional[str],
- cmd: T.Optional[T.List[str]]):
- assert isinstance(res, TestResult)
- self.res = res
- self.returncode = returncode
- self.starttime = starttime
- self.duration = duration
- self.stdo = stdo
- self.stde = stde
- self.cmd = cmd
- self.env = test_env
- self.should_fail = test.should_fail
+class TestRunRust(TestRun):
+ @property
+ def needs_parsing(self) -> bool:
+ return True
+
+ async def parse(self, harness: 'TestHarness', lines: T.AsyncIterator[str]) -> T.Tuple[TestResult, str]:
+ def parse_res(n: int, name: str, result: str) -> TAPParser.Test:
+ if result == 'ok':
+ return TAPParser.Test(n, name, TestResult.OK, None)
+ elif result == 'ignored':
+ return TAPParser.Test(n, name, TestResult.SKIP, None)
+ elif result == 'FAILED':
+ return TAPParser.Test(n, name, TestResult.FAIL, None)
+ return TAPParser.Test(n, name, TestResult.ERROR,
+ f'Unsupported output from rust test: {result}')
+
+ n = 1
+ async for line in lines:
+ if line.startswith('test ') and not line.startswith('test result'):
+ _, name, _, result = line.rstrip().split(' ')
+ name = name.replace('::', '.')
+ t = parse_res(n, name, result)
+ self.results.append(t)
+ harness.log_subtest(self, name, t.result)
+ n += 1
+
+ if all(t.result is TestResult.SKIP for t in self.results):
+ # This includes the case where self.results is empty
+ return TestResult.SKIP, ''
+ elif any(t.result is TestResult.ERROR for t in self.results):
+ return TestResult.ERROR, ''
+ elif any(t.result is TestResult.FAIL for t in self.results):
+ return TestResult.FAIL, ''
+ return TestResult.OK, ''
+
+TestRun.PROTOCOL_TO_CLASS[TestProtocol.RUST] = TestRunRust
- def get_log(self) -> str:
- res = '--- command ---\n'
- if self.cmd is None:
- res += 'NONE\n'
- else:
- test_only_env = set(self.env.items()) - set(os.environ.items())
- starttime_str = time.strftime("%H:%M:%S", time.gmtime(self.starttime))
- res += '{} {}{}\n'.format(
- starttime_str, env_tuple_to_str(test_only_env), ' '.join(self.cmd)
- )
- if self.stdo:
- res += '--- stdout ---\n'
- res += self.stdo
- if self.stde:
- if res[-1:] != '\n':
- res += '\n'
- res += '--- stderr ---\n'
- res += self.stde
- if res[-1:] != '\n':
- res += '\n'
- res += '-------\n\n'
- return res
def decode(stream: T.Union[None, bytes]) -> str:
if stream is None:
@@ -418,93 +1091,229 @@
except UnicodeDecodeError:
return stream.decode('iso-8859-1', errors='ignore')
-def write_json_log(jsonlogfile: T.TextIO, test_name: str, result: TestRun) -> None:
- jresult = {'name': test_name,
- 'stdout': result.stdo,
- 'result': result.res.value,
- 'starttime': result.starttime,
- 'duration': result.duration,
- 'returncode': result.returncode,
- 'env': result.env,
- 'command': result.cmd} # type: T.Dict[str, T.Any]
- if result.stde:
- jresult['stderr'] = result.stde
- jsonlogfile.write(json.dumps(jresult) + '\n')
+async def read_decode(reader: asyncio.StreamReader, console_mode: ConsoleUser) -> str:
+ stdo_lines = []
+ try:
+ while not reader.at_eof():
+ # Prefer splitting by line, as that produces nicer output
+ try:
+ line_bytes = await reader.readuntil(b'\n')
+ except asyncio.IncompleteReadError as e:
+ line_bytes = e.partial
+ except asyncio.LimitOverrunError as e:
+ line_bytes = await reader.readexactly(e.consumed)
+ line = decode(line_bytes)
+ stdo_lines.append(line)
+ if console_mode is ConsoleUser.STDOUT:
+ print(line, end='', flush=True)
+ return ''.join(stdo_lines)
+ except asyncio.CancelledError:
+ return ''.join(stdo_lines)
+
+# Extract lines out of the StreamReader. Print them
+# along the way if requested, and at the end collect
+# them all into a future.
+async def read_decode_lines(reader: asyncio.StreamReader, q: 'asyncio.Queue[T.Optional[str]]',
+ console_mode: ConsoleUser) -> str:
+ stdo_lines = []
+ try:
+ while not reader.at_eof():
+ line = decode(await reader.readline())
+ stdo_lines.append(line)
+ if console_mode is ConsoleUser.STDOUT:
+ print(line, end='', flush=True)
+ await q.put(line)
+ return ''.join(stdo_lines)
+ except asyncio.CancelledError:
+ return ''.join(stdo_lines)
+ finally:
+ await q.put(None)
def run_with_mono(fname: str) -> bool:
- if fname.endswith('.exe') and not (is_windows() or is_cygwin()):
- return True
- return False
+ return fname.endswith('.exe') and not (is_windows() or is_cygwin())
-def load_benchmarks(build_dir: str) -> T.List['TestSerialisation']:
- datafile = Path(build_dir) / 'meson-private' / 'meson_benchmark_setup.dat'
- if not datafile.is_file():
- raise TestException('Directory {!r} does not seem to be a Meson build directory.'.format(build_dir))
- with datafile.open('rb') as f:
- obj = T.cast(T.List['TestSerialisation'], pickle.load(f))
- return obj
-
-def load_tests(build_dir: str) -> T.List['TestSerialisation']:
- datafile = Path(build_dir) / 'meson-private' / 'meson_test_setup.dat'
- if not datafile.is_file():
- raise TestException('Directory {!r} does not seem to be a Meson build directory.'.format(build_dir))
- with datafile.open('rb') as f:
- obj = T.cast(T.List['TestSerialisation'], pickle.load(f))
- return obj
+def check_testdata(objs: T.List[TestSerialisation]) -> T.List[TestSerialisation]:
+ if not isinstance(objs, list):
+ raise MesonVersionMismatchException('', coredata_version)
+ for obj in objs:
+ if not isinstance(obj, TestSerialisation):
+ raise MesonVersionMismatchException('', coredata_version)
+ if not hasattr(obj, 'version'):
+ raise MesonVersionMismatchException('', coredata_version)
+ if major_versions_differ(obj.version, coredata_version):
+ raise MesonVersionMismatchException(obj.version, coredata_version)
+ return objs
+
+# Custom waiting primitives for asyncio
+
+async def try_wait_one(*awaitables: T.Any, timeout: T.Optional[T.Union[int, float]]) -> None:
+ """Wait for completion of one of the given futures, ignoring timeouts."""
+ await asyncio.wait(awaitables,
+ timeout=timeout, return_when=asyncio.FIRST_COMPLETED)
+
+async def queue_iter(q: 'asyncio.Queue[T.Optional[str]]') -> T.AsyncIterator[str]:
+ while True:
+ item = await q.get()
+ q.task_done()
+ if item is None:
+ break
+ yield item
+async def complete(future: asyncio.Future) -> None:
+ """Wait for completion of the given future, ignoring cancellation."""
+ try:
+ await future
+ except asyncio.CancelledError:
+ pass
+
+async def complete_all(futures: T.Iterable[asyncio.Future],
+ timeout: T.Optional[T.Union[int, float]] = None) -> None:
+ """Wait for completion of all the given futures, ignoring cancellation.
+ If timeout is not None, raise an asyncio.TimeoutError after the given
+ time has passed. asyncio.TimeoutError is only raised if some futures
+ have not completed and none have raised exceptions, even if timeout
+ is zero."""
+
+ def check_futures(futures: T.Iterable[asyncio.Future]) -> None:
+ # Raise exceptions if needed
+ left = False
+ for f in futures:
+ if not f.done():
+ left = True
+ elif not f.cancelled():
+ f.result()
+ if left:
+ raise asyncio.TimeoutError
+
+ # Python is silly and does not have a variant of asyncio.wait with an
+ # absolute time as deadline.
+ deadline = None if timeout is None else asyncio.get_event_loop().time() + timeout
+ while futures and (timeout is None or timeout > 0):
+ done, futures = await asyncio.wait(futures, timeout=timeout,
+ return_when=asyncio.FIRST_EXCEPTION)
+ check_futures(done)
+ if deadline:
+ timeout = deadline - asyncio.get_event_loop().time()
+
+ check_futures(futures)
+
+
+class TestSubprocess:
+ def __init__(self, p: asyncio.subprocess.Process,
+ stdout: T.Optional[int], stderr: T.Optional[int],
+ postwait_fn: T.Callable[[], None] = None):
+ self._process = p
+ self.stdout = stdout
+ self.stderr = stderr
+ self.stdo_task = None # type: T.Optional[asyncio.Future[str]]
+ self.stde_task = None # type: T.Optional[asyncio.Future[str]]
+ self.postwait_fn = postwait_fn # type: T.Callable[[], None]
+ self.all_futures = [] # type: T.List[asyncio.Future]
+
+ def stdout_lines(self, console_mode: ConsoleUser) -> T.AsyncIterator[str]:
+ q = asyncio.Queue() # type: asyncio.Queue[T.Optional[str]]
+ decode_coro = read_decode_lines(self._process.stdout, q, console_mode)
+ self.stdo_task = asyncio.ensure_future(decode_coro)
+ return queue_iter(q)
+
+ def communicate(self, console_mode: ConsoleUser) -> T.Tuple[T.Optional[T.Awaitable[str]],
+ T.Optional[T.Awaitable[str]]]:
+ # asyncio.ensure_future ensures that printing can
+ # run in the background, even before it is awaited
+ if self.stdo_task is None and self.stdout is not None:
+ decode_coro = read_decode(self._process.stdout, console_mode)
+ self.stdo_task = asyncio.ensure_future(decode_coro)
+ self.all_futures.append(self.stdo_task)
+ if self.stderr is not None and self.stderr != asyncio.subprocess.STDOUT:
+ decode_coro = read_decode(self._process.stderr, console_mode)
+ self.stde_task = asyncio.ensure_future(decode_coro)
+ self.all_futures.append(self.stde_task)
+
+ return self.stdo_task, self.stde_task
+
+ async def _kill(self) -> T.Optional[str]:
+ # Python does not provide multiplatform support for
+ # killing a process and all its children so we need
+ # to roll our own.
+ p = self._process
+ try:
+ if is_windows():
+ subprocess.run(['taskkill', '/F', '/T', '/PID', str(p.pid)])
+ else:
+ # Send a termination signal to the process group that setsid()
+ # created - giving it a chance to perform any cleanup.
+ os.killpg(p.pid, signal.SIGTERM)
+
+ # Make sure the termination signal actually kills the process
+ # group, otherwise retry with a SIGKILL.
+ await try_wait_one(p.wait(), timeout=0.5)
+ if p.returncode is not None:
+ return None
-class SingleTestRunner:
+ os.killpg(p.pid, signal.SIGKILL)
- def __init__(self, test: 'TestSerialisation', test_env: T.Dict[str, str],
- env: T.Dict[str, str], options: argparse.Namespace):
- self.test = test
- self.test_env = test_env
- self.env = env
- self.options = options
+ await try_wait_one(p.wait(), timeout=1)
+ if p.returncode is not None:
+ return None
+
+ # An earlier kill attempt has not worked for whatever reason.
+ # Try to kill it one last time with a direct call.
+ # If the process has spawned children, they will remain around.
+ p.kill()
+ await try_wait_one(p.wait(), timeout=1)
+ if p.returncode is not None:
+ return None
+ return 'Test process could not be killed.'
+ except ProcessLookupError:
+ # Sometimes (e.g. with Wine) this happens. There's nothing
+ # we can do, probably the process already died so just wait
+ # for the event loop to pick that up.
+ await p.wait()
+ return None
+ finally:
+ if self.stdo_task:
+ self.stdo_task.cancel()
+ if self.stde_task:
+ self.stde_task.cancel()
+
+ async def wait(self, timeout: T.Optional[int]) -> T.Tuple[int, TestResult, T.Optional[str]]:
+ p = self._process
+ result = None
+ additional_error = None
- def _get_cmd(self) -> T.Optional[T.List[str]]:
- if self.test.fname[0].endswith('.jar'):
- return ['java', '-jar'] + self.test.fname
- elif not self.test.is_cross_built and run_with_mono(self.test.fname[0]):
- return ['mono'] + self.test.fname
- else:
- if self.test.is_cross_built and self.test.needs_exe_wrapper:
- if self.test.exe_runner is None:
- # Can not run test on cross compiled executable
- # because there is no execute wrapper.
- return None
- else:
- if not self.test.exe_runner.found():
- msg = 'The exe_wrapper defined in the cross file {!r} was not ' \
- 'found. Please check the command and/or add it to PATH.'
- raise TestException(msg.format(self.test.exe_runner.name))
- return self.test.exe_runner.get_command() + self.test.fname
- else:
- return self.test.fname
+ self.all_futures.append(asyncio.ensure_future(p.wait()))
+ try:
+ await complete_all(self.all_futures, timeout=timeout)
+ except asyncio.TimeoutError:
+ additional_error = await self._kill()
+ result = TestResult.TIMEOUT
+ except asyncio.CancelledError:
+ # The main loop must have seen Ctrl-C.
+ additional_error = await self._kill()
+ result = TestResult.INTERRUPT
+ finally:
+ if self.postwait_fn:
+ self.postwait_fn()
- def run(self) -> TestRun:
- cmd = self._get_cmd()
- if cmd is None:
- skip_stdout = 'Not run because can not execute cross compiled binaries.'
- return TestRun(self.test, self.test_env, TestResult.SKIP, GNU_SKIP_RETURNCODE, time.time(), 0.0, skip_stdout, None, None)
- else:
- wrap = TestHarness.get_wrapper(self.options)
- if self.options.gdb:
- self.test.timeout = None
- return self._run_cmd(wrap + cmd + self.test.cmd_args + self.options.test_args)
+ return p.returncode or 0, result, additional_error
- def _run_cmd(self, cmd: T.List[str]) -> TestRun:
- starttime = time.time()
+class SingleTestRunner:
+
+ def __init__(self, test: TestSerialisation, env: T.Dict[str, str], name: str,
+ options: argparse.Namespace):
+ self.test = test
+ self.options = options
+ self.cmd = self._get_cmd()
- if len(self.test.extra_paths) > 0:
- self.env['PATH'] = os.pathsep.join(self.test.extra_paths + ['']) + self.env['PATH']
+ if self.cmd and self.test.extra_paths:
+ env['PATH'] = os.pathsep.join(self.test.extra_paths + ['']) + env['PATH']
winecmd = []
- for c in cmd:
+ for c in self.cmd:
winecmd.append(c)
if os.path.basename(c).startswith('wine'):
- self.env['WINEPATH'] = get_wine_shortpath(
+ env['WINEPATH'] = get_wine_shortpath(
winecmd,
- ['Z:' + p for p in self.test.extra_paths] + self.env.get('WINEPATH', '').split(';')
+ ['Z:' + p for p in self.test.extra_paths] + env.get('WINEPATH', '').split(';')
)
break
@@ -513,17 +1322,81 @@
# it ourselves. We do this unconditionally for regular tests
# because it is extremely useful to have.
# Setting MALLOC_PERTURB_="0" will completely disable this feature.
- if ('MALLOC_PERTURB_' not in self.env or not self.env['MALLOC_PERTURB_']) and not self.options.benchmark:
- self.env['MALLOC_PERTURB_'] = str(random.randint(1, 255))
+ if ('MALLOC_PERTURB_' not in env or not env['MALLOC_PERTURB_']) and not options.benchmark:
+ env['MALLOC_PERTURB_'] = str(random.randint(1, 255))
+
+ if self.options.gdb or self.test.timeout is None or self.test.timeout <= 0:
+ timeout = None
+ elif self.options.timeout_multiplier is None:
+ timeout = self.test.timeout
+ elif self.options.timeout_multiplier <= 0:
+ timeout = None
+ else:
+ timeout = self.test.timeout * self.options.timeout_multiplier
+
+ is_parallel = test.is_parallel and self.options.num_processes > 1 and not self.options.gdb
+ self.runobj = TestRun(test, env, name, timeout, is_parallel)
- stdout = None
- stderr = None
- if not self.options.verbose:
- stdout = tempfile.TemporaryFile("wb+")
- stderr = tempfile.TemporaryFile("wb+") if self.options.split else stdout
- if self.test.protocol == 'tap' and stderr is stdout:
- stdout = tempfile.TemporaryFile("wb+")
+ if self.options.gdb:
+ self.console_mode = ConsoleUser.GDB
+ elif self.options.verbose and not is_parallel and not self.runobj.needs_parsing:
+ self.console_mode = ConsoleUser.STDOUT
+ else:
+ self.console_mode = ConsoleUser.LOGGER
+ def _get_test_cmd(self) -> T.Optional[T.List[str]]:
+ if self.test.fname[0].endswith('.jar'):
+ return ['java', '-jar'] + self.test.fname
+ elif not self.test.is_cross_built and run_with_mono(self.test.fname[0]):
+ return ['mono'] + self.test.fname
+ elif self.test.cmd_is_built and self.test.is_cross_built and self.test.needs_exe_wrapper:
+ if self.test.exe_wrapper is None:
+ # Can not run test on cross compiled executable
+ # because there is no execute wrapper.
+ return None
+ elif self.test.cmd_is_built:
+ # If the command is not built (ie, its a python script),
+ # then we don't check for the exe-wrapper
+ if not self.test.exe_wrapper.found():
+ msg = ('The exe_wrapper defined in the cross file {!r} was not '
+ 'found. Please check the command and/or add it to PATH.')
+ raise TestException(msg.format(self.test.exe_wrapper.name))
+ return self.test.exe_wrapper.get_command() + self.test.fname
+ return self.test.fname
+
+ def _get_cmd(self) -> T.Optional[T.List[str]]:
+ test_cmd = self._get_test_cmd()
+ if not test_cmd:
+ return None
+ return TestHarness.get_wrapper(self.options) + test_cmd
+
+ @property
+ def is_parallel(self) -> bool:
+ return self.runobj.is_parallel
+
+ @property
+ def visible_name(self) -> str:
+ return self.runobj.name
+
+ @property
+ def timeout(self) -> T.Optional[int]:
+ return self.runobj.timeout
+
+ async def run(self, harness: 'TestHarness') -> TestRun:
+ if self.cmd is None:
+ skip_stdout = 'Not run because can not execute cross compiled binaries.'
+ harness.log_start_test(self.runobj)
+ self.runobj.complete_skip(skip_stdout)
+ else:
+ cmd = self.cmd + self.test.cmd_args + self.options.test_args
+ self.runobj.start(cmd)
+ harness.log_start_test(self.runobj)
+ await self._run_cmd(harness, cmd)
+ return self.runobj
+
+ async def _run_subprocess(self, args: T.List[str], *,
+ stdout: int, stderr: int,
+ env: T.Dict[str, str], cwd: T.Optional[str]) -> TestSubprocess:
# Let gdb handle ^C instead of us
if self.options.gdb:
previous_sigint_handler = signal.getsignal(signal.SIGINT)
@@ -539,145 +1412,145 @@
# We don't want setsid() in gdb because gdb needs the
# terminal in order to handle ^C and not show tcsetpgrp()
# errors avoid not being able to use the terminal.
- os.setsid() # type: ignore
+ os.setsid()
- p = subprocess.Popen(cmd,
- stdout=stdout,
- stderr=stderr,
- env=self.env,
- cwd=self.test.workdir,
- preexec_fn=preexec_fn if not is_windows() else None)
- timed_out = False
- kill_test = False
- if self.test.timeout is None:
- timeout = None
- elif self.options.timeout_multiplier is not None:
- timeout = self.test.timeout * self.options.timeout_multiplier
- else:
- timeout = self.test.timeout
- try:
- p.communicate(timeout=timeout)
- except subprocess.TimeoutExpired:
- if self.options.verbose:
- print('{} time out (After {} seconds)'.format(self.test.name, timeout))
- timed_out = True
- except KeyboardInterrupt:
- mlog.warning('CTRL-C detected while running %s' % (self.test.name))
- kill_test = True
- finally:
+ def postwait_fn() -> None:
if self.options.gdb:
# Let us accept ^C again
signal.signal(signal.SIGINT, previous_sigint_handler)
- additional_error = None
-
- if kill_test or timed_out:
- # Python does not provide multiplatform support for
- # killing a process and all its children so we need
- # to roll our own.
- if is_windows():
- subprocess.run(['taskkill', '/F', '/T', '/PID', str(p.pid)])
- else:
- try:
- # Kill the process group that setsid() created.
- os.killpg(p.pid, signal.SIGKILL) # type: ignore
- except ProcessLookupError:
- # Sometimes (e.g. with Wine) this happens.
- # There's nothing we can do (maybe the process
- # already died) so carry on.
- pass
- try:
- p.communicate(timeout=1)
- except subprocess.TimeoutExpired:
- # An earlier kill attempt has not worked for whatever reason.
- # Try to kill it one last time with a direct call.
- # If the process has spawned children, they will remain around.
- p.kill()
- try:
- p.communicate(timeout=1)
- except subprocess.TimeoutExpired:
- additional_error = 'Test process could not be killed.'
- except ValueError:
- additional_error = 'Could not read output. Maybe the process has redirected its stdout/stderr?'
- endtime = time.time()
- duration = endtime - starttime
- if additional_error is None:
- if stdout is None:
- stdo = ''
- else:
- stdout.seek(0)
- stdo = decode(stdout.read())
- if stderr is None or stderr is stdout:
- stde = ''
- else:
- stderr.seek(0)
- stde = decode(stderr.read())
+ p = await asyncio.create_subprocess_exec(*args,
+ stdout=stdout,
+ stderr=stderr,
+ env=env,
+ cwd=cwd,
+ preexec_fn=preexec_fn if not is_windows() else None)
+ return TestSubprocess(p, stdout=stdout, stderr=stderr,
+ postwait_fn=postwait_fn if not is_windows() else None)
+
+ async def _run_cmd(self, harness: 'TestHarness', cmd: T.List[str]) -> None:
+ if self.console_mode is ConsoleUser.GDB:
+ stdout = None
+ stderr = None
else:
- stdo = ""
- stde = additional_error
- if timed_out:
- return TestRun(self.test, self.test_env, TestResult.TIMEOUT, p.returncode, starttime, duration, stdo, stde, cmd)
- else:
- if self.test.protocol == 'exitcode':
- return TestRun.make_exitcode(self.test, self.test_env, p.returncode, starttime, duration, stdo, stde, cmd)
- else:
- if self.options.verbose:
- print(stdo, end='')
- return TestRun.make_tap(self.test, self.test_env, p.returncode, starttime, duration, stdo, stde, cmd)
+ stdout = asyncio.subprocess.PIPE
+ stderr = asyncio.subprocess.STDOUT \
+ if not self.options.split and not self.runobj.needs_parsing \
+ else asyncio.subprocess.PIPE
+
+ extra_cmd = [] # type: T.List[str]
+ if self.test.protocol is TestProtocol.GTEST:
+ gtestname = self.test.name
+ if self.test.workdir:
+ gtestname = os.path.join(self.test.workdir, self.test.name)
+ extra_cmd.append(f'--gtest_output=xml:{gtestname}.xml')
+
+ p = await self._run_subprocess(cmd + extra_cmd,
+ stdout=stdout,
+ stderr=stderr,
+ env=self.runobj.env,
+ cwd=self.test.workdir)
+
+ parse_task = None
+ if self.runobj.needs_parsing:
+ parse_coro = self.runobj.parse(harness, p.stdout_lines(self.console_mode))
+ parse_task = asyncio.ensure_future(parse_coro)
+
+ stdo_task, stde_task = p.communicate(self.console_mode)
+ returncode, result, additional_error = await p.wait(self.runobj.timeout)
+
+ if parse_task is not None:
+ res, error = await parse_task
+ if error:
+ additional_error = join_lines(additional_error, error)
+ result = result or res
+
+ stdo = await stdo_task if stdo_task else ''
+ stde = await stde_task if stde_task else ''
+ stde = join_lines(stde, additional_error)
+ self.runobj.complete(returncode, result, stdo, stde)
class TestHarness:
def __init__(self, options: argparse.Namespace):
self.options = options
- self.collected_logs = [] # type: T.List[str]
+ self.collected_failures = [] # type: T.List[TestRun]
self.fail_count = 0
self.expectedfail_count = 0
self.unexpectedpass_count = 0
self.success_count = 0
self.skip_count = 0
self.timeout_count = 0
+ self.test_count = 0
+ self.name_max_len = 0
self.is_run = False
- self.tests = None
- self.logfilename = None # type: T.Optional[str]
- self.logfile = None # type: T.Optional[T.TextIO]
- self.jsonlogfile = None # type: T.Optional[T.TextIO]
- if self.options.benchmark:
- self.tests = load_benchmarks(options.wd)
- else:
- self.tests = load_tests(options.wd)
+ self.loggers = [] # type: T.List[TestLogger]
+ self.loggers.append(ConsoleLogger())
+ self.need_console = False
+
+ self.logfile_base = None # type: T.Optional[str]
+ if self.options.logbase and not self.options.gdb:
+ namebase = None
+ self.logfile_base = os.path.join(self.options.wd, 'meson-logs', self.options.logbase)
+
+ if self.options.wrapper:
+ namebase = os.path.basename(self.get_wrapper(self.options)[0])
+ elif self.options.setup:
+ namebase = self.options.setup.replace(":", "_")
+
+ if namebase:
+ self.logfile_base += '-' + namebase.replace(' ', '_')
+
+ startdir = os.getcwd()
+ try:
+ os.chdir(self.options.wd)
+ self.build_data = build.load(os.getcwd())
+ if not self.options.setup:
+ self.options.setup = self.build_data.test_setup_default_name
+ if self.options.benchmark:
+ self.tests = self.load_tests('meson_benchmark_setup.dat')
+ else:
+ self.tests = self.load_tests('meson_test_setup.dat')
+ finally:
+ os.chdir(startdir)
+
ss = set()
for t in self.tests:
for s in t.suite:
ss.add(s)
self.suites = list(ss)
- def __del__(self) -> None:
- self.close_logfiles()
+ def load_tests(self, file_name: str) -> T.List[TestSerialisation]:
+ datafile = Path('meson-private') / file_name
+ if not datafile.is_file():
+ raise TestException(f'Directory {self.options.wd!r} does not seem to be a Meson build directory.')
+ with datafile.open('rb') as f:
+ objs = check_testdata(pickle.load(f))
+ return objs
- def __enter__(self):
+ def __enter__(self) -> 'TestHarness':
return self
- def __exit__(self, exc_type, exc_value, traceback) -> None:
+ def __exit__(self, exc_type: T.Any, exc_value: T.Any, traceback: T.Any) -> None:
self.close_logfiles()
def close_logfiles(self) -> None:
- if self.logfile:
- self.logfile.close()
- self.logfile = None
- if self.jsonlogfile:
- self.jsonlogfile.close()
- self.jsonlogfile = None
-
- def merge_suite_options(self, options: argparse.Namespace, test: 'TestSerialisation') -> T.Dict[str, str]:
- if ':' in options.setup:
- if options.setup not in self.build_data.test_setups:
- sys.exit("Unknown test setup '%s'." % options.setup)
- current = self.build_data.test_setups[options.setup]
+ for l in self.loggers:
+ l.close()
+
+ def get_test_setup(self, test: T.Optional[TestSerialisation]) -> build.TestSetup:
+ if ':' in self.options.setup:
+ if self.options.setup not in self.build_data.test_setups:
+ sys.exit(f"Unknown test setup '{self.options.setup}'.")
+ return self.build_data.test_setups[self.options.setup]
else:
- full_name = test.project_name + ":" + options.setup
+ full_name = test.project_name + ":" + self.options.setup
if full_name not in self.build_data.test_setups:
- sys.exit("Test setup '%s' not found from project '%s'." % (options.setup, test.project_name))
- current = self.build_data.test_setups[full_name]
+ sys.exit(f"Test setup '{self.options.setup}' not found from project '{test.project_name}'.")
+ return self.build_data.test_setups[full_name]
+
+ def merge_setup_options(self, options: argparse.Namespace, test: TestSerialisation) -> T.Dict[str, str]:
+ current = self.get_test_setup(test)
if not options.gdb:
options.gdb = current.gdb
if options.gdb:
@@ -686,23 +1559,25 @@
options.timeout_multiplier = current.timeout_multiplier
# if options.env is None:
# options.env = current.env # FIXME, should probably merge options here.
- if options.wrapper is not None and current.exe_wrapper is not None:
- sys.exit('Conflict: both test setup and command line specify an exe wrapper.')
if options.wrapper is None:
options.wrapper = current.exe_wrapper
+ elif current.exe_wrapper:
+ sys.exit('Conflict: both test setup and command line specify an exe wrapper.')
return current.env.get_env(os.environ.copy())
- def get_test_runner(self, test: 'TestSerialisation') -> SingleTestRunner:
+ def get_test_runner(self, test: TestSerialisation) -> SingleTestRunner:
+ name = self.get_pretty_suite(test)
options = deepcopy(self.options)
- if not options.setup:
- options.setup = self.build_data.test_setup_default_name
- if options.setup:
- env = self.merge_suite_options(options, test)
+ if self.options.setup:
+ env = self.merge_setup_options(options, test)
else:
env = os.environ.copy()
test_env = test.env.get_env(env)
env.update(test_env)
- return SingleTestRunner(test, test_env, env, options)
+ if (test.is_cross_built and test.needs_exe_wrapper and
+ test.exe_wrapper and test.exe_wrapper.found()):
+ env['MESON_EXE_WRAPPER'] = join_args(test.exe_wrapper.get_command())
+ return SingleTestRunner(test, env, name, options)
def process_test_result(self, result: TestRun) -> None:
if result.res is TestResult.TIMEOUT:
@@ -711,83 +1586,71 @@
self.skip_count += 1
elif result.res is TestResult.OK:
self.success_count += 1
- elif result.res is TestResult.FAIL or result.res is TestResult.ERROR:
+ elif result.res in {TestResult.FAIL, TestResult.ERROR, TestResult.INTERRUPT}:
self.fail_count += 1
elif result.res is TestResult.EXPECTEDFAIL:
self.expectedfail_count += 1
elif result.res is TestResult.UNEXPECTEDPASS:
self.unexpectedpass_count += 1
else:
- sys.exit('Unknown test result encountered: {}'.format(result.res))
+ sys.exit(f'Unknown test result encountered: {result.res}')
- def print_stats(self, numlen: int, tests: T.List['TestSerialisation'],
- name: str, result: TestRun, i: int) -> None:
- startpad = ' ' * (numlen - len('%d' % (i + 1)))
- num = '%s%d/%d' % (startpad, i + 1, len(tests))
- padding1 = ' ' * (38 - len(name))
- padding2 = ' ' * (8 - len(result.res.value))
- status = ''
-
- if result.res is TestResult.FAIL:
- status = returncode_to_status(result.returncode)
- result_str = '%s %s %s%s%s%5.2f s %s' % \
- (num, name, padding1, result.res.value, padding2, result.duration,
- status)
- ok_statuses = (TestResult.OK, TestResult.EXPECTEDFAIL)
- bad_statuses = (TestResult.FAIL, TestResult.TIMEOUT, TestResult.UNEXPECTEDPASS,
- TestResult.ERROR)
- if not self.options.quiet or result.res not in ok_statuses:
- if result.res not in ok_statuses and mlog.colorize_console:
- if result.res in bad_statuses:
- decorator = mlog.red
- elif result.res is TestResult.SKIP:
- decorator = mlog.yellow
- else:
- sys.exit('Unreachable code was ... well ... reached.')
- print(decorator(result_str).get_text(True))
- else:
- print(result_str)
- result_str += "\n\n" + result.get_log()
- if result.res in bad_statuses:
- if self.options.print_errorlogs:
- self.collected_logs.append(result_str)
- if self.logfile:
- self.logfile.write(result_str)
- if self.jsonlogfile:
- write_json_log(self.jsonlogfile, name, result)
-
- def print_summary(self) -> None:
- msg = '''
-Ok: %4d
-Expected Fail: %4d
-Fail: %4d
-Unexpected Pass: %4d
-Skipped: %4d
-Timeout: %4d
-''' % (self.success_count, self.expectedfail_count, self.fail_count,
- self.unexpectedpass_count, self.skip_count, self.timeout_count)
- print(msg)
- if self.logfile:
- self.logfile.write(msg)
-
- def print_collected_logs(self) -> None:
- if len(self.collected_logs) > 0:
- if len(self.collected_logs) > 10:
- print('\nThe output from 10 first failed tests:\n')
- else:
- print('\nThe output from the failed tests:\n')
- for log in self.collected_logs[:10]:
- lines = log.splitlines()
- if len(lines) > 104:
- print('\n'.join(lines[0:4]))
- print('--- Listing only the last 100 lines from a long log. ---')
- lines = lines[-100:]
- for line in lines:
- try:
- print(line)
- except UnicodeEncodeError:
- line = line.encode('ascii', errors='replace').decode()
- print(line)
+ if result.res.is_bad():
+ self.collected_failures.append(result)
+ for l in self.loggers:
+ l.log(self, result)
+
+ @property
+ def numlen(self) -> int:
+ return len(str(self.test_count))
+
+ @property
+ def max_left_width(self) -> int:
+ return 2 * self.numlen + 2
+
+ def format(self, result: TestRun, colorize: bool,
+ max_left_width: int = 0,
+ prefix: str = '',
+ left: T.Optional[str] = None,
+ middle: T.Optional[str] = None,
+ right: T.Optional[str] = None) -> str:
+
+ if left is None:
+ left = '{num:{numlen}}/{testcount} '.format(
+ numlen=self.numlen,
+ num=result.num,
+ testcount=self.test_count)
+
+ # A non-default max_left_width lets the logger print more stuff before the
+ # name, while ensuring that the rightmost columns remain aligned.
+ max_left_width = max(max_left_width, self.max_left_width)
+
+ if middle is None:
+ middle = result.name
+ extra_mid_width = max_left_width + self.name_max_len + 1 - uniwidth(middle) - uniwidth(left) - uniwidth(prefix)
+ middle += ' ' * max(1, extra_mid_width)
+
+ if right is None:
+ right = '{res} {dur:{durlen}.2f}s'.format(
+ res=result.res.get_text(colorize),
+ dur=result.duration,
+ durlen=self.duration_max_len + 3)
+ detail = result.detail
+ if detail:
+ right += ' ' + detail
+ return prefix + left + middle + right
+
+ def summary(self) -> str:
+ return textwrap.dedent('''
+
+ Ok: {:<4}
+ Expected Fail: {:<4}
+ Fail: {:<4}
+ Unexpected Pass: {:<4}
+ Skipped: {:<4}
+ Timeout: {:<4}
+ ''').format(self.success_count, self.expectedfail_count, self.fail_count,
+ self.unexpectedpass_count, self.skip_count, self.timeout_count)
def total_failure_count(self) -> int:
return self.fail_count + self.unexpectedpass_count + self.timeout_count
@@ -799,20 +1662,45 @@
tests = self.get_tests()
if not tests:
return 0
- self.run_tests(tests)
+ if not self.options.no_rebuild and not rebuild_deps(self.options.wd, tests):
+ # We return 125 here in case the build failed.
+ # The reason is that exit code 125 tells `git bisect run` that the current
+ # commit should be skipped. Thus users can directly use `meson test` to
+ # bisect without needing to handle the does-not-build case separately in a
+ # wrapper script.
+ sys.exit(125)
+
+ self.name_max_len = max(uniwidth(self.get_pretty_suite(test)) for test in tests)
+ startdir = os.getcwd()
+ try:
+ os.chdir(self.options.wd)
+ runners = [] # type: T.List[SingleTestRunner]
+ for i in range(self.options.repeat):
+ runners.extend(self.get_test_runner(test) for test in tests)
+ if i == 0:
+ self.duration_max_len = max(len(str(int(runner.timeout or 99)))
+ for runner in runners)
+ # Disable the progress report if it gets in the way
+ self.need_console = any(runner.console_mode is not ConsoleUser.LOGGER
+ for runner in runners)
+
+ self.test_count = len(runners)
+ self.run_tests(runners)
+ finally:
+ os.chdir(startdir)
return self.total_failure_count()
@staticmethod
def split_suite_string(suite: str) -> T.Tuple[str, str]:
if ':' in suite:
- # mypy can't figure out that str.split(n, 1) will return a list of
- # length 2, so we have to help it.
- return T.cast(T.Tuple[str, str], tuple(suite.split(':', 1)))
+ split = suite.split(':', 1)
+ assert len(split) == 2
+ return split[0], split[1]
else:
return suite, ""
@staticmethod
- def test_in_suites(test: 'TestSerialisation', suites: T.List[str]) -> bool:
+ def test_in_suites(test: TestSerialisation, suites: T.List[str]) -> bool:
for suite in suites:
(prj_match, st_match) = TestHarness.split_suite_string(suite)
for prjst in test.suite:
@@ -843,27 +1731,52 @@
return True
return False
- def test_suitable(self, test: 'TestSerialisation') -> bool:
- return ((not self.options.include_suites or
- TestHarness.test_in_suites(test, self.options.include_suites)) and not
- TestHarness.test_in_suites(test, self.options.exclude_suites))
+ def test_suitable(self, test: TestSerialisation) -> bool:
+ if TestHarness.test_in_suites(test, self.options.exclude_suites):
+ return False
+
+ if self.options.include_suites:
+ # Both force inclusion (overriding add_test_setup) and exclude
+ # everything else
+ return TestHarness.test_in_suites(test, self.options.include_suites)
+
+ if self.options.setup:
+ setup = self.get_test_setup(test)
+ if TestHarness.test_in_suites(test, setup.exclude_suites):
+ return False
+
+ return True
+
+ def tests_from_args(self, tests: T.List[TestSerialisation]) -> T.Generator[TestSerialisation, None, None]:
+ '''
+ Allow specifying test names like "meson test foo1 foo2", where test('foo1', ...)
+
+ Also support specifying the subproject to run tests from like
+ "meson test subproj:" (all tests inside subproj) or "meson test subproj:foo1"
+ to run foo1 inside subproj. Coincidentally also "meson test :foo1" to
+ run all tests with that name across all subprojects, which is
+ identical to "meson test foo1"
+ '''
+ for arg in self.options.args:
+ if ':' in arg:
+ subproj, name = arg.split(':', maxsplit=1)
+ else:
+ subproj, name = '', arg
+ for t in tests:
+ if subproj and t.project_name != subproj:
+ continue
+ if name and t.name != name:
+ continue
+ yield t
- def get_tests(self) -> T.List['TestSerialisation']:
+ def get_tests(self) -> T.List[TestSerialisation]:
if not self.tests:
print('No tests defined.')
return []
- if len(self.options.include_suites) or len(self.options.exclude_suites):
- tests = []
- for tst in self.tests:
- if self.test_suitable(tst):
- tests.append(tst)
- else:
- tests = self.tests
-
- # allow specifying test names like "meson test foo1 foo2", where test('foo1', ...)
+ tests = [t for t in self.tests if self.test_suitable(t)]
if self.options.args:
- tests = [t for t in tests if t.name in self.options.args]
+ tests = list(self.tests_from_args(tests))
if not tests:
print('No suitable tests defined.')
@@ -871,30 +1784,17 @@
return tests
- def open_log_files(self) -> None:
- if not self.options.logbase or self.options.verbose:
- return
+ def flush_logfiles(self) -> None:
+ for l in self.loggers:
+ l.flush()
- namebase = None
- logfile_base = os.path.join(self.options.wd, 'meson-logs', self.options.logbase)
-
- if self.options.wrapper:
- namebase = os.path.basename(self.get_wrapper(self.options)[0])
- elif self.options.setup:
- namebase = self.options.setup.replace(":", "_")
-
- if namebase:
- logfile_base += '-' + namebase.replace(' ', '_')
- self.logfilename = logfile_base + '.txt'
- self.jsonlogfilename = logfile_base + '.json'
-
- self.jsonlogfile = open(self.jsonlogfilename, 'w', encoding='utf-8', errors='replace')
- self.logfile = open(self.logfilename, 'w', encoding='utf-8', errors='surrogateescape')
+ def open_logfiles(self) -> None:
+ if not self.logfile_base:
+ return
- self.logfile.write('Log of Meson test suite run on %s\n\n'
- % datetime.datetime.now().isoformat())
- inherit_env = env_tuple_to_str(os.environ.items())
- self.logfile.write('Inherited environment: {}\n\n'.format(inherit_env))
+ self.loggers.append(JunitBuilder(self.logfile_base + '.junit.xml'))
+ self.loggers.append(JsonLogfileBuilder(self.logfile_base + '.json'))
+ self.loggers.append(TextLogfileBuilder(self.logfile_base + '.txt', errors='surrogateescape'))
@staticmethod
def get_wrapper(options: argparse.Namespace) -> T.List[str]:
@@ -909,77 +1809,125 @@
wrap += options.wrapper
return wrap
- def get_pretty_suite(self, test: 'TestSerialisation') -> str:
+ def get_pretty_suite(self, test: TestSerialisation) -> str:
if len(self.suites) > 1 and test.suite:
rv = TestHarness.split_suite_string(test.suite[0])[0]
s = "+".join(TestHarness.split_suite_string(s)[1] for s in test.suite)
- if len(s):
+ if s:
rv += ":"
return rv + s + " / " + test.name
else:
return test.name
- def run_tests(self, tests: T.List['TestSerialisation']) -> None:
- executor = None
- futures = [] # type: T.List[T.Tuple[conc.Future[TestRun], int, T.List[TestSerialisation], str, int]]
- numlen = len('%d' % len(tests))
- self.open_log_files()
- startdir = os.getcwd()
- if self.options.wd:
- os.chdir(self.options.wd)
- self.build_data = build.load(os.getcwd())
+ def run_tests(self, runners: T.List[SingleTestRunner]) -> None:
+ try:
+ self.open_logfiles()
+ # Replace with asyncio.run once we can require Python 3.7
+ loop = asyncio.get_event_loop()
+ loop.run_until_complete(self._run_tests(runners))
+ finally:
+ self.close_logfiles()
+ def log_subtest(self, test: TestRun, s: str, res: TestResult) -> None:
+ for l in self.loggers:
+ l.log_subtest(self, test, s, res)
+
+ def log_start_test(self, test: TestRun) -> None:
+ for l in self.loggers:
+ l.start_test(self, test)
+
+ async def _run_tests(self, runners: T.List[SingleTestRunner]) -> None:
+ semaphore = asyncio.Semaphore(self.options.num_processes)
+ futures = deque() # type: T.Deque[asyncio.Future]
+ running_tests = dict() # type: T.Dict[asyncio.Future, str]
+ interrupted = False
+ ctrlc_times = deque(maxlen=MAX_CTRLC) # type: T.Deque[float]
+
+ async def run_test(test: SingleTestRunner) -> None:
+ async with semaphore:
+ if interrupted or (self.options.repeat > 1 and self.fail_count):
+ return
+ res = await test.run(self)
+ self.process_test_result(res)
+
+ def test_done(f: asyncio.Future) -> None:
+ if not f.cancelled():
+ f.result()
+ futures.remove(f)
+ try:
+ del running_tests[f]
+ except KeyError:
+ pass
+
+ def cancel_one_test(warn: bool) -> None:
+ future = futures.popleft()
+ futures.append(future)
+ if warn:
+ self.flush_logfiles()
+ mlog.warning('CTRL-C detected, interrupting {}'.format(running_tests[future]))
+ del running_tests[future]
+ future.cancel()
+
+ def cancel_all_tests() -> None:
+ nonlocal interrupted
+ interrupted = True
+ while running_tests:
+ cancel_one_test(False)
+
+ def sigterm_handler() -> None:
+ if interrupted:
+ return
+ self.flush_logfiles()
+ mlog.warning('Received SIGTERM, exiting')
+ cancel_all_tests()
+
+ def sigint_handler() -> None:
+ # We always pick the longest-running future that has not been cancelled
+ # If all the tests have been CTRL-C'ed, just stop
+ nonlocal interrupted
+ if interrupted:
+ return
+ ctrlc_times.append(asyncio.get_event_loop().time())
+ if len(ctrlc_times) == MAX_CTRLC and ctrlc_times[-1] - ctrlc_times[0] < 1:
+ self.flush_logfiles()
+ mlog.warning('CTRL-C detected, exiting')
+ cancel_all_tests()
+ elif running_tests:
+ cancel_one_test(True)
+ else:
+ self.flush_logfiles()
+ mlog.warning('CTRL-C detected, exiting')
+ interrupted = True
+
+ for l in self.loggers:
+ l.start(self)
+
+ if sys.platform != 'win32':
+ if os.getpgid(0) == os.getpid():
+ asyncio.get_event_loop().add_signal_handler(signal.SIGINT, sigint_handler)
+ else:
+ asyncio.get_event_loop().add_signal_handler(signal.SIGINT, sigterm_handler)
+ asyncio.get_event_loop().add_signal_handler(signal.SIGTERM, sigterm_handler)
try:
- for _ in range(self.options.repeat):
- for i, test in enumerate(tests):
- visible_name = self.get_pretty_suite(test)
- single_test = self.get_test_runner(test)
-
- if not test.is_parallel or self.options.num_processes == 1 or single_test.options.gdb:
- self.drain_futures(futures)
- futures = []
- res = single_test.run()
- self.process_test_result(res)
- self.print_stats(numlen, tests, visible_name, res, i)
- else:
- if not executor:
- executor = conc.ThreadPoolExecutor(max_workers=self.options.num_processes)
- f = executor.submit(single_test.run)
- futures.append((f, numlen, tests, visible_name, i))
- if self.options.repeat > 1 and self.fail_count:
- break
+ for runner in runners:
+ if not runner.is_parallel:
+ await complete_all(futures)
+ future = asyncio.ensure_future(run_test(runner))
+ futures.append(future)
+ running_tests[future] = runner.visible_name
+ future.add_done_callback(test_done)
+ if not runner.is_parallel:
+ await complete(future)
if self.options.repeat > 1 and self.fail_count:
break
- self.drain_futures(futures)
- self.print_summary()
- self.print_collected_logs()
-
- if self.logfilename:
- print('Full log written to %s' % self.logfilename)
+ await complete_all(futures)
finally:
- os.chdir(startdir)
-
- def drain_futures(self, futures: T.List[T.Tuple['conc.Future[TestRun]', int, T.List['TestSerialisation'], str, int]]) -> None:
- for x in futures:
- (result, numlen, tests, name, i) = x
- if self.options.repeat > 1 and self.fail_count:
- result.cancel()
- if self.options.verbose:
- result.result()
- self.process_test_result(result.result())
- self.print_stats(numlen, tests, name, result.result(), i)
-
- def run_special(self) -> int:
- '''Tests run by the user, usually something like "under gdb 1000 times".'''
- if self.is_run:
- raise RuntimeError('Can not use run_special after a full run.')
- tests = self.get_tests()
- if not tests:
- return 0
- self.run_tests(tests)
- return self.total_failure_count()
-
+ if sys.platform != 'win32':
+ asyncio.get_event_loop().remove_signal_handler(signal.SIGINT)
+ asyncio.get_event_loop().remove_signal_handler(signal.SIGTERM)
+ for l in self.loggers:
+ await l.finish(self)
def list_tests(th: TestHarness) -> bool:
tests = th.get_tests()
@@ -987,7 +1935,13 @@
print(th.get_pretty_suite(t))
return not tests
-def rebuild_all(wd: str) -> bool:
+def rebuild_deps(wd: str, tests: T.List[TestSerialisation]) -> bool:
+ def convert_path_to_target(path: str) -> str:
+ path = os.path.relpath(path, wd)
+ if os.sep != '/':
+ path = path.replace(os.sep, '/')
+ return path
+
if not (Path(wd) / 'build.ninja').is_file():
print('Only ninja backend is supported to rebuild tests before running them.')
return True
@@ -997,9 +1951,23 @@
print("Can't find ninja, can't rebuild test.")
return False
- ret = subprocess.run([ninja, '-C', wd]).returncode
+ depends = set() # type: T.Set[str]
+ targets = set() # type: T.Set[str]
+ intro_targets = dict() # type: T.Dict[str, T.List[str]]
+ for target in load_info_file(get_infodir(wd), kind='targets'):
+ intro_targets[target['id']] = [
+ convert_path_to_target(f)
+ for f in target['filename']]
+ for t in tests:
+ for d in t.depends:
+ if d in depends:
+ continue
+ depends.update(d)
+ targets.update(intro_targets[d])
+
+ ret = subprocess.run(ninja + ['-C', wd] + sorted(targets)).returncode
if ret != 0:
- print('Could not rebuild {}'.format(wd))
+ print(f'Could not rebuild {wd}')
return False
return True
@@ -1023,27 +1991,24 @@
if options.wrapper:
check_bin = options.wrapper[0]
+ if sys.platform == 'win32':
+ loop = asyncio.ProactorEventLoop()
+ asyncio.set_event_loop(loop)
+
if check_bin is not None:
exe = ExternalProgram(check_bin, silent=True)
if not exe.found():
- print('Could not find requested program: {!r}'.format(check_bin))
+ print(f'Could not find requested program: {check_bin!r}')
return 1
- options.wd = os.path.abspath(options.wd)
- if not options.list and not options.no_rebuild:
- if not rebuild_all(options.wd):
- # We return 125 here in case the build failed.
- # The reason is that exit code 125 tells `git bisect run` that the current commit should be skipped.
- # Thus users can directly use `meson test` to bisect without needing to handle the does-not-build case separately in a wrapper script.
- return 125
+ b = build.load(options.wd)
+ setup_vsenv(b.need_vsenv)
with TestHarness(options) as th:
try:
if options.list:
return list_tests(th)
- if not options.args:
- return th.doit()
- return th.run_special()
+ return th.doit()
except TestException as e:
print('Meson test encountered an error:\n')
if os.environ.get('MESON_FORCE_BACKTRACE'):
diff -Nru meson-0.53.2/mesonbuild/munstable_coredata.py meson-0.61.2/mesonbuild/munstable_coredata.py
--- meson-0.53.2/mesonbuild/munstable_coredata.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/munstable_coredata.py 2021-11-02 19:58:07.000000000 +0000
@@ -14,7 +14,7 @@
from . import coredata as cdata
-from .mesonlib import MachineChoice
+from .mesonlib import MachineChoice, OptionKey
import os.path
import pprint
@@ -59,7 +59,7 @@
print('')
coredata = cdata.load(options.builddir)
- backend = coredata.get_builtin_option('backend')
+ backend = coredata.get_option(OptionKey('backend'))
for k, v in sorted(coredata.__dict__.items()):
if k in ('backend_options', 'base_options', 'builtins', 'compiler_options', 'user_options'):
# use `meson configure` to view these
@@ -95,7 +95,7 @@
dump_compilers(v[for_machine])
elif k == 'deps':
def print_dep(dep_key, dep):
- print(' ' + dep_key[0] + ": ")
+ print(' ' + dep_key[0][1] + ": ")
print(' compile args: ' + repr(dep.get_compile_args()))
print(' link args: ' + repr(dep.get_link_args()))
if dep.get_sources():
@@ -105,7 +105,7 @@
for for_machine in iter(MachineChoice):
items_list = list(sorted(v[for_machine].items()))
if items_list:
- print('Cached dependencies for {} machine' % for_machine.get_lower_case_name())
+ print(f'Cached dependencies for {for_machine.get_lower_case_name()} machine')
for dep_key, deps in items_list:
for dep in deps:
print_dep(dep_key, dep)
diff -Nru meson-0.53.2/mesonbuild/optinterpreter.py meson-0.61.2/mesonbuild/optinterpreter.py
--- meson-0.53.2/mesonbuild/optinterpreter.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/optinterpreter.py 2021-11-02 19:58:07.000000000 +0000
@@ -12,153 +12,81 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os, re
-import functools
+import re
import typing as T
-from . import mparser
from . import coredata
from . import mesonlib
-from . import compilers
+from . import mparser
+from . import mlog
+from .interpreterbase import FeatureNew, typed_pos_args, typed_kwargs, ContainerTypeInfo, KwargInfo, permittedKwargs
+if T.TYPE_CHECKING:
+ from .interpreterbase import TV_func, TYPE_var, TYPE_kwargs
+ from typing_extensions import TypedDict
+ FuncOptionArgs = TypedDict('FuncOptionArgs', {
+ 'type': str,
+ 'description': str,
+ 'yield': bool,
+ 'choices': T.Optional[T.List[str]],
+ 'value': object,
+ 'min': T.Optional[int],
+ 'max': T.Optional[int],
+ 'deprecated': T.Union[bool, T.Dict[str, str], T.List[str]],
+ })
+ ParserArgs = TypedDict('ParserArgs', {
+ 'yield': bool,
+ 'choices': T.Optional[T.List[str]],
+ 'value': object,
+ 'min': T.Optional[int],
+ 'max': T.Optional[int],
+ })
-forbidden_option_names = set(coredata.builtin_options.keys())
-forbidden_prefixes = [lang + '_' for lang in compilers.all_languages] + ['b_', 'backend_']
-reserved_prefixes = ['cross_']
-
-def is_invalid_name(name: str, *, log: bool = True) -> bool:
- if name in forbidden_option_names:
- return True
- pref = name.split('_')[0] + '_'
- if pref in forbidden_prefixes:
- return True
- if pref in reserved_prefixes:
- if log:
- from . import mlog
- mlog.deprecation('Option uses prefix "%s", which is reserved for Meson. This will become an error in the future.' % pref)
- return False
class OptionException(mesonlib.MesonException):
pass
-def permitted_kwargs(permitted):
- """Function that validates kwargs for options."""
- def _wraps(func):
- @functools.wraps(func)
- def _inner(name, description, kwargs):
- bad = [a for a in kwargs.keys() if a not in permitted]
- if bad:
- raise OptionException('Invalid kwargs for option "{}": "{}"'.format(
- name, ' '.join(bad)))
- return func(description, kwargs)
- return _inner
- return _wraps
-
-
optname_regex = re.compile('[^a-zA-Z0-9_-]')
-@permitted_kwargs({'value', 'yield'})
-def StringParser(description, kwargs):
- return coredata.UserStringOption(description,
- kwargs.get('value', ''),
- kwargs.get('choices', []),
- kwargs.get('yield', coredata.default_yielding))
-
-@permitted_kwargs({'value', 'yield'})
-def BooleanParser(description, kwargs):
- return coredata.UserBooleanOption(description,
- kwargs.get('value', True),
- kwargs.get('yield', coredata.default_yielding))
-
-@permitted_kwargs({'value', 'yield', 'choices'})
-def ComboParser(description, kwargs):
- if 'choices' not in kwargs:
- raise OptionException('Combo option missing "choices" keyword.')
- choices = kwargs['choices']
- if not isinstance(choices, list):
- raise OptionException('Combo choices must be an array.')
- for i in choices:
- if not isinstance(i, str):
- raise OptionException('Combo choice elements must be strings.')
- return coredata.UserComboOption(description,
- choices,
- kwargs.get('value', choices[0]),
- kwargs.get('yield', coredata.default_yielding),)
-
-
-@permitted_kwargs({'value', 'min', 'max', 'yield'})
-def IntegerParser(description, kwargs):
- if 'value' not in kwargs:
- raise OptionException('Integer option must contain value argument.')
- return coredata.UserIntegerOption(description,
- kwargs.get('min', None),
- kwargs.get('max', None),
- kwargs['value'],
- kwargs.get('yield', coredata.default_yielding))
-
-# FIXME: Cannot use FeatureNew while parsing options because we parse it before
-# reading options in project(). See func_project() in interpreter.py
-#@FeatureNew('array type option()', '0.44.0')
-@permitted_kwargs({'value', 'yield', 'choices'})
-def string_array_parser(description, kwargs):
- if 'choices' in kwargs:
- choices = kwargs['choices']
- if not isinstance(choices, list):
- raise OptionException('Array choices must be an array.')
- for i in choices:
- if not isinstance(i, str):
- raise OptionException('Array choice elements must be strings.')
- value = kwargs.get('value', choices)
- else:
- choices = None
- value = kwargs.get('value', [])
- if not isinstance(value, list):
- raise OptionException('Array choices must be passed as an array.')
- return coredata.UserArrayOption(description,
- value,
- choices=choices,
- yielding=kwargs.get('yield', coredata.default_yielding))
-
-@permitted_kwargs({'value', 'yield'})
-def FeatureParser(description, kwargs):
- return coredata.UserFeatureOption(description,
- kwargs.get('value', 'auto'),
- yielding=kwargs.get('yield', coredata.default_yielding))
-
-option_types = {'string': StringParser,
- 'boolean': BooleanParser,
- 'combo': ComboParser,
- 'integer': IntegerParser,
- 'array': string_array_parser,
- 'feature': FeatureParser,
- } # type: T.Dict[str, T.Callable[[str, T.Dict], coredata.UserOption]]
class OptionInterpreter:
- def __init__(self, subproject):
- self.options = {}
+ def __init__(self, subproject: str) -> None:
+ self.options: 'coredata.KeyedOptionDictType' = {}
self.subproject = subproject
+ self.option_types = {'string': self.string_parser,
+ 'boolean': self.boolean_parser,
+ 'combo': self.combo_parser,
+ 'integer': self.integer_parser,
+ 'array': self.string_array_parser,
+ 'feature': self.feature_parser,
+ }
- def process(self, option_file):
+ def process(self, option_file: str) -> None:
try:
- with open(option_file, 'r', encoding='utf8') as f:
- ast = mparser.Parser(f.read(), '').parse()
+ with open(option_file, encoding='utf-8') as f:
+ ast = mparser.Parser(f.read(), option_file).parse()
except mesonlib.MesonException as me:
me.file = option_file
raise me
if not isinstance(ast, mparser.CodeBlockNode):
e = OptionException('Option file is malformed.')
e.lineno = ast.lineno()
+ e.file = option_file
raise e
for cur in ast.lines:
try:
+ self.current_node = cur
self.evaluate_statement(cur)
- except Exception as e:
+ except mesonlib.MesonException as e:
e.lineno = cur.lineno
e.colno = cur.colno
- e.file = os.path.join('meson_options.txt')
+ e.file = option_file
raise e
+ except Exception as e:
+ raise mesonlib.MesonException(
+ str(e), lineno=cur.lineno, colno=cur.colno, file=option_file)
- def reduce_single(self, arg):
+ def reduce_single(self, arg: T.Union[str, mparser.BaseNode]) -> 'TYPE_var':
if isinstance(arg, str):
return arg
elif isinstance(arg, (mparser.StringNode, mparser.BooleanNode,
@@ -166,53 +94,130 @@
return arg.value
elif isinstance(arg, mparser.ArrayNode):
return [self.reduce_single(curarg) for curarg in arg.args.arguments]
+ elif isinstance(arg, mparser.DictNode):
+ d = {}
+ for k, v in arg.args.kwargs.items():
+ if not isinstance(k, mparser.StringNode):
+ raise OptionException('Dictionary keys must be a string literal')
+ d[k.value] = self.reduce_single(v)
+ return d
+ elif isinstance(arg, mparser.UMinusNode):
+ res = self.reduce_single(arg.value)
+ if not isinstance(res, (int, float)):
+ raise OptionException('Token after "-" is not a number')
+ FeatureNew.single_use('negative numbers in meson_options.txt', '0.54.1', self.subproject)
+ return -res
+ elif isinstance(arg, mparser.NotNode):
+ res = self.reduce_single(arg.value)
+ if not isinstance(res, bool):
+ raise OptionException('Token after "not" is not a a boolean')
+ FeatureNew.single_use('negation ("not") in meson_options.txt', '0.54.1', self.subproject)
+ return not res
+ elif isinstance(arg, mparser.ArithmeticNode):
+ l = self.reduce_single(arg.left)
+ r = self.reduce_single(arg.right)
+ if not (arg.operation == 'add' and isinstance(l, str) and isinstance(r, str)):
+ raise OptionException('Only string concatenation with the "+" operator is allowed')
+ FeatureNew.single_use('string concatenation in meson_options.txt', '0.55.0', self.subproject)
+ return l + r
else:
raise OptionException('Arguments may only be string, int, bool, or array of those.')
- def reduce_arguments(self, args):
- assert(isinstance(args, mparser.ArgumentNode))
+ def reduce_arguments(self, args: mparser.ArgumentNode) -> T.Tuple['TYPE_var', 'TYPE_kwargs']:
if args.incorrect_order():
raise OptionException('All keyword arguments must be after positional arguments.')
reduced_pos = [self.reduce_single(arg) for arg in args.arguments]
reduced_kw = {}
for key in args.kwargs.keys():
- if not isinstance(key, str):
+ if not isinstance(key, mparser.IdNode):
raise OptionException('Keyword argument name is not a string.')
a = args.kwargs[key]
- reduced_kw[key] = self.reduce_single(a)
+ reduced_kw[key.value] = self.reduce_single(a)
return reduced_pos, reduced_kw
- def evaluate_statement(self, node):
+ def evaluate_statement(self, node: mparser.BaseNode) -> None:
if not isinstance(node, mparser.FunctionNode):
raise OptionException('Option file may only contain option definitions')
func_name = node.func_name
if func_name != 'option':
raise OptionException('Only calls to option() are allowed in option files.')
(posargs, kwargs) = self.reduce_arguments(node.args)
+ self.func_option(posargs, kwargs)
- # FIXME: Cannot use FeatureNew while parsing options because we parse
- # it before reading options in project(). See func_project() in
- # interpreter.py
- #if 'yield' in kwargs:
- # FeatureNew('option yield', '0.45.0').use(self.subproject)
-
- if 'type' not in kwargs:
- raise OptionException('Option call missing mandatory "type" keyword argument')
- opt_type = kwargs.pop('type')
- if opt_type not in option_types:
- raise OptionException('Unknown type %s.' % opt_type)
- if len(posargs) != 1:
- raise OptionException('Option() must have one (and only one) positional argument')
- opt_name = posargs[0]
- if not isinstance(opt_name, str):
- raise OptionException('Positional argument must be a string.')
+ @typed_kwargs('option',
+ KwargInfo('type', str, required=True),
+ KwargInfo('description', str, default=''),
+ KwargInfo('yield', bool, default=coredata.default_yielding, since='0.45.0'),
+ KwargInfo('choices', (ContainerTypeInfo(list, str), type(None))),
+ KwargInfo('value', object),
+ KwargInfo('min', (int, type(None))),
+ KwargInfo('max', (int, type(None))),
+ KwargInfo('deprecated', (bool, ContainerTypeInfo(dict, str), ContainerTypeInfo(list, str)),
+ default=False, since='0.60.0')
+ )
+ @typed_pos_args('option', str)
+ def func_option(self, args: T.Tuple[str], kwargs: 'FuncOptionArgs') -> None:
+ opt_name = args[0]
if optname_regex.search(opt_name) is not None:
raise OptionException('Option names can only contain letters, numbers or dashes.')
- if is_invalid_name(opt_name):
+ key = mesonlib.OptionKey.from_string(opt_name).evolve(subproject=self.subproject)
+ if not key.is_project():
raise OptionException('Option name %s is reserved.' % opt_name)
- if self.subproject != '':
- opt_name = self.subproject + ':' + opt_name
- opt = option_types[opt_type](opt_name, kwargs.pop('description', ''), kwargs)
- if opt.description == '':
- opt.description = opt_name
- self.options[opt_name] = opt
+
+ opt_type = kwargs['type']
+ parser = self.option_types.get(opt_type)
+ if not parser:
+ raise OptionException(f'Unknown type {opt_type}.')
+ description = kwargs['description'] or opt_name
+
+ # Only keep in kwargs arguments that are used by option type's parser
+ # because they use @permittedKwargs().
+ known_parser_kwargs = {'value', 'choices', 'yield', 'min', 'max'}
+ parser_kwargs = {k: v for k, v in kwargs.items() if k in known_parser_kwargs and v is not None}
+ opt = parser(description, T.cast('ParserArgs', parser_kwargs))
+ opt.deprecated = kwargs['deprecated']
+
+ if key in self.options:
+ mlog.deprecation(f'Option {opt_name} already exists.')
+ self.options[key] = opt
+
+ @permittedKwargs({'value', 'yield'})
+ def string_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value', '')
+ return coredata.UserStringOption(description, value, kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield'})
+ def boolean_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value', True)
+ return coredata.UserBooleanOption(description, value, kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield', 'choices'})
+ def combo_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ choices = kwargs.get('choices')
+ if not choices:
+ raise OptionException('Combo option missing "choices" keyword.')
+ value = kwargs.get('value', choices[0])
+ return coredata.UserComboOption(description, choices, value, kwargs['yield'])
+
+ @permittedKwargs({'value', 'min', 'max', 'yield'})
+ def integer_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value')
+ if value is None:
+ raise OptionException('Integer option must contain value argument.')
+ inttuple = (kwargs.get('min'), kwargs.get('max'), value)
+ return coredata.UserIntegerOption(description, inttuple, kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield', 'choices'})
+ def string_array_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ choices = kwargs.get('choices', [])
+ value = kwargs.get('value', choices)
+ if not isinstance(value, list):
+ raise OptionException('Array choices must be passed as an array.')
+ return coredata.UserArrayOption(description, value,
+ choices=choices,
+ yielding=kwargs['yield'])
+
+ @permittedKwargs({'value', 'yield'})
+ def feature_parser(self, description: str, kwargs: 'ParserArgs') -> coredata.UserOption:
+ value = kwargs.get('value', 'auto')
+ return coredata.UserFeatureOption(description, value, kwargs['yield'])
diff -Nru meson-0.53.2/mesonbuild/_pathlib.py meson-0.61.2/mesonbuild/_pathlib.py
--- meson-0.53.2/mesonbuild/_pathlib.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/_pathlib.py 2021-07-20 08:56:20.000000000 +0000
@@ -0,0 +1,73 @@
+# Copyright 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.
+
+'''
+ This module soly exists to work around a pathlib.resolve bug on
+ certain Windows systems:
+
+ https://github.com/mesonbuild/meson/issues/7295
+ https://bugs.python.org/issue31842
+
+ It should **never** be used directly. Instead, it is automatically
+ used when `import pathlib` is used. This is achieved by messing with
+ `sys.modules['pathlib']` in mesonmain.
+
+ Additionally, the sole purpose of this module is to work around a
+ python bug. This only bugfixes to pathlib functions and classes are
+ allowed here. Finally, this file should be removed once all upstream
+ python bugs are fixed and it is OK to tell our users to "just upgrade
+ python".
+'''
+
+import pathlib
+import os
+import platform
+
+__all__ = [
+ 'PurePath',
+ 'PurePosixPath',
+ 'PureWindowsPath',
+ 'Path',
+]
+
+PurePath = pathlib.PurePath
+PurePosixPath = pathlib.PurePosixPath
+PureWindowsPath = pathlib.PureWindowsPath
+
+# Only patch on platforms where the bug occurs
+if platform.system().lower() in {'windows'}:
+ # Can not directly inherit from pathlib.Path because the __new__
+ # operator of pathlib.Path() returns a {Posix,Windows}Path object.
+ class Path(type(pathlib.Path())):
+ def resolve(self, strict: bool = False) -> 'Path':
+ '''
+ Work around a resolve bug on certain Windows systems:
+
+ https://github.com/mesonbuild/meson/issues/7295
+ https://bugs.python.org/issue31842
+ '''
+
+ try:
+ return super().resolve(strict=strict)
+ except OSError:
+ return Path(os.path.normpath(self))
+else:
+ Path = pathlib.Path
+ PosixPath = pathlib.PosixPath
+ WindowsPath = pathlib.WindowsPath
+
+ __all__ += [
+ 'PosixPath',
+ 'WindowsPath',
+ ]
diff -Nru meson-0.53.2/mesonbuild/programs.py meson-0.61.2/mesonbuild/programs.py
--- meson-0.53.2/mesonbuild/programs.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/programs.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,384 @@
+# Copyright 2013-2020 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.
+
+"""Representations and logic for External and Internal Programs."""
+
+import functools
+import os
+import shutil
+import stat
+import sys
+import re
+import typing as T
+from pathlib import Path
+
+from . import mesonlib
+from . import mlog
+from .mesonlib import MachineChoice
+
+if T.TYPE_CHECKING:
+ from .environment import Environment
+ from .interpreter import Interpreter
+
+
+class ExternalProgram(mesonlib.HoldableObject):
+
+ """A program that is found on the system."""
+
+ windows_exts = ('exe', 'msc', 'com', 'bat', 'cmd')
+ for_machine = MachineChoice.BUILD
+
+ def __init__(self, name: str, command: T.Optional[T.List[str]] = None,
+ silent: bool = False, search_dir: T.Optional[str] = None,
+ extra_search_dirs: T.Optional[T.List[str]] = None):
+ self.name = name
+ self.path: T.Optional[str] = None
+ self.cached_version: T.Optional[str] = None
+ if command is not None:
+ self.command = mesonlib.listify(command)
+ if mesonlib.is_windows():
+ cmd = self.command[0]
+ args = self.command[1:]
+ # Check whether the specified cmd is a path to a script, in
+ # which case we need to insert the interpreter. If not, try to
+ # use it as-is.
+ ret = self._shebang_to_cmd(cmd)
+ if ret:
+ self.command = ret + args
+ else:
+ self.command = [cmd] + args
+ else:
+ all_search_dirs = [search_dir]
+ if extra_search_dirs:
+ all_search_dirs += extra_search_dirs
+ for d in all_search_dirs:
+ self.command = self._search(name, d)
+ if self.found():
+ break
+
+ if self.found():
+ # Set path to be the last item that is actually a file (in order to
+ # skip options in something like ['python', '-u', 'file.py']. If we
+ # can't find any components, default to the last component of the path.
+ for arg in reversed(self.command):
+ if arg is not None and os.path.isfile(arg):
+ self.path = arg
+ break
+ else:
+ self.path = self.command[-1]
+
+ if not silent:
+ # ignore the warning because derived classes never call this __init__
+ # method, and thus only the found() method of this class is ever executed
+ if self.found(): # lgtm [py/init-calls-subclass]
+ mlog.log('Program', mlog.bold(name), 'found:', mlog.green('YES'),
+ '(%s)' % ' '.join(self.command))
+ else:
+ mlog.log('Program', mlog.bold(name), 'found:', mlog.red('NO'))
+
+ def summary_value(self) -> T.Union[str, mlog.AnsiDecorator]:
+ if not self.found():
+ return mlog.red('NO')
+ return self.path
+
+ def __repr__(self) -> str:
+ r = '<{} {!r} -> {!r}>'
+ return r.format(self.__class__.__name__, self.name, self.command)
+
+ def description(self) -> str:
+ '''Human friendly description of the command'''
+ return ' '.join(self.command)
+
+ def get_version(self, interpreter: 'Interpreter') -> str:
+ if not self.cached_version:
+ from . import build
+ raw_cmd = self.get_command() + ['--version']
+ res = interpreter.run_command_impl(interpreter.current_node, (self, ['--version']),
+ {'capture': True, 'check': True, 'env': build.EnvironmentVariables()},
+ True)
+ output = res.stdout.strip()
+ if not output:
+ output = res.stderr.strip()
+ match = re.search(r'([0-9][0-9\.]+)', output)
+ if not match:
+ raise mesonlib.MesonException(f'Could not find a version number in output of {raw_cmd!r}')
+ self.cached_version = match.group(1)
+ return self.cached_version
+
+ @classmethod
+ def from_bin_list(cls, env: 'Environment', for_machine: MachineChoice, name: str) -> 'ExternalProgram':
+ # There is a static `for_machine` for this class because the binary
+ # always runs on the build platform. (It's host platform is our build
+ # platform.) But some external programs have a target platform, so this
+ # is what we are specifying here.
+ command = env.lookup_binary_entry(for_machine, name)
+ if command is None:
+ return NonExistingExternalProgram()
+ return cls.from_entry(name, command)
+
+ @staticmethod
+ @functools.lru_cache(maxsize=None)
+ def _windows_sanitize_path(path: str) -> str:
+ # Ensure that we use USERPROFILE even when inside MSYS, MSYS2, Cygwin, etc.
+ if 'USERPROFILE' not in os.environ:
+ return path
+ # The WindowsApps directory is a bit of a problem. It contains
+ # some zero-sized .exe files which have "reparse points", that
+ # might either launch an installed application, or might open
+ # a page in the Windows Store to download the application.
+ #
+ # To handle the case where the python interpreter we're
+ # running on came from the Windows Store, if we see the
+ # WindowsApps path in the search path, replace it with
+ # dirname(sys.executable).
+ appstore_dir = Path(os.environ['USERPROFILE']) / 'AppData' / 'Local' / 'Microsoft' / 'WindowsApps'
+ paths = []
+ for each in path.split(os.pathsep):
+ if Path(each) != appstore_dir:
+ paths.append(each)
+ elif 'WindowsApps' in sys.executable:
+ paths.append(os.path.dirname(sys.executable))
+ return os.pathsep.join(paths)
+
+ @staticmethod
+ def from_entry(name: str, command: T.Union[str, T.List[str]]) -> 'ExternalProgram':
+ if isinstance(command, list):
+ if len(command) == 1:
+ command = command[0]
+ # We cannot do any searching if the command is a list, and we don't
+ # need to search if the path is an absolute path.
+ if isinstance(command, list) or os.path.isabs(command):
+ if isinstance(command, str):
+ command = [command]
+ return ExternalProgram(name, command=command, silent=True)
+ assert isinstance(command, str)
+ # Search for the command using the specified string!
+ return ExternalProgram(command, silent=True)
+
+ @staticmethod
+ def _shebang_to_cmd(script: str) -> T.Optional[T.List[str]]:
+ """
+ Check if the file has a shebang and manually parse it to figure out
+ the interpreter to use. This is useful if the script is not executable
+ or if we're on Windows (which does not understand shebangs).
+ """
+ try:
+ with open(script, encoding='utf-8') as f:
+ first_line = f.readline().strip()
+ if first_line.startswith('#!'):
+ # In a shebang, everything before the first space is assumed to
+ # be the command to run and everything after the first space is
+ # the single argument to pass to that command. So we must split
+ # exactly once.
+ commands = first_line[2:].split('#')[0].strip().split(maxsplit=1)
+ if mesonlib.is_windows():
+ # Windows does not have UNIX paths so remove them,
+ # but don't remove Windows paths
+ if commands[0].startswith('/'):
+ commands[0] = commands[0].split('/')[-1]
+ if len(commands) > 0 and commands[0] == 'env':
+ commands = commands[1:]
+ # Windows does not ship python3.exe, but we know the path to it
+ if len(commands) > 0 and commands[0] == 'python3':
+ commands = mesonlib.python_command + commands[1:]
+ elif mesonlib.is_haiku():
+ # Haiku does not have /usr, but a lot of scripts assume that
+ # /usr/bin/env always exists. Detect that case and run the
+ # script with the interpreter after it.
+ if commands[0] == '/usr/bin/env':
+ commands = commands[1:]
+ # We know what python3 is, we're running on it
+ if len(commands) > 0 and commands[0] == 'python3':
+ commands = mesonlib.python_command + commands[1:]
+ else:
+ # Replace python3 with the actual python3 that we are using
+ if commands[0] == '/usr/bin/env' and commands[1] == 'python3':
+ commands = mesonlib.python_command + commands[2:]
+ elif commands[0].split('/')[-1] == 'python3':
+ commands = mesonlib.python_command + commands[1:]
+ return commands + [script]
+ except Exception as e:
+ mlog.debug(str(e))
+ mlog.debug(f'Unusable script {script!r}')
+ return None
+
+ def _is_executable(self, path: str) -> bool:
+ suffix = os.path.splitext(path)[-1].lower()[1:]
+ execmask = stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+ if mesonlib.is_windows():
+ if suffix in self.windows_exts:
+ return True
+ elif os.stat(path).st_mode & execmask:
+ return not os.path.isdir(path)
+ return False
+
+ def _search_dir(self, name: str, search_dir: T.Optional[str]) -> T.Optional[list]:
+ if search_dir is None:
+ return None
+ trial = os.path.join(search_dir, name)
+ if os.path.exists(trial):
+ if self._is_executable(trial):
+ return [trial]
+ # Now getting desperate. Maybe it is a script file that is
+ # a) not chmodded executable, or
+ # b) we are on windows so they can't be directly executed.
+ return self._shebang_to_cmd(trial)
+ else:
+ if mesonlib.is_windows():
+ for ext in self.windows_exts:
+ trial_ext = f'{trial}.{ext}'
+ if os.path.exists(trial_ext):
+ return [trial_ext]
+ return None
+
+ def _search_windows_special_cases(self, name: str, command: str) -> T.List[T.Optional[str]]:
+ '''
+ Lots of weird Windows quirks:
+ 1. PATH search for @name returns files with extensions from PATHEXT,
+ but only self.windows_exts are executable without an interpreter.
+ 2. @name might be an absolute path to an executable, but without the
+ extension. This works inside MinGW so people use it a lot.
+ 3. The script is specified without an extension, in which case we have
+ to manually search in PATH.
+ 4. More special-casing for the shebang inside the script.
+ '''
+ if command:
+ # On Windows, even if the PATH search returned a full path, we can't be
+ # sure that it can be run directly if it's not a native executable.
+ # For instance, interpreted scripts sometimes need to be run explicitly
+ # with an interpreter if the file association is not done properly.
+ name_ext = os.path.splitext(command)[1]
+ if name_ext[1:].lower() in self.windows_exts:
+ # Good, it can be directly executed
+ return [command]
+ # Try to extract the interpreter from the shebang
+ commands = self._shebang_to_cmd(command)
+ if commands:
+ return commands
+ return [None]
+ # Maybe the name is an absolute path to a native Windows
+ # executable, but without the extension. This is technically wrong,
+ # but many people do it because it works in the MinGW shell.
+ if os.path.isabs(name):
+ for ext in self.windows_exts:
+ command = f'{name}.{ext}'
+ if os.path.exists(command):
+ return [command]
+ # On Windows, interpreted scripts must have an extension otherwise they
+ # cannot be found by a standard PATH search. So we do a custom search
+ # where we manually search for a script with a shebang in PATH.
+ search_dirs = self._windows_sanitize_path(os.environ.get('PATH', '')).split(';')
+ for search_dir in search_dirs:
+ commands = self._search_dir(name, search_dir)
+ if commands:
+ return commands
+ return [None]
+
+ def _search(self, name: str, search_dir: T.Optional[str]) -> T.List[T.Optional[str]]:
+ '''
+ Search in the specified dir for the specified executable by name
+ and if not found search in PATH
+ '''
+ commands = self._search_dir(name, search_dir)
+ if commands:
+ return commands
+ # If there is a directory component, do not look in PATH
+ if os.path.dirname(name) and not os.path.isabs(name):
+ return [None]
+ # Do a standard search in PATH
+ path = os.environ.get('PATH', None)
+ if mesonlib.is_windows() and path:
+ path = self._windows_sanitize_path(path)
+ command = shutil.which(name, path=path)
+ if mesonlib.is_windows():
+ return self._search_windows_special_cases(name, command)
+ # On UNIX-like platforms, shutil.which() is enough to find
+ # all executables whether in PATH or with an absolute path
+ return [command]
+
+ def found(self) -> bool:
+ return self.command[0] is not None
+
+ def get_command(self) -> T.List[str]:
+ return self.command[:]
+
+ def get_path(self) -> T.Optional[str]:
+ return self.path
+
+ def get_name(self) -> str:
+ return self.name
+
+
+class NonExistingExternalProgram(ExternalProgram): # lgtm [py/missing-call-to-init]
+ "A program that will never exist"
+
+ def __init__(self, name: str = 'nonexistingprogram') -> None:
+ self.name = name
+ self.command = [None]
+ self.path = None
+
+ def __repr__(self) -> str:
+ r = '<{} {!r} -> {!r}>'
+ return r.format(self.__class__.__name__, self.name, self.command)
+
+ def found(self) -> bool:
+ return False
+
+
+class EmptyExternalProgram(ExternalProgram): # lgtm [py/missing-call-to-init]
+ '''
+ A program object that returns an empty list of commands. Used for cases
+ such as a cross file exe_wrapper to represent that it's not required.
+ '''
+
+ def __init__(self) -> None:
+ self.name = None
+ self.command = []
+ self.path = None
+
+ def __repr__(self) -> str:
+ r = '<{} {!r} -> {!r}>'
+ return r.format(self.__class__.__name__, self.name, self.command)
+
+ def found(self) -> bool:
+ return True
+
+
+class OverrideProgram(ExternalProgram):
+
+ """A script overriding a program."""
+
+
+def find_external_program(env: 'Environment', for_machine: MachineChoice, name: str,
+ display_name: str, default_names: T.List[str],
+ allow_default_for_cross: bool = True) -> T.Generator['ExternalProgram', None, None]:
+ """Find an external program, chcking the cross file plus any default options."""
+ # Lookup in cross or machine file.
+ potential_cmd = env.lookup_binary_entry(for_machine, name)
+ if potential_cmd is not None:
+ mlog.debug(f'{display_name} binary for {for_machine} specified from cross file, native file, '
+ f'or env var as {potential_cmd}')
+ yield ExternalProgram.from_entry(name, potential_cmd)
+ # We never fallback if the user-specified option is no good, so
+ # stop returning options.
+ return
+ mlog.debug(f'{display_name} binary missing from cross or native file, or env var undefined.')
+ # Fallback on hard-coded defaults, if a default binary is allowed for use
+ # with cross targets, or if this is not a cross target
+ if allow_default_for_cross or not (for_machine is MachineChoice.HOST and env.is_cross_build(for_machine)):
+ for potential_path in default_names:
+ mlog.debug(f'Trying a default {display_name} fallback at', potential_path)
+ yield ExternalProgram(potential_path, silent=True)
+ else:
+ mlog.debug('Default target is not allowed for cross use')
diff -Nru meson-0.53.2/mesonbuild/rewriter.py meson-0.61.2/mesonbuild/rewriter.py
--- meson-0.53.2/mesonbuild/rewriter.py 2020-01-23 12:51:19.000000000 +0000
+++ meson-0.61.2/mesonbuild/rewriter.py 2021-12-26 16:24:25.000000000 +0000
@@ -46,7 +46,7 @@
tgt_parser.add_argument('--type', dest='tgt_type', choices=rewriter_keys['target']['target_type'][2], default='executable',
help='Type of the target to add (only for the "add_target" action)')
tgt_parser.add_argument('target', help='Name or ID of the target')
- tgt_parser.add_argument('operation', choices=['add', 'rm', 'add_target', 'rm_target', 'info'],
+ tgt_parser.add_argument('operation', choices=['add', 'rm', 'add_target', 'rm_target', 'add_extra_files', 'rm_extra_files', 'info'],
help='Action to execute')
tgt_parser.add_argument('sources', nargs='*', help='Sources to add/remove')
@@ -76,7 +76,7 @@
def __call__(self, f):
@wraps(f)
def wrapped(*wrapped_args, **wrapped_kwargs):
- assert(len(wrapped_args) >= 2)
+ assert len(wrapped_args) >= 2
cmd = wrapped_args[1]
for key, val in self.keys.items():
typ = val[0] # The type of the value
@@ -92,7 +92,7 @@
raise RewriterException('Invalid type of "{}". Required is {} but provided was {}'
.format(key, typ.__name__, type(cmd[key]).__name__))
if choices is not None:
- assert(isinstance(choices, list))
+ assert isinstance(choices, list)
if cmd[key] not in choices:
raise RewriterException('Invalid value of "{}": Possible values are {} but provided was "{}"'
.format(key, choices, cmd[key]))
@@ -113,7 +113,7 @@
def _new_node(self):
# Overwrite in derived class
- return BaseNode()
+ raise RewriterException('Internal error: _new_node of MTypeBase was called')
def can_modify(self):
return self.node_type is not None
@@ -159,7 +159,7 @@
super().__init__(node)
def _new_node(self):
- return StringNode(Token('', '', 0, 0, 0, None, False))
+ return BooleanNode(Token('', '', 0, 0, 0, None, False))
def supported_nodes(self):
return [BooleanNode]
@@ -172,7 +172,7 @@
super().__init__(node)
def _new_node(self):
- return StringNode(Token('', '', 0, 0, 0, None, ''))
+ return IdNode(Token('', '', 0, 0, 0, None, ''))
def supported_nodes(self):
return [IdNode]
@@ -189,7 +189,7 @@
def _new_element_node(self, value):
# Overwrite in derived class
- return BaseNode()
+ raise RewriterException('Internal error: _new_element_node of MTypeList was called')
def _ensure_array_node(self):
if not isinstance(self.node, ArrayNode):
@@ -308,7 +308,7 @@
},
'target': {
'target': (str, None, None),
- 'operation': (str, None, ['src_add', 'src_rm', 'target_rm', 'target_add', 'info']),
+ 'operation': (str, None, ['src_add', 'src_rm', 'target_rm', 'target_add', 'extra_files_add', 'extra_files_rm', 'info']),
'sources': (list, [], None),
'subdir': (str, '', None),
'target_type': (str, 'executable', ['both_libraries', 'executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library']),
@@ -353,7 +353,7 @@
self.sourcedir = sourcedir
self.interpreter = IntrospectionInterpreter(sourcedir, '', generator, visitors = [AstIDGenerator(), AstIndentationGenerator(), AstConditionLevel()])
self.skip_errors = skip_errors
- self.modefied_nodes = []
+ self.modified_nodes = []
self.to_remove_nodes = []
self.to_add_nodes = []
self.functions = {
@@ -414,10 +414,10 @@
# Check the assignments
tgt = None
if target in self.interpreter.assignments:
- node = self.interpreter.assignments[target][0]
+ node = self.interpreter.assignments[target]
if isinstance(node, FunctionNode):
if node.func_name in ['executable', 'jar', 'library', 'shared_library', 'shared_module', 'static_library', 'both_libraries']:
- tgt = self.interpreter.assign_vals[target][0]
+ tgt = self.interpreter.assign_vals[target]
return tgt
@@ -434,7 +434,7 @@
# Check the assignments
if dependency in self.interpreter.assignments:
- node = self.interpreter.assignments[dependency][0]
+ node = self.interpreter.assignments[dependency]
if isinstance(node, FunctionNode):
if node.func_name in ['dependency']:
name = self.interpreter.flatten_args(node.args)[0]
@@ -450,7 +450,7 @@
'id': "/",
'operation': 'remove_regex',
'kwargs': {
- 'default_options': ['{}=.*'.format(x) for x in cmd['options'].keys()]
+ 'default_options': [f'{x}=.*' for x in cmd['options'].keys()]
}
}
self.process_kwargs(kwargs_cmd)
@@ -464,14 +464,11 @@
cdata = self.interpreter.coredata
options = {
- **cdata.builtins,
- **cdata.builtins_per_machine.host,
- **{'build.' + k: o for k, o in cdata.builtins_per_machine.build.items()},
- **cdata.backend_options,
- **cdata.base_options,
- **cdata.compiler_options.host,
- **{'build.' + k: o for k, o in cdata.compiler_options.build.items()},
- **cdata.user_options,
+ **{str(k): v for k, v in cdata.options.items()},
+ **{str(k): v for k, v in cdata.options.items()},
+ **{str(k): v for k, v in cdata.options.items()},
+ **{str(k): v for k, v in cdata.options.items()},
+ **{str(k): v for k, v in cdata.options.items()},
}
for key, val in sorted(cmd['options'].items()):
@@ -487,7 +484,7 @@
self.handle_error()
continue
- kwargs_cmd['kwargs']['default_options'] += ['{}={}'.format(key, val)]
+ kwargs_cmd['kwargs']['default_options'] += [f'{key}={val}']
self.process_kwargs(kwargs_cmd)
@@ -503,8 +500,12 @@
node = None
arg_node = None
if cmd['function'] == 'project':
- if cmd['id'] != '/':
- mlog.error('The ID for the function type project must be "/"', *self.on_error())
+ # msys bash may expand '/' to a path. It will mangle '//' to '/'
+ # but in order to keep usage shell-agnostic, also allow `//` as
+ # the function ID such that it will work in both msys bash and
+ # other shells.
+ if {'/', '//'}.isdisjoint({cmd['id']}):
+ mlog.error('The ID for the function type project must be "/" or "//" not "' + cmd['id'] + '"', *self.on_error())
return self.handle_error()
node = self.interpreter.project_node
arg_node = node.args
@@ -520,8 +521,10 @@
arg_node = node.args
if not node:
mlog.error('Unable to find the function node')
- assert(isinstance(node, FunctionNode))
- assert(isinstance(arg_node, ArgumentNode))
+ assert isinstance(node, FunctionNode)
+ assert isinstance(arg_node, ArgumentNode)
+ # Transform the key nodes to plain strings
+ arg_node.kwargs = {k.value: v for k, v in arg_node.kwargs.items()}
# Print kwargs info
if cmd['operation'] == 'info':
@@ -585,11 +588,13 @@
arg_node.kwargs[key] = modifyer.get_node()
num_changed += 1
- if num_changed > 0 and node not in self.modefied_nodes:
- self.modefied_nodes += [node]
+ # Convert the keys back to IdNode's
+ arg_node.kwargs = {IdNode(Token('', '', 0, 0, 0, None, k)): v for k, v in arg_node.kwargs.items()}
+ if num_changed > 0 and node not in self.modified_nodes:
+ self.modified_nodes += [node]
def find_assignment_node(self, node: BaseNode) -> AssignmentNode:
- if hasattr(node, 'ast_id') and node.ast_id in self.interpreter.reverse_assignment:
+ if node.ast_id and node.ast_id in self.interpreter.reverse_assignment:
return self.interpreter.reverse_assignment[node.ast_id]
return None
@@ -635,7 +640,7 @@
node = target['sources'][0]
else:
node = target['node']
- assert(node is not None)
+ assert node is not None
# Generate the current source list
src_list = []
@@ -651,8 +656,8 @@
mlog.log(' -- Source', mlog.green(i), 'is already defined for the target --> skipping')
continue
mlog.log(' -- Adding source', mlog.green(i), 'at',
- mlog.yellow('{}:{}'.format(os.path.join(node.subdir, environment.build_filename), node.lineno)))
- token = Token('string', node.subdir, 0, 0, 0, None, i)
+ mlog.yellow(f'{node.filename}:{node.lineno}'))
+ token = Token('string', node.filename, 0, 0, 0, None, i)
to_append += [StringNode(token)]
# Append to the AST at the right place
@@ -661,14 +666,14 @@
arg_node = node.args
elif isinstance(node, ArgumentNode):
arg_node = node
- assert(arg_node is not None)
+ assert arg_node is not None
arg_node.arguments += to_append
# Mark the node as modified
if arg_node not in to_sort_nodes and not isinstance(node, FunctionNode):
to_sort_nodes += [arg_node]
- if node not in self.modefied_nodes:
- self.modefied_nodes += [node]
+ if node not in self.modified_nodes:
+ self.modified_nodes += [node]
elif cmd['operation'] == 'src_rm':
# Helper to find the exact string node and its parent
@@ -693,16 +698,101 @@
arg_node = root.args
elif isinstance(root, ArgumentNode):
arg_node = root
- assert(arg_node is not None)
+ assert arg_node is not None
mlog.log(' -- Removing source', mlog.green(i), 'from',
- mlog.yellow('{}:{}'.format(os.path.join(string_node.subdir, environment.build_filename), string_node.lineno)))
+ mlog.yellow(f'{string_node.filename}:{string_node.lineno}'))
arg_node.arguments.remove(string_node)
# Mark the node as modified
if arg_node not in to_sort_nodes and not isinstance(root, FunctionNode):
to_sort_nodes += [arg_node]
- if root not in self.modefied_nodes:
- self.modefied_nodes += [root]
+ if root not in self.modified_nodes:
+ self.modified_nodes += [root]
+
+ elif cmd['operation'] == 'extra_files_add':
+ tgt_function: FunctionNode = target['node']
+ mark_array = True
+ try:
+ node = target['extra_files'][0]
+ except IndexError:
+ # Specifying `extra_files` with a list that flattens to empty gives an empty
+ # target['extra_files'] list, account for that.
+ try:
+ extra_files_key = next(k for k in tgt_function.args.kwargs.keys() if isinstance(k, IdNode) and k.value == 'extra_files')
+ node = tgt_function.args.kwargs[extra_files_key]
+ except StopIteration:
+ # Target has no extra_files kwarg, create one
+ node = ArrayNode(ArgumentNode(Token('', tgt_function.filename, 0, 0, 0, None, '[]')), tgt_function.end_lineno, tgt_function.end_colno, tgt_function.end_lineno, tgt_function.end_colno)
+ tgt_function.args.kwargs[IdNode(Token('string', tgt_function.filename, 0, 0, 0, None, 'extra_files'))] = node
+ mark_array = False
+ if tgt_function not in self.modified_nodes:
+ self.modified_nodes += [tgt_function]
+ target['extra_files'] = [node]
+ if isinstance(node, IdNode):
+ node = self.interpreter.assignments[node.value]
+ target['extra_files'] = [node]
+ if not isinstance(node, ArrayNode):
+ mlog.error('Target', mlog.bold(cmd['target']), 'extra_files argument must be a list', *self.on_error())
+ return self.handle_error()
+
+ # Generate the current extra files list
+ extra_files_list = []
+ for i in target['extra_files']:
+ for j in arg_list_from_node(i):
+ if isinstance(j, StringNode):
+ extra_files_list += [j.value]
+
+ # Generate the new String nodes
+ to_append = []
+ for i in sorted(set(cmd['sources'])):
+ if i in extra_files_list:
+ mlog.log(' -- Extra file', mlog.green(i), 'is already defined for the target --> skipping')
+ continue
+ mlog.log(' -- Adding extra file', mlog.green(i), 'at',
+ mlog.yellow(f'{node.filename}:{node.lineno}'))
+ token = Token('string', node.filename, 0, 0, 0, None, i)
+ to_append += [StringNode(token)]
+
+ # Append to the AST at the right place
+ arg_node = node.args
+ arg_node.arguments += to_append
+
+ # Mark the node as modified
+ if arg_node not in to_sort_nodes:
+ to_sort_nodes += [arg_node]
+ # If the extra_files array is newly created, don't mark it as its parent function node already is,
+ # otherwise this would cause double modification.
+ if mark_array and node not in self.modified_nodes:
+ self.modified_nodes += [node]
+
+ elif cmd['operation'] == 'extra_files_rm':
+ # Helper to find the exact string node and its parent
+ def find_node(src):
+ for i in target['extra_files']:
+ for j in arg_list_from_node(i):
+ if isinstance(j, StringNode):
+ if j.value == src:
+ return i, j
+ return None, None
+
+ for i in cmd['sources']:
+ # Try to find the node with the source string
+ root, string_node = find_node(i)
+ if root is None:
+ mlog.warning(' -- Unable to find extra file', mlog.green(i), 'in the target')
+ continue
+
+ # Remove the found string node from the argument list
+ arg_node = root.args
+ mlog.log(' -- Removing extra file', mlog.green(i), 'from',
+ mlog.yellow(f'{string_node.filename}:{string_node.lineno}'))
+ arg_node.arguments.remove(string_node)
+
+ # Mark the node as modified
+ if arg_node not in to_sort_nodes and not isinstance(root, FunctionNode):
+ to_sort_nodes += [arg_node]
+ if root not in self.modified_nodes:
+ self.modified_nodes += [root]
elif cmd['operation'] == 'target_add':
if target is not None:
@@ -712,23 +802,24 @@
id_base = re.sub(r'[- ]', '_', cmd['target'])
target_id = id_base + '_exe' if cmd['target_type'] == 'executable' else '_lib'
source_id = id_base + '_sources'
+ filename = os.path.join(cmd['subdir'], environment.build_filename)
# Build src list
- src_arg_node = ArgumentNode(Token('string', cmd['subdir'], 0, 0, 0, None, ''))
+ src_arg_node = ArgumentNode(Token('string', filename, 0, 0, 0, None, ''))
src_arr_node = ArrayNode(src_arg_node, 0, 0, 0, 0)
- src_far_node = ArgumentNode(Token('string', cmd['subdir'], 0, 0, 0, None, ''))
- src_fun_node = FunctionNode(cmd['subdir'], 0, 0, 0, 0, 'files', src_far_node)
- src_ass_node = AssignmentNode(cmd['subdir'], 0, 0, source_id, src_fun_node)
- src_arg_node.arguments = [StringNode(Token('string', cmd['subdir'], 0, 0, 0, None, x)) for x in cmd['sources']]
+ src_far_node = ArgumentNode(Token('string', filename, 0, 0, 0, None, ''))
+ src_fun_node = FunctionNode(filename, 0, 0, 0, 0, 'files', src_far_node)
+ src_ass_node = AssignmentNode(filename, 0, 0, source_id, src_fun_node)
+ src_arg_node.arguments = [StringNode(Token('string', filename, 0, 0, 0, None, x)) for x in cmd['sources']]
src_far_node.arguments = [src_arr_node]
# Build target
- tgt_arg_node = ArgumentNode(Token('string', cmd['subdir'], 0, 0, 0, None, ''))
- tgt_fun_node = FunctionNode(cmd['subdir'], 0, 0, 0, 0, cmd['target_type'], tgt_arg_node)
- tgt_ass_node = AssignmentNode(cmd['subdir'], 0, 0, target_id, tgt_fun_node)
+ tgt_arg_node = ArgumentNode(Token('string', filename, 0, 0, 0, None, ''))
+ tgt_fun_node = FunctionNode(filename, 0, 0, 0, 0, cmd['target_type'], tgt_arg_node)
+ tgt_ass_node = AssignmentNode(filename, 0, 0, target_id, tgt_fun_node)
tgt_arg_node.arguments = [
- StringNode(Token('string', cmd['subdir'], 0, 0, 0, None, cmd['target'])),
- IdNode(Token('string', cmd['subdir'], 0, 0, 0, None, source_id))
+ StringNode(Token('string', filename, 0, 0, 0, None, cmd['target'])),
+ IdNode(Token('string', filename, 0, 0, 0, None, source_id))
]
src_ass_node.accept(AstIndentationGenerator())
@@ -741,7 +832,7 @@
to_remove = target['node']
self.to_remove_nodes += [to_remove]
mlog.log(' -- Removing target', mlog.green(cmd['target']), 'at',
- mlog.yellow('{}:{}'.format(os.path.join(to_remove.subdir, environment.build_filename), to_remove.lineno)))
+ mlog.yellow(f'{to_remove.filename}:{to_remove.lineno}'))
elif cmd['operation'] == 'info':
# T.List all sources in the target
@@ -750,9 +841,15 @@
for j in arg_list_from_node(i):
if isinstance(j, StringNode):
src_list += [j.value]
+ extra_files_list = []
+ for i in target['extra_files']:
+ for j in arg_list_from_node(i):
+ if isinstance(j, StringNode):
+ extra_files_list += [j.value]
test_data = {
'name': target['name'],
- 'sources': src_list
+ 'sources': src_list,
+ 'extra_files': extra_files_list
}
self.add_info('target', target['id'], test_data)
@@ -776,12 +873,12 @@
self.functions[cmd['type']](cmd)
def apply_changes(self):
- assert(all(hasattr(x, 'lineno') and hasattr(x, 'colno') and hasattr(x, 'subdir') for x in self.modefied_nodes))
- assert(all(hasattr(x, 'lineno') and hasattr(x, 'colno') and hasattr(x, 'subdir') for x in self.to_remove_nodes))
- assert(all(isinstance(x, (ArrayNode, FunctionNode)) for x in self.modefied_nodes))
- assert(all(isinstance(x, (ArrayNode, AssignmentNode, FunctionNode)) for x in self.to_remove_nodes))
+ assert all(hasattr(x, 'lineno') and hasattr(x, 'colno') and hasattr(x, 'filename') for x in self.modified_nodes)
+ assert all(hasattr(x, 'lineno') and hasattr(x, 'colno') and hasattr(x, 'filename') for x in self.to_remove_nodes)
+ assert all(isinstance(x, (ArrayNode, FunctionNode)) for x in self.modified_nodes)
+ assert all(isinstance(x, (ArrayNode, AssignmentNode, FunctionNode)) for x in self.to_remove_nodes)
# Sort based on line and column in reversed order
- work_nodes = [{'node': x, 'action': 'modify'} for x in self.modefied_nodes]
+ work_nodes = [{'node': x, 'action': 'modify'} for x in self.modified_nodes]
work_nodes += [{'node': x, 'action': 'rm'} for x in self.to_remove_nodes]
work_nodes = list(sorted(work_nodes, key=lambda x: (x['node'].lineno, x['node'].colno), reverse=True))
work_nodes += [{'node': x, 'action': 'add'} for x in self.to_add_nodes]
@@ -796,7 +893,7 @@
printer.post_process()
new_data = printer.result.strip()
data = {
- 'file': os.path.join(i['node'].subdir, environment.build_filename),
+ 'file': i['node'].filename,
'str': new_data,
'node': i['node'],
'action': i['action']
@@ -812,9 +909,9 @@
fdata = ''
# Create an empty file if it does not exist
if not os.path.exists(fpath):
- with open(fpath, 'w'):
+ with open(fpath, 'w', encoding='utf-8'):
pass
- with open(fpath, 'r') as fp:
+ with open(fpath, encoding='utf-8') as fp:
fdata = fp.read()
# Generate line offsets numbers
@@ -865,7 +962,7 @@
# Write the files back
for key, val in files.items():
mlog.log('Rewriting', mlog.yellow(key))
- with open(val['path'], 'w') as fp:
+ with open(val['path'], 'w', encoding='utf-8') as fp:
fp.write(val['raw'])
target_operation_map = {
@@ -873,6 +970,8 @@
'rm': 'src_rm',
'add_target': 'target_add',
'rm_target': 'target_rm',
+ 'add_extra_files': 'extra_files_add',
+ 'rm_extra_files': 'extra_files_rm',
'info': 'info',
}
@@ -915,9 +1014,9 @@
'options': list_to_dict(options.options),
}]
-def genreate_cmd(options) -> T.List[dict]:
+def generate_cmd(options) -> T.List[dict]:
if os.path.exists(options.json):
- with open(options.json, 'r') as fp:
+ with open(options.json, encoding='utf-8') as fp:
return json.load(fp)
else:
return json.loads(options.json)
@@ -929,8 +1028,8 @@
'kwargs': generate_kwargs,
'default-options': generate_def_opts,
'def': generate_def_opts,
- 'command': genreate_cmd,
- 'cmd': genreate_cmd,
+ 'command': generate_cmd,
+ 'cmd': generate_cmd,
}
def run(options):
diff -Nru meson-0.53.2/mesonbuild/scripts/clangformat.py meson-0.61.2/mesonbuild/scripts/clangformat.py
--- meson-0.53.2/mesonbuild/scripts/clangformat.py 2019-10-06 17:01:35.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/clangformat.py 2021-12-26 16:24:25.000000000 +0000
@@ -12,34 +12,41 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import pathlib
+import argparse
import subprocess
-from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from .run_tool import run_tool
from ..environment import detect_clangformat
-from ..compilers import lang_suffixes
+import typing as T
-def clangformat(exelist, srcdir_name, builddir_name):
- srcdir = pathlib.Path(srcdir_name)
- suffixes = set(lang_suffixes['c']).union(set(lang_suffixes['cpp']))
- suffixes.add('h')
- futures = []
- with ThreadPoolExecutor() as e:
- for f in (x for suff in suffixes for x in srcdir.glob('**/*.' + suff)):
- strf = str(f)
- if strf.startswith(builddir_name):
- continue
- futures.append(e.submit(subprocess.check_call, exelist + ['-style=file', '-i', strf]))
- [x.result() for x in futures]
- return 0
-
-def run(args):
- srcdir_name = args[0]
- builddir_name = args[1]
+def run_clang_format(fname: Path, exelist: T.List[str], check: bool) -> subprocess.CompletedProcess:
+ if check:
+ original = fname.read_bytes()
+ before = fname.stat().st_mtime
+ ret = subprocess.run(exelist + ['-style=file', '-i', str(fname)])
+ after = fname.stat().st_mtime
+ if before != after:
+ print('File reformatted: ', fname)
+ if check:
+ # Restore the original if only checking.
+ fname.write_bytes(original)
+ ret.returncode = 1
+ return ret
+
+def run(args: T.List[str]) -> int:
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--check', action='store_true')
+ parser.add_argument('sourcedir')
+ parser.add_argument('builddir')
+ options = parser.parse_args(args)
+
+ srcdir = Path(options.sourcedir)
+ builddir = Path(options.builddir)
exelist = detect_clangformat()
if not exelist:
print('Could not execute clang-format "%s"' % ' '.join(exelist))
return 1
- return clangformat(exelist, srcdir_name, builddir_name)
+ return run_tool('clang-format', srcdir, builddir, run_clang_format, exelist, options.check)
diff -Nru meson-0.53.2/mesonbuild/scripts/clangtidy.py meson-0.61.2/mesonbuild/scripts/clangtidy.py
--- meson-0.53.2/mesonbuild/scripts/clangtidy.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/clangtidy.py 2021-12-26 16:24:25.000000000 +0000
@@ -12,41 +12,23 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import pathlib
+import argparse
import subprocess
-import shutil
-from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
-from ..compilers import lang_suffixes
+from .run_tool import run_tool
+import typing as T
-def manual_clangformat(srcdir_name, builddir_name):
- srcdir = pathlib.Path(srcdir_name)
- suffixes = set(lang_suffixes['c']).union(set(lang_suffixes['cpp']))
- suffixes.add('h')
- futures = []
- returncode = 0
- with ThreadPoolExecutor() as e:
- for f in (x for suff in suffixes for x in srcdir.glob('**/*.' + suff)):
- strf = str(f)
- if strf.startswith(builddir_name):
- continue
- futures.append(e.submit(subprocess.run, ['clang-tidy', '-p', builddir_name, strf]))
- [max(returncode, x.result().returncode) for x in futures]
- return returncode
-
-def clangformat(srcdir_name, builddir_name):
- run_clang_tidy = None
- for rct in ('run-clang-tidy', 'run-clang-tidy.py'):
- if shutil.which(rct):
- run_clang_tidy = rct
- break
- if run_clang_tidy:
- return subprocess.run([run_clang_tidy, '-p', builddir_name]).returncode
- else:
- print('Could not find run-clang-tidy, running checks manually.')
- manual_clangformat(srcdir_name, builddir_name)
-
-def run(args):
- srcdir_name = args[0]
- builddir_name = args[1]
- return clangformat(srcdir_name, builddir_name)
+def run_clang_tidy(fname: Path, builddir: Path) -> subprocess.CompletedProcess:
+ return subprocess.run(['clang-tidy', '-p', str(builddir), str(fname)])
+
+def run(args: T.List[str]) -> int:
+ parser = argparse.ArgumentParser()
+ parser.add_argument('sourcedir')
+ parser.add_argument('builddir')
+ options = parser.parse_args(args)
+
+ srcdir = Path(options.sourcedir)
+ builddir = Path(options.builddir)
+
+ return run_tool('clang-tidy', srcdir, builddir, run_clang_tidy, builddir)
diff -Nru meson-0.53.2/mesonbuild/scripts/cleantrees.py meson-0.61.2/mesonbuild/scripts/cleantrees.py
--- meson-0.53.2/mesonbuild/scripts/cleantrees.py 2016-12-20 19:35:10.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/cleantrees.py 2021-04-27 06:49:45.000000000 +0000
@@ -16,19 +16,20 @@
import sys
import shutil
import pickle
+import typing as T
-def rmtrees(build_dir, trees):
+def rmtrees(build_dir: str, trees: T.List[str]) -> None:
for t in trees:
# Never delete trees outside of the builddir
if os.path.isabs(t):
- print('Cannot delete dir with absolute path {!r}'.format(t))
+ print(f'Cannot delete dir with absolute path {t!r}')
continue
bt = os.path.join(build_dir, t)
# Skip if it doesn't exist, or if it is not a directory
if os.path.isdir(bt):
shutil.rmtree(bt, ignore_errors=True)
-def run(args):
+def run(args: T.List[str]) -> int:
if len(args) != 1:
print('Cleaner script for Meson. Do not run on your own please.')
print('cleantrees.py ')
diff -Nru meson-0.53.2/mesonbuild/scripts/cmake_run_ctgt.py meson-0.61.2/mesonbuild/scripts/cmake_run_ctgt.py
--- meson-0.53.2/mesonbuild/scripts/cmake_run_ctgt.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/cmake_run_ctgt.py 2021-04-27 06:49:45.000000000 +0000
@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+
+import argparse
+import subprocess
+import shutil
+import sys
+from pathlib import Path
+import typing as T
+
+def run(argsv: T.List[str]) -> int:
+ commands = [[]] # type: T.List[T.List[str]]
+ SEPARATOR = ';;;'
+
+ # Generate CMD parameters
+ parser = argparse.ArgumentParser(description='Wrapper for add_custom_command')
+ parser.add_argument('-d', '--directory', type=str, metavar='D', required=True, help='Working directory to cwd to')
+ parser.add_argument('-o', '--outputs', nargs='+', metavar='O', required=True, help='Expected output files')
+ parser.add_argument('-O', '--original-outputs', nargs='*', metavar='O', default=[], help='Output files expected by CMake')
+ parser.add_argument('commands', nargs=argparse.REMAINDER, help=f'A "{SEPARATOR}" separated list of commands')
+
+ # Parse
+ args = parser.parse_args(argsv)
+ directory = Path(args.directory)
+
+ dummy_target = None
+ if len(args.outputs) == 1 and len(args.original_outputs) == 0:
+ dummy_target = Path(args.outputs[0])
+ elif len(args.outputs) != len(args.original_outputs):
+ print('Length of output list and original output list differ')
+ return 1
+
+ for i in args.commands:
+ if i == SEPARATOR:
+ commands += [[]]
+ continue
+
+ i = i.replace('"', '') # Remove lefover quotes
+ commands[-1] += [i]
+
+ # Execute
+ for i in commands:
+ # Skip empty lists
+ if not i:
+ continue
+
+ cmd = []
+ stdout = None
+ stderr = None
+ capture_file = ''
+
+ for j in i:
+ if j in ['>', '>>']:
+ stdout = subprocess.PIPE
+ continue
+ elif j in ['&>', '&>>']:
+ stdout = subprocess.PIPE
+ stderr = subprocess.STDOUT
+ continue
+
+ if stdout is not None or stderr is not None:
+ capture_file += j
+ else:
+ cmd += [j]
+
+ try:
+ directory.mkdir(parents=True, exist_ok=True)
+
+ res = subprocess.run(cmd, stdout=stdout, stderr=stderr, cwd=str(directory), check=True)
+ if capture_file:
+ out_file = directory / capture_file
+ out_file.write_bytes(res.stdout)
+ except subprocess.CalledProcessError:
+ return 1
+
+ if dummy_target:
+ dummy_target.touch()
+ return 0
+
+ # Copy outputs
+ zipped_outputs = zip([Path(x) for x in args.outputs], [Path(x) for x in args.original_outputs])
+ for expected, generated in zipped_outputs:
+ do_copy = False
+ if not expected.exists():
+ if not generated.exists():
+ print('Unable to find generated file. This can cause the build to fail:')
+ print(generated)
+ do_copy = False
+ else:
+ do_copy = True
+ elif generated.exists():
+ if generated.stat().st_mtime > expected.stat().st_mtime:
+ do_copy = True
+
+ if do_copy:
+ if expected.exists():
+ expected.unlink()
+ shutil.copyfile(str(generated), str(expected))
+
+ return 0
+
+if __name__ == '__main__':
+ sys.exit(run(sys.argv[1:]))
diff -Nru meson-0.53.2/mesonbuild/scripts/cmd_or_ps.ps1 meson-0.61.2/mesonbuild/scripts/cmd_or_ps.ps1
--- meson-0.53.2/mesonbuild/scripts/cmd_or_ps.ps1 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/cmd_or_ps.ps1 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,22 @@
+# Copied from GStreamer project
+# Author: Seungha Yang
+
+$i=1
+$ppid=(gwmi win32_process -Filter "processid='$pid'").parentprocessid
+$pname=(Get-Process -id $ppid).Name
+While($true) {
+ if($pname -eq "cmd" -Or $pname -eq "powershell") {
+ Write-Host ("{0}.exe" -f $pname)
+ Break
+ }
+
+ # 10 times iteration seems to be sufficient
+ if($i -gt 10) {
+ Break
+ }
+
+ # not found yet, find grand parant
+ $ppid=(gwmi win32_process -Filter "processid='$ppid'").parentprocessid
+ $pname=(Get-Process -id $ppid).Name
+ $i++
+}
diff -Nru meson-0.53.2/mesonbuild/scripts/commandrunner.py meson-0.61.2/mesonbuild/scripts/commandrunner.py
--- meson-0.53.2/mesonbuild/scripts/commandrunner.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/commandrunner.py 1970-01-01 00:00:00.000000000 +0000
@@ -1,83 +0,0 @@
-# Copyright 2014 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.
-
-"""This program is a wrapper to run external commands. It determines
-what to run, sets up the environment and executes the command."""
-
-import sys, os, subprocess, shutil, shlex
-import re
-
-def run_command(source_dir, build_dir, subdir, meson_command, command, arguments):
- env = {'MESON_SOURCE_ROOT': source_dir,
- 'MESON_BUILD_ROOT': build_dir,
- 'MESON_SUBDIR': subdir,
- 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in meson_command + ['introspect']]),
- }
- cwd = os.path.join(source_dir, subdir)
- child_env = os.environ.copy()
- child_env.update(env)
-
- # Is the command an executable in path?
- exe = shutil.which(command)
- if exe is not None:
- command_array = [exe] + arguments
- else:# No? Maybe it is a script in the source tree.
- fullpath = os.path.join(source_dir, subdir, command)
- command_array = [fullpath] + arguments
- try:
- return subprocess.Popen(command_array, env=child_env, cwd=cwd)
- except FileNotFoundError:
- print('Could not execute command "%s". File not found.' % command)
- sys.exit(1)
- except PermissionError:
- print('Could not execute command "%s". File not executable.' % command)
- sys.exit(1)
- except OSError as err:
- print('Could not execute command "{}": {}'.format(command, err))
- sys.exit(1)
- except subprocess.SubprocessError as err:
- print('Could not execute command "{}": {}'.format(command, err))
- sys.exit(1)
-
-def is_python_command(cmdname):
- end_py_regex = r'python(3|3\.\d+)?(\.exe)?$'
- return re.search(end_py_regex, cmdname) is not None
-
-def run(args):
- if len(args) < 4:
- print('commandrunner.py [arguments]')
- return 1
- src_dir = args[0]
- build_dir = args[1]
- subdir = args[2]
- meson_command = args[3]
- if is_python_command(meson_command):
- meson_command = [meson_command, args[4]]
- command = args[5]
- arguments = args[6:]
- else:
- meson_command = [meson_command]
- command = args[4]
- arguments = args[5:]
- pc = run_command(src_dir, build_dir, subdir, meson_command, command, arguments)
- while True:
- try:
- pc.wait()
- break
- except KeyboardInterrupt:
- pass
- return pc.returncode
-
-if __name__ == '__main__':
- sys.exit(run(sys.argv[1:]))
diff -Nru meson-0.53.2/mesonbuild/scripts/coverage.py meson-0.61.2/mesonbuild/scripts/coverage.py
--- meson-0.53.2/mesonbuild/scripts/coverage.py 2019-05-02 18:59:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/coverage.py 2021-11-02 19:58:13.000000000 +0000
@@ -12,40 +12,58 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-from mesonbuild import environment
+from mesonbuild import environment, mesonlib
-import argparse, sys, os, subprocess, pathlib
+import argparse, re, sys, os, subprocess, pathlib, stat
+import typing as T
-def coverage(outputs, source_root, subproject_root, build_root, log_dir):
+def coverage(outputs: T.List[str], source_root: str, subproject_root: str, build_root: str, log_dir: str, use_llvm_cov: bool) -> int:
outfiles = []
exitcode = 0
- (gcovr_exe, gcovr_new_rootdir, lcov_exe, genhtml_exe) = environment.find_coverage_tools()
+ (gcovr_exe, gcovr_version, lcov_exe, genhtml_exe, llvm_cov_exe) = environment.find_coverage_tools()
# gcovr >= 4.2 requires a different syntax for out of source builds
- if gcovr_new_rootdir:
+ if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=4.2'):
gcovr_base_cmd = [gcovr_exe, '-r', source_root, build_root]
else:
gcovr_base_cmd = [gcovr_exe, '-r', build_root]
+ if use_llvm_cov:
+ gcov_exe_args = ['--gcov-executable', llvm_cov_exe + ' gcov']
+ else:
+ gcov_exe_args = []
+
if not outputs or 'xml' in outputs:
- if gcovr_exe:
+ if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
subprocess.check_call(gcovr_base_cmd +
['-x',
- '-e', subproject_root,
- '-o', os.path.join(log_dir, 'coverage.xml'),
- ])
+ '-e', re.escape(subproject_root),
+ '-o', os.path.join(log_dir, 'coverage.xml')
+ ] + gcov_exe_args)
outfiles.append(('Xml', pathlib.Path(log_dir, 'coverage.xml')))
elif outputs:
print('gcovr >= 3.3 needed to generate Xml coverage report')
exitcode = 1
+ if not outputs or 'sonarqube' in outputs:
+ if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=4.2'):
+ subprocess.check_call(gcovr_base_cmd +
+ ['--sonarqube',
+ '-o', os.path.join(log_dir, 'sonarqube.xml'),
+ '-e', re.escape(subproject_root)
+ ] + gcov_exe_args)
+ outfiles.append(('Sonarqube', pathlib.Path(log_dir, 'sonarqube.xml')))
+ elif outputs:
+ print('gcovr >= 4.2 needed to generate Xml coverage report')
+ exitcode = 1
+
if not outputs or 'text' in outputs:
- if gcovr_exe:
+ if gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
subprocess.check_call(gcovr_base_cmd +
- ['-e', subproject_root,
- '-o', os.path.join(log_dir, 'coverage.txt'),
- ])
+ ['-e', re.escape(subproject_root),
+ '-o', os.path.join(log_dir, 'coverage.txt')
+ ] + gcov_exe_args)
outfiles.append(('Text', pathlib.Path(log_dir, 'coverage.txt')))
elif outputs:
print('gcovr >= 3.3 needed to generate text coverage report')
@@ -58,19 +76,34 @@
initial_tracefile = covinfo + '.initial'
run_tracefile = covinfo + '.run'
raw_tracefile = covinfo + '.raw'
+ if use_llvm_cov:
+ # Create a shim to allow using llvm-cov as a gcov tool.
+ if mesonlib.is_windows():
+ llvm_cov_shim_path = os.path.join(log_dir, 'llvm-cov.bat')
+ with open(llvm_cov_shim_path, 'w', encoding='utf-8') as llvm_cov_bat:
+ llvm_cov_bat.write(f'@"{llvm_cov_exe}" gcov %*')
+ else:
+ llvm_cov_shim_path = os.path.join(log_dir, 'llvm-cov.sh')
+ with open(llvm_cov_shim_path, 'w', encoding='utf-8') as llvm_cov_sh:
+ llvm_cov_sh.write(f'#!/usr/bin/env sh\nexec "{llvm_cov_exe}" gcov $@')
+ os.chmod(llvm_cov_shim_path, os.stat(llvm_cov_shim_path).st_mode | stat.S_IEXEC)
+ gcov_tool_args = ['--gcov-tool', llvm_cov_shim_path]
+ else:
+ gcov_tool_args = []
subprocess.check_call([lcov_exe,
'--directory', build_root,
'--capture',
'--initial',
'--output-file',
- initial_tracefile])
+ initial_tracefile] +
+ gcov_tool_args)
subprocess.check_call([lcov_exe,
'--directory', build_root,
'--capture',
'--output-file', run_tracefile,
'--no-checksum',
- '--rc', 'lcov_branch_coverage=1',
- ])
+ '--rc', 'lcov_branch_coverage=1'] +
+ gcov_tool_args)
# Join initial and test results.
subprocess.check_call([lcov_exe,
'-a', initial_tracefile,
@@ -99,7 +132,7 @@
'--branch-coverage',
covinfo])
outfiles.append(('Html', pathlib.Path(htmloutdir, 'index.html')))
- elif gcovr_exe:
+ elif gcovr_exe and mesonlib.version_compare(gcovr_version, '>=3.3'):
htmloutdir = os.path.join(log_dir, 'coveragereport')
if not os.path.isdir(htmloutdir):
os.mkdir(htmloutdir)
@@ -107,7 +140,7 @@
['--html',
'--html-details',
'--print-summary',
- '-e', subproject_root,
+ '-e', re.escape(subproject_root),
'-o', os.path.join(htmloutdir, 'index.html'),
])
outfiles.append(('Html', pathlib.Path(htmloutdir, 'index.html')))
@@ -126,7 +159,7 @@
return exitcode
-def run(args):
+def run(args: T.List[str]) -> int:
if not os.path.isfile('build.ninja'):
print('Coverage currently only works with the Ninja backend.')
return 1
@@ -135,8 +168,12 @@
const='text', help='generate Text report')
parser.add_argument('--xml', dest='outputs', action='append_const',
const='xml', help='generate Xml report')
+ parser.add_argument('--sonarqube', dest='outputs', action='append_const',
+ const='sonarqube', help='generate Sonarqube Xml report')
parser.add_argument('--html', dest='outputs', action='append_const',
const='html', help='generate Html report')
+ parser.add_argument('--use_llvm_cov', action='store_true',
+ help='use llvm-cov')
parser.add_argument('source_root')
parser.add_argument('subproject_root')
parser.add_argument('build_root')
@@ -144,7 +181,7 @@
options = parser.parse_args(args)
return coverage(options.outputs, options.source_root,
options.subproject_root, options.build_root,
- options.log_dir)
+ options.log_dir, options.use_llvm_cov)
if __name__ == '__main__':
sys.exit(run(sys.argv[1:]))
diff -Nru meson-0.53.2/mesonbuild/scripts/delwithsuffix.py meson-0.61.2/mesonbuild/scripts/delwithsuffix.py
--- meson-0.53.2/mesonbuild/scripts/delwithsuffix.py 2017-05-20 09:00:34.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/delwithsuffix.py 2021-04-01 21:12:21.000000000 +0000
@@ -13,8 +13,9 @@
# limitations under the License.
import os, sys
+import typing as T
-def run(args):
+def run(args: T.List[str]) -> int:
if len(args) != 2:
print('delwithsuffix.py ')
sys.exit(1)
diff -Nru meson-0.53.2/mesonbuild/scripts/depfixer.py meson-0.61.2/mesonbuild/scripts/depfixer.py
--- meson-0.53.2/mesonbuild/scripts/depfixer.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/depfixer.py 2021-12-26 16:24:25.000000000 +0000
@@ -13,10 +13,15 @@
# limitations under the License.
-import sys, struct
-import shutil, subprocess
+import sys
+import os
+import stat
+import struct
+import shutil
+import subprocess
+import typing as T
-from ..mesonlib import OrderedSet
+from ..mesonlib import OrderedSet, generate_list
SHT_STRTAB = 3
DT_NEEDED = 1
@@ -26,8 +31,11 @@
DT_SONAME = 14
DT_MIPS_RLD_MAP_REL = 1879048245
+# Global cache for tools
+INSTALL_NAME_TOOL = False
+
class DataSizes:
- def __init__(self, ptrsize, is_le):
+ def __init__(self, ptrsize: int, is_le: bool) -> None:
if is_le:
p = '<'
else:
@@ -54,7 +62,7 @@
self.OffSize = 4
class DynamicEntry(DataSizes):
- def __init__(self, ifile, ptrsize, is_le):
+ def __init__(self, ifile: T.BinaryIO, ptrsize: int, is_le: bool) -> None:
super().__init__(ptrsize, is_le)
self.ptrsize = ptrsize
if ptrsize == 64:
@@ -64,7 +72,7 @@
self.d_tag = struct.unpack(self.Sword, ifile.read(self.SwordSize))[0]
self.val = struct.unpack(self.Word, ifile.read(self.WordSize))[0]
- def write(self, ofile):
+ def write(self, ofile: T.BinaryIO) -> None:
if self.ptrsize == 64:
ofile.write(struct.pack(self.Sxword, self.d_tag))
ofile.write(struct.pack(self.XWord, self.val))
@@ -73,7 +81,7 @@
ofile.write(struct.pack(self.Word, self.val))
class SectionHeader(DataSizes):
- def __init__(self, ifile, ptrsize, is_le):
+ def __init__(self, ifile: T.BinaryIO, ptrsize: int, is_le: bool) -> None:
super().__init__(ptrsize, is_le)
if ptrsize == 64:
is_64 = True
@@ -113,10 +121,12 @@
self.sh_entsize = struct.unpack(self.Word, ifile.read(self.WordSize))[0]
class Elf(DataSizes):
- def __init__(self, bfile, verbose=True):
+ def __init__(self, bfile: str, verbose: bool = True) -> None:
self.bfile = bfile
self.verbose = verbose
- self.bf = open(bfile, 'r+b')
+ self.sections = [] # type: T.List[SectionHeader]
+ self.dynamic = [] # type: T.List[DynamicEntry]
+ self.open_bf(bfile)
try:
(self.ptrsize, self.is_le) = self.detect_elf_type()
super().__init__(self.ptrsize, self.is_le)
@@ -124,43 +134,64 @@
self.parse_sections()
self.parse_dynamic()
except (struct.error, RuntimeError):
- self.bf.close()
+ self.close_bf()
raise
- def __enter__(self):
+ def open_bf(self, bfile: str) -> None:
+ self.bf = None
+ self.bf_perms = None
+ try:
+ self.bf = open(bfile, 'r+b')
+ except PermissionError as e:
+ self.bf_perms = stat.S_IMODE(os.lstat(bfile).st_mode)
+ os.chmod(bfile, stat.S_IREAD | stat.S_IWRITE | stat.S_IEXEC)
+ try:
+ self.bf = open(bfile, 'r+b')
+ except Exception:
+ os.chmod(bfile, self.bf_perms)
+ self.bf_perms = None
+ raise e
+
+ def close_bf(self) -> None:
+ if self.bf is not None:
+ if self.bf_perms is not None:
+ os.fchmod(self.bf.fileno(), self.bf_perms)
+ self.bf_perms = None
+ self.bf.close()
+ self.bf = None
+
+ def __enter__(self) -> 'Elf':
return self
- def __del__(self):
- if self.bf:
- self.bf.close()
+ def __del__(self) -> None:
+ self.close_bf()
- def __exit__(self, exc_type, exc_value, traceback):
- self.bf.close()
- self.bf = None
+ def __exit__(self, exc_type: T.Any, exc_value: T.Any, traceback: T.Any) -> None:
+ self.close_bf()
- def detect_elf_type(self):
+ def detect_elf_type(self) -> T.Tuple[int, bool]:
data = self.bf.read(6)
if data[1:4] != b'ELF':
# This script gets called to non-elf targets too
# so just ignore them.
if self.verbose:
- print('File "%s" is not an ELF file.' % self.bfile)
+ print(f'File {self.bfile!r} is not an ELF file.')
sys.exit(0)
if data[4] == 1:
ptrsize = 32
elif data[4] == 2:
ptrsize = 64
else:
- sys.exit('File "%s" has unknown ELF class.' % self.bfile)
+ sys.exit(f'File {self.bfile!r} has unknown ELF class.')
if data[5] == 1:
is_le = True
elif data[5] == 2:
is_le = False
else:
- sys.exit('File "%s" has unknown ELF endianness.' % self.bfile)
+ sys.exit(f'File {self.bfile!r} has unknown ELF endianness.')
return ptrsize, is_le
- def parse_header(self):
+ def parse_header(self) -> None:
self.bf.seek(0)
self.e_ident = struct.unpack('16s', self.bf.read(16))[0]
self.e_type = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0]
@@ -177,13 +208,12 @@
self.e_shnum = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0]
self.e_shstrndx = struct.unpack(self.Half, self.bf.read(self.HalfSize))[0]
- def parse_sections(self):
+ def parse_sections(self) -> None:
self.bf.seek(self.e_shoff)
- self.sections = []
for _ in range(self.e_shnum):
self.sections.append(SectionHeader(self.bf, self.ptrsize, self.is_le))
- def read_str(self):
+ def read_str(self) -> bytes:
arr = []
x = self.bf.read(1)
while x != b'\0':
@@ -193,17 +223,17 @@
raise RuntimeError('Tried to read past the end of the file')
return b''.join(arr)
- def find_section(self, target_name):
+ def find_section(self, target_name: bytes) -> T.Optional[SectionHeader]:
section_names = self.sections[self.e_shstrndx]
for i in self.sections:
self.bf.seek(section_names.sh_offset + i.sh_name)
name = self.read_str()
if name == target_name:
return i
+ return None
- def parse_dynamic(self):
+ def parse_dynamic(self) -> None:
sec = self.find_section(b'.dynamic')
- self.dynamic = []
if sec is None:
return
self.bf.seek(sec.sh_offset)
@@ -213,14 +243,14 @@
if e.d_tag == 0:
break
- def print_section_names(self):
+ @generate_list
+ def get_section_names(self) -> T.Generator[str, None, None]:
section_names = self.sections[self.e_shstrndx]
for i in self.sections:
self.bf.seek(section_names.sh_offset + i.sh_name)
- name = self.read_str()
- print(name.decode())
+ yield self.read_str().decode()
- def print_soname(self):
+ def get_soname(self) -> T.Optional[str]:
soname = None
strtab = None
for i in self.dynamic:
@@ -229,47 +259,43 @@
if i.d_tag == DT_STRTAB:
strtab = i
if soname is None or strtab is None:
- print("This file does not have a soname")
- return
+ return None
self.bf.seek(strtab.val + soname.val)
- print(self.read_str())
+ return self.read_str().decode()
- def get_entry_offset(self, entrynum):
+ def get_entry_offset(self, entrynum: int) -> T.Optional[int]:
sec = self.find_section(b'.dynstr')
for i in self.dynamic:
if i.d_tag == entrynum:
- return sec.sh_offset + i.val
+ res = sec.sh_offset + i.val
+ assert isinstance(res, int)
+ return res
return None
- def print_rpath(self):
+ def get_rpath(self) -> T.Optional[str]:
offset = self.get_entry_offset(DT_RPATH)
if offset is None:
- print("This file does not have an rpath.")
- else:
- self.bf.seek(offset)
- print(self.read_str())
+ return None
+ self.bf.seek(offset)
+ return self.read_str().decode()
- def print_runpath(self):
+ def get_runpath(self) -> T.Optional[str]:
offset = self.get_entry_offset(DT_RUNPATH)
if offset is None:
- print("This file does not have a runpath.")
- else:
- self.bf.seek(offset)
- print(self.read_str())
+ return None
+ self.bf.seek(offset)
+ return self.read_str().decode()
- def print_deps(self):
+ @generate_list
+ def get_deps(self) -> T.Generator[str, None, None]:
sec = self.find_section(b'.dynstr')
- deps = []
for i in self.dynamic:
if i.d_tag == DT_NEEDED:
- deps.append(i)
- for i in deps:
- offset = sec.sh_offset + i.val
- self.bf.seek(offset)
- name = self.read_str()
- print(name)
+ offset = sec.sh_offset + i.val
+ self.bf.seek(offset)
+ yield self.read_str().decode()
- def fix_deps(self, prefix):
+ def fix_deps(self, prefix: bytes) -> None:
sec = self.find_section(b'.dynstr')
deps = []
for i in self.dynamic:
@@ -283,28 +309,46 @@
basename = name.split(b'/')[-1]
padding = b'\0' * (len(name) - len(basename))
newname = basename + padding
- assert(len(newname) == len(name))
+ assert len(newname) == len(name)
self.bf.seek(offset)
self.bf.write(newname)
- def fix_rpath(self, new_rpath):
+ def fix_rpath(self, fname: str, rpath_dirs_to_remove: T.Set[bytes], new_rpath: bytes) -> None:
# The path to search for can be either rpath or runpath.
# Fix both of them to be sure.
- self.fix_rpathtype_entry(new_rpath, DT_RPATH)
- self.fix_rpathtype_entry(new_rpath, DT_RUNPATH)
+ self.fix_rpathtype_entry(fname, rpath_dirs_to_remove, new_rpath, DT_RPATH)
+ self.fix_rpathtype_entry(fname, rpath_dirs_to_remove, new_rpath, DT_RUNPATH)
- def fix_rpathtype_entry(self, new_rpath, entrynum):
- if isinstance(new_rpath, str):
- new_rpath = new_rpath.encode('utf8')
+ def fix_rpathtype_entry(self, fname: str, rpath_dirs_to_remove: T.Set[bytes], new_rpath: bytes, entrynum: int) -> None:
rp_off = self.get_entry_offset(entrynum)
if rp_off is None:
if self.verbose:
- print('File does not have rpath. It should be a fully static executable.')
+ print(f'File {fname!r} does not have an rpath. It should be a fully static executable.')
return
self.bf.seek(rp_off)
+
old_rpath = self.read_str()
+ # Some rpath entries may come from multiple sources.
+ # Only add each one once.
+ new_rpaths = OrderedSet() # type: OrderedSet[bytes]
+ if new_rpath:
+ new_rpaths.update(new_rpath.split(b':'))
+ if old_rpath:
+ # Filter out build-only rpath entries
+ # added by get_link_dep_subdirs() or
+ # specified by user with build_rpath.
+ for rpath_dir in old_rpath.split(b':'):
+ if not (rpath_dir in rpath_dirs_to_remove or
+ rpath_dir == (b'X' * len(rpath_dir))):
+ if rpath_dir:
+ new_rpaths.add(rpath_dir)
+
+ # Prepend user-specified new entries while preserving the ones that came from pkgconfig etc.
+ new_rpath = b':'.join(new_rpaths)
+
if len(old_rpath) < len(new_rpath):
- sys.exit("New rpath must not be longer than the old one.")
+ msg = "New rpath must not be longer than the old one.\n Old: {}\n New: {}".format(old_rpath.decode('utf-8'), new_rpath.decode('utf-8'))
+ sys.exit(msg)
# The linker does read-only string deduplication. If there is a
# string that shares a suffix with the rpath, they might get
# dedupped. This means changing the rpath string might break something
@@ -320,7 +364,7 @@
self.bf.write(new_rpath)
self.bf.write(b'\0')
- def remove_rpath_entry(self, entrynum):
+ def remove_rpath_entry(self, entrynum: int) -> None:
sec = self.find_section(b'.dynamic')
if sec is None:
return None
@@ -340,15 +384,13 @@
entry.write(self.bf)
return None
-def fix_elf(fname, new_rpath, verbose=True):
- with Elf(fname, verbose) as e:
- if new_rpath is None:
- e.print_rpath()
- e.print_runpath()
- else:
- e.fix_rpath(new_rpath)
+def fix_elf(fname: str, rpath_dirs_to_remove: T.Set[bytes], new_rpath: T.Optional[bytes], verbose: bool = True) -> None:
+ if new_rpath is not None:
+ with Elf(fname, verbose) as e:
+ # note: e.get_rpath() and e.get_runpath() may be useful
+ e.fix_rpath(fname, rpath_dirs_to_remove, new_rpath)
-def get_darwin_rpaths_to_remove(fname):
+def get_darwin_rpaths_to_remove(fname: str) -> T.List[str]:
out = subprocess.check_output(['otool', '-l', fname],
universal_newlines=True,
stderr=subprocess.DEVNULL)
@@ -366,7 +408,7 @@
result.append(rp)
return result
-def fix_darwin(fname, new_rpath, final_path, install_name_mappings):
+def fix_darwin(fname: str, new_rpath: str, final_path: str, install_name_mappings: T.Dict[str, str]) -> None:
try:
rpaths = get_darwin_rpaths_to_remove(fname)
except subprocess.CalledProcessError:
@@ -416,9 +458,9 @@
except Exception as err:
raise SystemExit(err)
-def fix_jar(fname):
+def fix_jar(fname: str) -> None:
subprocess.check_call(['jar', 'xfv', fname, 'META-INF/MANIFEST.MF'])
- with open('META-INF/MANIFEST.MF', 'r+') as f:
+ with open('META-INF/MANIFEST.MF', 'r+', encoding='utf-8') as f:
lines = f.readlines()
f.seek(0)
for line in lines:
@@ -427,23 +469,33 @@
f.truncate()
subprocess.check_call(['jar', 'ufm', fname, 'META-INF/MANIFEST.MF'])
-def fix_rpath(fname, new_rpath, final_path, install_name_mappings, verbose=True):
- # Static libraries never have rpaths
- if fname.endswith('.a'):
- return
- # DLLs and EXE never have rpaths
- if fname.endswith('.dll') or fname.endswith('.exe'):
+def fix_rpath(fname: str, rpath_dirs_to_remove: T.Set[bytes], new_rpath: T.Union[str, bytes], final_path: str, install_name_mappings: T.Dict[str, str], verbose: bool = True) -> None:
+ global INSTALL_NAME_TOOL
+ # Static libraries, import libraries, debug information, headers, etc
+ # never have rpaths
+ # DLLs and EXE currently do not need runtime path fixing
+ if fname.endswith(('.a', '.lib', '.pdb', '.h', '.hpp', '.dll', '.exe')):
return
try:
if fname.endswith('.jar'):
fix_jar(fname)
return
- fix_elf(fname, new_rpath, verbose)
+ if isinstance(new_rpath, str):
+ new_rpath = new_rpath.encode('utf8')
+ fix_elf(fname, rpath_dirs_to_remove, new_rpath, verbose)
return
except SystemExit as e:
if isinstance(e.code, int) and e.code == 0:
pass
else:
raise
- if shutil.which('install_name_tool'):
+ # We don't look for this on import because it will do a useless PATH lookup
+ # on non-mac platforms. That can be expensive on some Windows machines
+ # (up to 30ms), which is significant with --only-changed. For details, see:
+ # https://github.com/mesonbuild/meson/pull/6612#discussion_r378581401
+ if INSTALL_NAME_TOOL is False:
+ INSTALL_NAME_TOOL = bool(shutil.which('install_name_tool'))
+ if INSTALL_NAME_TOOL:
+ if isinstance(new_rpath, bytes):
+ new_rpath = new_rpath.decode('utf8')
fix_darwin(fname, new_rpath, final_path, install_name_mappings)
diff -Nru meson-0.53.2/mesonbuild/scripts/depscan.py meson-0.61.2/mesonbuild/scripts/depscan.py
--- meson-0.53.2/mesonbuild/scripts/depscan.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/depscan.py 2021-11-02 19:58:13.000000000 +0000
@@ -0,0 +1,202 @@
+# Copyright 2020 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.
+
+import json
+import os
+import pathlib
+import pickle
+import re
+import sys
+import typing as T
+
+from ..backend.ninjabackend import TargetDependencyScannerInfo, ninja_quote
+from ..compilers.compilers import lang_suffixes
+
+CPP_IMPORT_RE = re.compile(r'\w*import ([a-zA-Z0-9]+);')
+CPP_EXPORT_RE = re.compile(r'\w*export module ([a-zA-Z0-9]+);')
+
+FORTRAN_INCLUDE_PAT = r"^\s*include\s*['\"](\w+\.\w+)['\"]"
+FORTRAN_MODULE_PAT = r"^\s*\bmodule\b\s+(\w+)\s*(?:!+.*)*$"
+FORTRAN_SUBMOD_PAT = r"^\s*\bsubmodule\b\s*\((\w+:?\w+)\)\s*(\w+)"
+FORTRAN_USE_PAT = r"^\s*use,?\s*(?:non_intrinsic)?\s*(?:::)?\s*(\w+)"
+
+FORTRAN_MODULE_RE = re.compile(FORTRAN_MODULE_PAT, re.IGNORECASE)
+FORTRAN_SUBMOD_RE = re.compile(FORTRAN_SUBMOD_PAT, re.IGNORECASE)
+FORTRAN_USE_RE = re.compile(FORTRAN_USE_PAT, re.IGNORECASE)
+
+class DependencyScanner:
+ def __init__(self, pickle_file: str, outfile: str, sources: T.List[str]):
+ with open(pickle_file, 'rb') as pf:
+ self.target_data = pickle.load(pf) # type: TargetDependencyScannerInfo
+ self.outfile = outfile
+ self.sources = sources
+ self.provided_by = {} # type: T.Dict[str, str]
+ self.exports = {} # type: T.Dict[str, str]
+ self.needs = {} # type: T.Dict[str, T.List[str]]
+ self.sources_with_exports = [] # type: T.List[str]
+
+ def scan_file(self, fname: str) -> None:
+ suffix = os.path.splitext(fname)[1][1:].lower()
+ if suffix in lang_suffixes['fortran']:
+ self.scan_fortran_file(fname)
+ elif suffix in lang_suffixes['cpp']:
+ self.scan_cpp_file(fname)
+ else:
+ sys.exit(f'Can not scan files with suffix .{suffix}.')
+
+ def scan_fortran_file(self, fname: str) -> None:
+ fpath = pathlib.Path(fname)
+ modules_in_this_file = set()
+ for line in fpath.read_text(encoding='utf-8').split('\n'):
+ import_match = FORTRAN_USE_RE.match(line)
+ export_match = FORTRAN_MODULE_RE.match(line)
+ submodule_export_match = FORTRAN_SUBMOD_RE.match(line)
+ if import_match:
+ needed = import_match.group(1).lower()
+ # In Fortran you have an using declaration also for the module
+ # you define in the same file. Prevent circular dependencies.
+ if needed not in modules_in_this_file:
+ if fname in self.needs:
+ self.needs[fname].append(needed)
+ else:
+ self.needs[fname] = [needed]
+ if export_match:
+ exported_module = export_match.group(1).lower()
+ assert exported_module not in modules_in_this_file
+ modules_in_this_file.add(exported_module)
+ if exported_module in self.provided_by:
+ raise RuntimeError(f'Multiple files provide module {exported_module}.')
+ self.sources_with_exports.append(fname)
+ self.provided_by[exported_module] = fname
+ self.exports[fname] = exported_module
+ if submodule_export_match:
+ # Store submodule "Foo" "Bar" as "foo:bar".
+ # A submodule declaration can be both an import and an export declaration:
+ #
+ # submodule (a1:a2) a3
+ # - requires a1@a2.smod
+ # - produces a1@a3.smod
+ parent_module_name_full = submodule_export_match.group(1).lower()
+ parent_module_name = parent_module_name_full.split(':')[0]
+ submodule_name = submodule_export_match.group(2).lower()
+ concat_name = f'{parent_module_name}:{submodule_name}'
+ self.sources_with_exports.append(fname)
+ self.provided_by[concat_name] = fname
+ self.exports[fname] = concat_name
+ # Fortran requires that the immediate parent module must be built
+ # before the current one. Thus:
+ #
+ # submodule (parent) parent <- requires parent.mod (really parent.smod, but they are created at the same time)
+ # submodule (a1:a2) a3 <- requires a1@a2.smod
+ #
+ # a3 does not depend on the a1 parent module directly, only transitively.
+ if fname in self.needs:
+ self.needs[fname].append(parent_module_name_full)
+ else:
+ self.needs[fname] = [parent_module_name_full]
+
+ def scan_cpp_file(self, fname: str) -> None:
+ fpath = pathlib.Path(fname)
+ for line in fpath.read_text(encoding='utf-8').split('\n'):
+ import_match = CPP_IMPORT_RE.match(line)
+ export_match = CPP_EXPORT_RE.match(line)
+ if import_match:
+ needed = import_match.group(1)
+ if fname in self.needs:
+ self.needs[fname].append(needed)
+ else:
+ self.needs[fname] = [needed]
+ if export_match:
+ exported_module = export_match.group(1)
+ if exported_module in self.provided_by:
+ raise RuntimeError(f'Multiple files provide module {exported_module}.')
+ self.sources_with_exports.append(fname)
+ self.provided_by[exported_module] = fname
+ self.exports[fname] = exported_module
+
+ def objname_for(self, src: str) -> str:
+ objname = self.target_data.source2object[src]
+ assert isinstance(objname, str)
+ return objname
+
+ def module_name_for(self, src: str) -> str:
+ suffix = os.path.splitext(src)[1][1:].lower()
+ if suffix in lang_suffixes['fortran']:
+ exported = self.exports[src]
+ # Module foo:bar goes to a file name foo@bar.smod
+ # Module Foo goes to a file name foo.mod
+ namebase = exported.replace(':', '@')
+ if ':' in exported:
+ extension = 'smod'
+ else:
+ extension = 'mod'
+ return os.path.join(self.target_data.private_dir, f'{namebase}.{extension}')
+ elif suffix in lang_suffixes['cpp']:
+ return '{}.ifc'.format(self.exports[src])
+ else:
+ raise RuntimeError('Unreachable code.')
+
+ def scan(self) -> int:
+ for s in self.sources:
+ self.scan_file(s)
+ with open(self.outfile, 'w', encoding='utf-8') as ofile:
+ ofile.write('ninja_dyndep_version = 1\n')
+ for src in self.sources:
+ objfilename = self.objname_for(src)
+ mods_and_submods_needed = []
+ module_files_generated = []
+ module_files_needed = []
+ if src in self.sources_with_exports:
+ module_files_generated.append(self.module_name_for(src))
+ if src in self.needs:
+ for modname in self.needs[src]:
+ if modname not in self.provided_by:
+ # Nothing provides this module, we assume that it
+ # comes from a dependency library somewhere and is
+ # already built by the time this compilation starts.
+ pass
+ else:
+ mods_and_submods_needed.append(modname)
+
+ for modname in mods_and_submods_needed:
+ provider_src = self.provided_by[modname]
+ provider_modfile = self.module_name_for(provider_src)
+ # Prune self-dependencies
+ if provider_src != src:
+ module_files_needed.append(provider_modfile)
+
+ quoted_objfilename = ninja_quote(objfilename, True)
+ quoted_module_files_generated = [ninja_quote(x, True) for x in module_files_generated]
+ quoted_module_files_needed = [ninja_quote(x, True) for x in module_files_needed]
+ if quoted_module_files_generated:
+ mod_gen = '| ' + ' '.join(quoted_module_files_generated)
+ else:
+ mod_gen = ''
+ if quoted_module_files_needed:
+ mod_dep = '| ' + ' '.join(quoted_module_files_needed)
+ else:
+ mod_dep = ''
+ build_line = 'build {} {}: dyndep {}'.format(quoted_objfilename,
+ mod_gen,
+ mod_dep)
+ ofile.write(build_line + '\n')
+ return 0
+
+def run(args: T.List[str]) -> int:
+ assert len(args) == 3, 'got wrong number of arguments!'
+ pickle_file, outfile, jsonfile = args
+ with open(jsonfile, encoding='utf-8') as f:
+ sources = json.load(f)
+ scanner = DependencyScanner(pickle_file, outfile, sources)
+ return scanner.scan()
diff -Nru meson-0.53.2/mesonbuild/scripts/dirchanger.py meson-0.61.2/mesonbuild/scripts/dirchanger.py
--- meson-0.53.2/mesonbuild/scripts/dirchanger.py 2016-12-18 18:47:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/dirchanger.py 2021-04-01 21:12:21.000000000 +0000
@@ -16,8 +16,9 @@
the command given in the rest of the arguments.'''
import os, subprocess, sys
+import typing as T
-def run(args):
+def run(args: T.List[str]) -> int:
dirname = args[0]
command = args[1:]
diff -Nru meson-0.53.2/mesonbuild/scripts/externalproject.py meson-0.61.2/mesonbuild/scripts/externalproject.py
--- meson-0.53.2/mesonbuild/scripts/externalproject.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/externalproject.py 2021-11-02 19:58:07.000000000 +0000
@@ -0,0 +1,119 @@
+# Copyright 2019 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.
+
+import os
+import argparse
+import multiprocessing
+import subprocess
+from pathlib import Path
+import typing as T
+
+from ..mesonlib import Popen_safe, split_args
+
+class ExternalProject:
+ def __init__(self, options: argparse.Namespace):
+ self.name = options.name
+ self.src_dir = options.srcdir
+ self.build_dir = options.builddir
+ self.install_dir = options.installdir
+ self.log_dir = options.logdir
+ self.verbose = options.verbose
+ self.stampfile = options.stampfile
+ self.depfile = options.depfile
+ self.make = split_args(options.make)
+
+ def write_depfile(self) -> None:
+ with open(self.depfile, 'w', encoding='utf-8') as f:
+ f.write(f'{self.stampfile}: \\\n')
+ for dirpath, dirnames, filenames in os.walk(self.src_dir):
+ dirnames[:] = [d for d in dirnames if not d.startswith('.')]
+ for fname in filenames:
+ if fname.startswith('.'):
+ continue
+ path = Path(dirpath, fname)
+ f.write(' {} \\\n'.format(path.as_posix().replace(' ', '\\ ')))
+
+ def write_stampfile(self) -> None:
+ with open(self.stampfile, 'w', encoding='utf-8'):
+ pass
+
+ def gnu_make(self) -> bool:
+ p, o, e = Popen_safe(self.make + ['--version'])
+ if p.returncode == 0 and 'GNU Make' in o:
+ return True
+ return False
+
+ def build(self) -> int:
+ is_make = self.make[0] == 'make'
+ make_cmd = self.make.copy()
+ if is_make and self.gnu_make():
+ make_cmd.append(f'-j{multiprocessing.cpu_count()}')
+ rc = self._run('build', make_cmd)
+ if rc != 0:
+ return rc
+
+ install_cmd = self.make.copy()
+ install_env = {}
+ if is_make:
+ install_cmd.append(f'DESTDIR={self.install_dir}')
+ else:
+ install_env['DESTDIR'] = self.install_dir
+ install_cmd.append('install')
+ rc = self._run('install', install_cmd, install_env)
+ if rc != 0:
+ return rc
+
+ self.write_depfile()
+ self.write_stampfile()
+
+ return 0
+
+ def _run(self, step: str, command: T.List[str], env: T.Optional[T.Dict[str, str]] = None) -> int:
+ m = 'Running command ' + str(command) + ' in directory ' + str(self.build_dir) + '\n'
+ log_filename = Path(self.log_dir, f'{self.name}-{step}.log')
+ output = None
+ if not self.verbose:
+ output = open(log_filename, 'w', encoding='utf-8')
+ output.write(m + '\n')
+ output.flush()
+ else:
+ print(m)
+ run_env = os.environ.copy()
+ if env:
+ run_env.update(env)
+ p, o, e = Popen_safe(command, stderr=subprocess.STDOUT, stdout=output,
+ cwd=self.build_dir,
+ env=run_env)
+ if p.returncode != 0:
+ m = f'{step} step returned error code {p.returncode}.'
+ if not self.verbose:
+ m += '\nSee logs: ' + str(log_filename)
+ print(m)
+ return p.returncode
+
+def run(args: T.List[str]) -> int:
+ parser = argparse.ArgumentParser()
+ parser.add_argument('--name')
+ parser.add_argument('--srcdir')
+ parser.add_argument('--builddir')
+ parser.add_argument('--installdir')
+ parser.add_argument('--logdir')
+ parser.add_argument('--make')
+ parser.add_argument('--verbose', action='store_true')
+ parser.add_argument('stampfile')
+ parser.add_argument('depfile')
+
+ options = parser.parse_args(args)
+ ep = ExternalProject(options)
+ return ep.build()
diff -Nru meson-0.53.2/mesonbuild/scripts/gettext.py meson-0.61.2/mesonbuild/scripts/gettext.py
--- meson-0.53.2/mesonbuild/scripts/gettext.py 2019-04-17 08:08:43.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/gettext.py 2021-11-02 19:58:07.000000000 +0000
@@ -13,10 +13,9 @@
# limitations under the License.
import os
-import shutil
import argparse
import subprocess
-from . import destdir_join
+import typing as T
parser = argparse.ArgumentParser()
parser.add_argument('command')
@@ -27,23 +26,23 @@
parser.add_argument('--subdir', default='')
parser.add_argument('--extra-args', default='')
-def read_linguas(src_sub):
+def read_linguas(src_sub: str) -> T.List[str]:
# Syntax of this file is documented here:
# https://www.gnu.org/software/gettext/manual/html_node/po_002fLINGUAS.html
linguas = os.path.join(src_sub, 'LINGUAS')
try:
langs = []
- with open(linguas) as f:
+ with open(linguas, encoding='utf-8') as f:
for line in f:
line = line.strip()
if line and not line.startswith('#'):
langs += line.split()
return langs
except (FileNotFoundError, PermissionError):
- print('Could not find file LINGUAS in {}'.format(src_sub))
+ print(f'Could not find file LINGUAS in {src_sub}')
return []
-def run_potgen(src_sub, pkgname, datadirs, args):
+def run_potgen(src_sub: str, pkgname: str, datadirs: str, args: T.List[str]) -> int:
listfile = os.path.join(src_sub, 'POTFILES.in')
if not os.path.exists(listfile):
listfile = os.path.join(src_sub, 'POTFILES')
@@ -60,13 +59,7 @@
'-D', os.environ['MESON_SOURCE_ROOT'], '-k_', '-o', ofile] + args,
env=child_env)
-def gen_gmo(src_sub, bld_sub, langs):
- for l in langs:
- subprocess.check_call(['msgfmt', os.path.join(src_sub, l + '.po'),
- '-o', os.path.join(bld_sub, l + '.gmo')])
- return 0
-
-def update_po(src_sub, pkgname, langs):
+def update_po(src_sub: str, pkgname: str, langs: T.List[str]) -> int:
potfile = os.path.join(src_sub, pkgname + '.pot')
for l in langs:
pofile = os.path.join(src_sub, l + '.po')
@@ -76,20 +69,7 @@
subprocess.check_call(['msginit', '--input', potfile, '--output-file', pofile, '--locale', l, '--no-translator'])
return 0
-def do_install(src_sub, bld_sub, dest, pkgname, langs):
- for l in langs:
- srcfile = os.path.join(bld_sub, l + '.gmo')
- outfile = os.path.join(dest, l, 'LC_MESSAGES',
- pkgname + '.mo')
- tempfile = outfile + '.tmp'
- os.makedirs(os.path.dirname(outfile), exist_ok=True)
- shutil.copyfile(srcfile, tempfile)
- shutil.copystat(srcfile, tempfile)
- os.replace(tempfile, outfile)
- print('Installing %s to %s' % (srcfile, outfile))
- return 0
-
-def run(args):
+def run(args: T.List[str]) -> int:
options = parser.parse_args(args)
subcmd = options.command
langs = options.langs.split('@@') if options.langs else None
@@ -98,26 +78,16 @@
if options.subdir:
subdir = options.subdir
src_sub = os.path.join(os.environ['MESON_SOURCE_ROOT'], subdir)
- bld_sub = os.path.join(os.environ['MESON_BUILD_ROOT'], subdir)
if not langs:
langs = read_linguas(src_sub)
if subcmd == 'pot':
return run_potgen(src_sub, options.pkgname, options.datadirs, extra_args)
- elif subcmd == 'gen_gmo':
- return gen_gmo(src_sub, bld_sub, langs)
elif subcmd == 'update_po':
if run_potgen(src_sub, options.pkgname, options.datadirs, extra_args) != 0:
return 1
return update_po(src_sub, options.pkgname, langs)
- elif subcmd == 'install':
- destdir = os.environ.get('DESTDIR', '')
- dest = destdir_join(destdir, os.path.join(os.environ['MESON_INSTALL_PREFIX'],
- options.localedir))
- if gen_gmo(src_sub, bld_sub, langs) != 0:
- return 1
- do_install(src_sub, bld_sub, dest, options.pkgname, langs)
else:
print('Unknown subcommand.')
return 1
diff -Nru meson-0.53.2/mesonbuild/scripts/gtkdochelper.py meson-0.61.2/mesonbuild/scripts/gtkdochelper.py
--- meson-0.53.2/mesonbuild/scripts/gtkdochelper.py 2019-09-16 21:20:45.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/gtkdochelper.py 2021-04-27 06:49:45.000000000 +0000
@@ -16,8 +16,9 @@
import subprocess
import shutil
import argparse
-from ..mesonlib import MesonException, Popen_safe, is_windows, split_args
+from ..mesonlib import MesonException, Popen_safe, is_windows, is_cygwin, split_args
from . import destdir_join
+import typing as T
parser = argparse.ArgumentParser()
@@ -50,12 +51,12 @@
program_name = 'gtkdoc-' + tool
parser.add_argument('--' + program_name, dest=program_name.replace('-', '_'))
-def gtkdoc_run_check(cmd, cwd, library_paths=None):
+def gtkdoc_run_check(cmd: T.List[str], cwd: str, library_paths: T.Optional[T.List[str]] = None) -> None:
if library_paths is None:
library_paths = []
env = dict(os.environ)
- if is_windows():
+ if is_windows() or is_cygwin():
if 'PATH' in env:
library_paths.extend(env['PATH'].split(os.pathsep))
env['PATH'] = os.pathsep.join(library_paths)
@@ -64,23 +65,33 @@
library_paths.extend(env['LD_LIBRARY_PATH'].split(os.pathsep))
env['LD_LIBRARY_PATH'] = os.pathsep.join(library_paths)
+ if is_windows():
+ cmd.insert(0, sys.executable)
+
# Put stderr into stdout since we want to print it out anyway.
# This preserves the order of messages.
p, out = Popen_safe(cmd, cwd=cwd, env=env, stderr=subprocess.STDOUT)[0:2]
if p.returncode != 0:
- err_msg = ["{!r} failed with status {:d}".format(cmd, p.returncode)]
+ err_msg = [f"{cmd!r} failed with status {p.returncode:d}"]
if out:
err_msg.append(out)
raise MesonException('\n'.join(err_msg))
elif out:
- print(out)
-
-def build_gtkdoc(source_root, build_root, doc_subdir, src_subdirs,
- main_file, module, module_version,
- html_args, scan_args, fixxref_args, mkdb_args,
- gobject_typesfile, scanobjs_args, run, ld, cc, ldflags, cflags,
- html_assets, content_files, ignore_headers, namespace,
- expand_content_files, mode, options):
+ # Unfortunately Windows cmd.exe consoles may be using a codepage
+ # that might choke print() with a UnicodeEncodeError, so let's
+ # ignore such errors for now, as a compromise as we are outputting
+ # console output here...
+ try:
+ print(out)
+ except UnicodeEncodeError:
+ pass
+
+def build_gtkdoc(source_root: str, build_root: str, doc_subdir: str, src_subdirs: T.List[str],
+ main_file: str, module: str, module_version: str,
+ html_args: T.List[str], scan_args: T.List[str], fixxref_args: T.List[str], mkdb_args: T.List[str],
+ gobject_typesfile: str, scanobjs_args: T.List[str], run: str, ld: str, cc: str, ldflags: str, cflags: str,
+ html_assets: T.List[str], content_files: T.List[str], ignore_headers: T.List[str], namespace: str,
+ expand_content_files: T.List[str], mode: str, options: argparse.Namespace) -> None:
print("Building documentation for %s" % module)
src_dir_args = []
@@ -204,16 +215,16 @@
gtkdoc_run_check(fixref_cmd, abs_out)
if module_version:
- shutil.move(os.path.join(htmldir, '{}.devhelp2'.format(module)),
- os.path.join(htmldir, '{}-{}.devhelp2'.format(module, module_version)))
+ shutil.move(os.path.join(htmldir, f'{module}.devhelp2'),
+ os.path.join(htmldir, f'{module}-{module_version}.devhelp2'))
-def install_gtkdoc(build_root, doc_subdir, install_prefix, datadir, module):
+def install_gtkdoc(build_root: str, doc_subdir: str, install_prefix: str, datadir: str, module: str) -> None:
source = os.path.join(build_root, doc_subdir, 'html')
final_destination = os.path.join(install_prefix, datadir, module)
shutil.rmtree(final_destination, ignore_errors=True)
shutil.copytree(source, final_destination)
-def run(args):
+def run(args: T.List[str]) -> int:
options = parser.parse_args(args)
if options.htmlargs:
htmlargs = options.htmlargs.split('@@')
diff -Nru meson-0.53.2/mesonbuild/scripts/hotdochelper.py meson-0.61.2/mesonbuild/scripts/hotdochelper.py
--- meson-0.53.2/mesonbuild/scripts/hotdochelper.py 2018-10-31 09:31:20.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/hotdochelper.py 2021-04-01 21:12:21.000000000 +0000
@@ -5,6 +5,7 @@
from . import destdir_join
import argparse
+import typing as T
parser = argparse.ArgumentParser()
parser.add_argument('--install')
@@ -14,7 +15,7 @@
parser.add_argument('--project-version')
-def run(argv):
+def run(argv: T.List[str]) -> int:
options, args = parser.parse_known_args(argv)
subenv = os.environ.copy()
@@ -23,7 +24,7 @@
res = subprocess.call(args, cwd=options.builddir, env=subenv)
if res != 0:
- exit(res)
+ return res
if options.install:
source_dir = os.path.join(options.builddir, options.install)
@@ -34,3 +35,4 @@
shutil.rmtree(installdir, ignore_errors=True)
shutil.copytree(source_dir, installdir)
+ return 0
diff -Nru meson-0.53.2/mesonbuild/scripts/__init__.py meson-0.61.2/mesonbuild/scripts/__init__.py
--- meson-0.53.2/mesonbuild/scripts/__init__.py 2017-01-12 20:52:44.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/__init__.py 2021-04-01 21:12:21.000000000 +0000
@@ -12,7 +12,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-def destdir_join(d1, d2):
+# TODO: consider switching to pathlib for this
+def destdir_join(d1: str, d2: str) -> str:
# c:\destdir + c:\prefix must produce c:\destdir\prefix
if len(d1) > 1 and d1[1] == ':' \
and len(d2) > 1 and d2[1] == ':':
diff -Nru meson-0.53.2/mesonbuild/scripts/meson_exe.py meson-0.61.2/mesonbuild/scripts/meson_exe.py
--- meson-0.53.2/mesonbuild/scripts/meson_exe.py 2019-09-16 21:20:45.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/meson_exe.py 2021-12-26 16:24:25.000000000 +0000
@@ -16,74 +16,91 @@
import sys
import argparse
import pickle
-import platform
import subprocess
+import typing as T
+import locale
from .. import mesonlib
from ..backend.backends import ExecutableSerialisation
options = None
-def buildparser():
+def buildparser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description='Custom executable wrapper for Meson. Do not run on your own, mmm\'kay?')
parser.add_argument('--unpickle')
parser.add_argument('--capture')
+ parser.add_argument('--feed')
return parser
-def is_windows():
- platname = platform.system().lower()
- return platname == 'windows' or 'mingw' in platname
-
-def is_cygwin():
- platname = platform.system().lower()
- return 'cygwin' in platname
-
-def run_exe(exe):
- if exe.exe_runner:
- if not exe.exe_runner.found():
+def run_exe(exe: ExecutableSerialisation, extra_env: T.Optional[T.Dict[str, str]] = None) -> int:
+ if exe.exe_wrapper:
+ if not exe.exe_wrapper.found():
raise AssertionError('BUG: Can\'t run cross-compiled exe {!r} with not-found '
- 'wrapper {!r}'.format(exe.cmd_args[0], exe.exe_runner.get_path()))
- cmd_args = exe.exe_runner.get_command() + exe.cmd_args
+ 'wrapper {!r}'.format(exe.cmd_args[0], exe.exe_wrapper.get_path()))
+ cmd_args = exe.exe_wrapper.get_command() + exe.cmd_args
else:
cmd_args = exe.cmd_args
child_env = os.environ.copy()
- child_env.update(exe.env)
+ if extra_env:
+ child_env.update(extra_env)
+ if exe.env:
+ child_env = exe.env.get_env(child_env)
if exe.extra_paths:
child_env['PATH'] = (os.pathsep.join(exe.extra_paths + ['']) +
child_env['PATH'])
- if exe.exe_runner and mesonlib.substring_is_in_list('wine', exe.exe_runner.get_command()):
+ if exe.exe_wrapper and mesonlib.substring_is_in_list('wine', exe.exe_wrapper.get_command()):
child_env['WINEPATH'] = mesonlib.get_wine_shortpath(
- exe.exe_runner.get_command(),
+ exe.exe_wrapper.get_command(),
['Z:' + p for p in exe.extra_paths] + child_env.get('WINEPATH', '').split(';')
)
+ stdin = None
+ if exe.feed:
+ stdin = open(exe.feed, 'rb')
+
+ pipe = subprocess.PIPE
+ if exe.verbose:
+ assert not exe.capture, 'Cannot capture and print to console at the same time'
+ pipe = None
+
p = subprocess.Popen(cmd_args, env=child_env, cwd=exe.workdir,
- close_fds=False,
- stdout=subprocess.PIPE,
- stderr=subprocess.PIPE)
+ close_fds=False, stdin=stdin, stdout=pipe, stderr=pipe)
stdout, stderr = p.communicate()
+ if stdin is not None:
+ stdin.close()
+
if p.returncode == 0xc0000135:
# STATUS_DLL_NOT_FOUND on Windows indicating a common problem that is otherwise hard to diagnose
- raise FileNotFoundError('Missing DLLs on calling {!r}'.format(exe.name))
+ raise FileNotFoundError('due to missing DLLs')
+
+ if p.returncode != 0:
+ if exe.pickled:
+ print(f'while executing {cmd_args!r}')
+ if exe.verbose:
+ return p.returncode
+ encoding = locale.getpreferredencoding()
+ if not exe.capture:
+ print('--- stdout ---')
+ print(stdout.decode(encoding=encoding, errors='replace'))
+ print('--- stderr ---')
+ print(stderr.decode(encoding=encoding, errors='replace'))
+ return p.returncode
- if exe.capture and p.returncode == 0:
+ if exe.capture:
skip_write = False
try:
with open(exe.capture, 'rb') as cur:
skip_write = cur.read() == stdout
- except IOError:
+ except OSError:
pass
if not skip_write:
with open(exe.capture, 'wb') as output:
output.write(stdout)
- else:
- sys.stdout.buffer.write(stdout)
- if stderr:
- sys.stderr.buffer.write(stderr)
- return p.returncode
-def run(args):
+ return 0
+
+def run(args: T.List[str]) -> int:
global options
parser = buildparser()
options, cmd_args = parser.parse_known_args(args)
@@ -94,12 +111,13 @@
if not options.unpickle and not cmd_args:
parser.error('either --unpickle or executable and arguments are required')
if options.unpickle:
- if cmd_args or options.capture:
+ if cmd_args or options.capture or options.feed:
parser.error('no other arguments can be used with --unpickle')
with open(options.unpickle, 'rb') as f:
exe = pickle.load(f)
+ exe.pickled = True
else:
- exe = ExecutableSerialisation(cmd_args, capture=options.capture)
+ exe = ExecutableSerialisation(cmd_args, capture=options.capture, feed=options.feed)
return run_exe(exe)
diff -Nru meson-0.53.2/mesonbuild/scripts/msgfmthelper.py meson-0.61.2/mesonbuild/scripts/msgfmthelper.py
--- meson-0.53.2/mesonbuild/scripts/msgfmthelper.py 2019-05-02 18:59:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/msgfmthelper.py 2021-04-01 21:12:21.000000000 +0000
@@ -15,6 +15,7 @@
import argparse
import subprocess
import os
+import typing as T
parser = argparse.ArgumentParser()
parser.add_argument('input')
@@ -25,7 +26,7 @@
parser.add_argument('args', default=[], metavar='extra msgfmt argument', nargs='*')
-def run(args):
+def run(args: T.List[str]) -> int:
options = parser.parse_args(args)
env = None
if options.datadirs:
diff -Nru meson-0.53.2/mesonbuild/scripts/regen_checker.py meson-0.61.2/mesonbuild/scripts/regen_checker.py
--- meson-0.53.2/mesonbuild/scripts/regen_checker.py 2018-08-25 08:05:43.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/regen_checker.py 2021-04-27 06:50:21.000000000 +0000
@@ -14,10 +14,14 @@
import sys, os
import pickle, subprocess
+import typing as T
+from ..coredata import CoreData
+from ..backend.backends import RegenInfo
+from ..mesonlib import OptionKey
# This could also be used for XCode.
-def need_regen(regeninfo, regen_timestamp):
+def need_regen(regeninfo: RegenInfo, regen_timestamp: float) -> bool:
for i in regeninfo.depfiles:
curfile = os.path.join(regeninfo.build_dir, i)
curtime = os.stat(curfile).st_mtime
@@ -31,7 +35,7 @@
Vs2010Backend.touch_regen_timestamp(regeninfo.build_dir)
return False
-def regen(regeninfo, meson_command, backend):
+def regen(regeninfo: RegenInfo, meson_command: T.List[str], backend: str) -> None:
cmd = meson_command + ['--internal',
'regenerate',
regeninfo.build_dir,
@@ -39,19 +43,22 @@
'--backend=' + backend]
subprocess.check_call(cmd)
-def run(args):
+def run(args: T.List[str]) -> int:
private_dir = args[0]
dumpfile = os.path.join(private_dir, 'regeninfo.dump')
- coredata = os.path.join(private_dir, 'coredata.dat')
+ coredata_file = os.path.join(private_dir, 'coredata.dat')
with open(dumpfile, 'rb') as f:
regeninfo = pickle.load(f)
- with open(coredata, 'rb') as f:
+ assert isinstance(regeninfo, RegenInfo)
+ with open(coredata_file, 'rb') as f:
coredata = pickle.load(f)
- backend = coredata.get_builtin_option('backend')
+ assert isinstance(coredata, CoreData)
+ backend = coredata.get_option(OptionKey('backend'))
+ assert isinstance(backend, str)
regen_timestamp = os.stat(dumpfile).st_mtime
if need_regen(regeninfo, regen_timestamp):
regen(regeninfo, coredata.meson_command, backend)
- sys.exit(0)
+ return 0
if __name__ == '__main__':
- run(sys.argv[1:])
+ sys.exit(run(sys.argv[1:]))
diff -Nru meson-0.53.2/mesonbuild/scripts/run_tool.py meson-0.61.2/mesonbuild/scripts/run_tool.py
--- meson-0.53.2/mesonbuild/scripts/run_tool.py 1970-01-01 00:00:00.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/run_tool.py 2021-12-26 16:24:25.000000000 +0000
@@ -0,0 +1,65 @@
+# Copyright 2018 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.
+
+import subprocess
+import itertools
+import fnmatch
+from pathlib import Path
+from concurrent.futures import ThreadPoolExecutor
+
+from ..compilers import lang_suffixes
+from ..mesonlib import Popen_safe
+import typing as T
+
+def parse_pattern_file(fname: Path) -> T.List[str]:
+ patterns = []
+ try:
+ with fname.open(encoding='utf-8') as f:
+ for line in f:
+ pattern = line.strip()
+ if pattern and not pattern.startswith('#'):
+ patterns.append(pattern)
+ except FileNotFoundError:
+ pass
+ return patterns
+
+def run_tool(name: str, srcdir: Path, builddir: Path, fn: T.Callable[..., subprocess.CompletedProcess], *args: T.Any) -> int:
+ patterns = parse_pattern_file(srcdir / f'.{name}-include')
+ globs: T.Union[T.List[T.List[Path]], T.List[T.Generator[Path, None, None]]]
+ if patterns:
+ globs = [srcdir.glob(p) for p in patterns]
+ else:
+ p, o, _ = Popen_safe(['git', 'ls-files'], cwd=srcdir)
+ if p.returncode == 0:
+ globs = [[Path(srcdir, f) for f in o.splitlines()]]
+ else:
+ globs = [srcdir.glob('**/*')]
+ patterns = parse_pattern_file(srcdir / f'.{name}-ignore')
+ ignore = [str(builddir / '*')]
+ ignore.extend([str(srcdir / p) for p in patterns])
+ suffixes = set(lang_suffixes['c']).union(set(lang_suffixes['cpp']))
+ suffixes.add('h')
+ suffixes = {f'.{s}' for s in suffixes}
+ futures = []
+ returncode = 0
+ with ThreadPoolExecutor() as e:
+ for f in itertools.chain(*globs):
+ strf = str(f)
+ if f.is_dir() or f.suffix not in suffixes or \
+ any(fnmatch.fnmatch(strf, i) for i in ignore):
+ continue
+ futures.append(e.submit(fn, f, *args))
+ if futures:
+ returncode = max(x.result().returncode for x in futures)
+ return returncode
diff -Nru meson-0.53.2/mesonbuild/scripts/scanbuild.py meson-0.61.2/mesonbuild/scripts/scanbuild.py
--- meson-0.53.2/mesonbuild/scripts/scanbuild.py 2019-12-04 18:45:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/scanbuild.py 2021-08-18 11:22:15.000000000 +0000
@@ -12,34 +12,54 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-import os
import subprocess
import shutil
import tempfile
from ..environment import detect_ninja, detect_scanbuild
+from ..coredata import get_cmd_line_file, CmdLineFileParser
+from ..mesonlib import windows_proof_rmtree
+from pathlib import Path
+import typing as T
+from ast import literal_eval
+import os
-
-def scanbuild(exelist, srcdir, blddir, privdir, logdir, args):
- with tempfile.TemporaryDirectory(dir=privdir) as scandir:
- meson_cmd = exelist + args
- build_cmd = exelist + ['-o', logdir, detect_ninja(), '-C', scandir]
- rc = subprocess.call(meson_cmd + [srcdir, scandir])
- if rc != 0:
- return rc
- return subprocess.call(build_cmd)
-
-
-def run(args):
- srcdir = args[0]
+def scanbuild(exelist: T.List[str], srcdir: Path, blddir: Path, privdir: Path, logdir: Path, args: T.List[str]) -> int:
+ # In case of problems leave the temp directory around
+ # so it can be debugged.
+ scandir = tempfile.mkdtemp(dir=str(privdir))
+ meson_cmd = exelist + args
+ build_cmd = exelist + ['-o', str(logdir)] + detect_ninja() + ['-C', scandir]
+ rc = subprocess.call(meson_cmd + [str(srcdir), scandir])
+ if rc != 0:
+ return rc
+ rc = subprocess.call(build_cmd)
+ if rc == 0:
+ windows_proof_rmtree(scandir)
+ return rc
+
+def run(args: T.List[str]) -> int:
+ srcdir = Path(args[0])
+ bldpath = Path(args[1])
blddir = args[1]
meson_cmd = args[2:]
- privdir = os.path.join(blddir, 'meson-private')
- logdir = os.path.join(blddir, 'meson-logs/scanbuild')
- shutil.rmtree(logdir, ignore_errors=True)
+ privdir = bldpath / 'meson-private'
+ logdir = bldpath / 'meson-logs' / 'scanbuild'
+ shutil.rmtree(str(logdir), ignore_errors=True)
+
+ # if any cross or native files are specified we should use them
+ cmd = get_cmd_line_file(blddir)
+ data = CmdLineFileParser()
+ data.read(cmd)
+
+ if 'cross_file' in data['properties']:
+ meson_cmd.extend([f'--cross-file={os.path.abspath(f)}' for f in literal_eval(data['properties']['cross_file'])])
+
+ if 'native_file' in data['properties']:
+ meson_cmd.extend([f'--native-file={os.path.abspath(f)}' for f in literal_eval(data['properties']['native_file'])])
exelist = detect_scanbuild()
if not exelist:
print('Could not execute scan-build "%s"' % ' '.join(exelist))
return 1
- return scanbuild(exelist, srcdir, blddir, privdir, logdir, meson_cmd)
+ return scanbuild(exelist, srcdir, bldpath, privdir, logdir, meson_cmd)
diff -Nru meson-0.53.2/mesonbuild/scripts/symbolextractor.py meson-0.61.2/mesonbuild/scripts/symbolextractor.py
--- meson-0.53.2/mesonbuild/scripts/symbolextractor.py 2019-05-02 18:59:50.000000000 +0000
+++ meson-0.61.2/mesonbuild/scripts/symbolextractor.py 2021-11-02 19:58:07.000000000 +0000
@@ -20,8 +20,10 @@
# This file is basically a reimplementation of
# http://cgit.freedesktop.org/libreoffice/core/commit/?id=3213cd54b76bc80a6f0516aac75a48ff3b2ad67c
+import typing as T
import os, sys
from .. import mesonlib
+from .. import mlog
from ..mesonlib import Popen_safe
import argparse
@@ -31,91 +33,298 @@
help='cross compilation host platform')
parser.add_argument('args', nargs='+')
-def dummy_syms(outfilename):
+TOOL_WARNING_FILE = None
+RELINKING_WARNING = 'Relinking will always happen on source changes.'
+
+def dummy_syms(outfilename: str) -> None:
"""Just touch it so relinking happens always."""
- with open(outfilename, 'w'):
+ with open(outfilename, 'w', encoding='utf-8'):
pass
-def write_if_changed(text, outfilename):
+def write_if_changed(text: str, outfilename: str) -> None:
try:
- with open(outfilename, 'r') as f:
+ with open(outfilename, encoding='utf-8') as f:
oldtext = f.read()
if text == oldtext:
return
except FileNotFoundError:
pass
- with open(outfilename, 'w') as f:
+ with open(outfilename, 'w', encoding='utf-8') as f:
f.write(text)
-def linux_syms(libfilename, outfilename):
- evar = 'READELF'
- if evar in os.environ:
- readelfbin = os.environ[evar].strip()
- else:
- readelfbin = 'readelf'
- evar = 'NM'
+def print_tool_warning(tools: T.List[str], msg: str, stderr: T.Optional[str] = None) -> None:
+ global TOOL_WARNING_FILE
+ if os.path.exists(TOOL_WARNING_FILE):
+ return
+ m = f'{tools!r} {msg}. {RELINKING_WARNING}'
+ if stderr:
+ m += '\n' + stderr
+ mlog.warning(m)
+ # Write it out so we don't warn again
+ with open(TOOL_WARNING_FILE, 'w', encoding='utf-8'):
+ pass
+
+def get_tool(name: str) -> T.List[str]:
+ evar = name.upper()
if evar in os.environ:
- nmbin = os.environ[evar].strip()
- else:
- nmbin = 'nm'
- pe, output = Popen_safe([readelfbin, '-d', libfilename])[0:2]
- if pe.returncode != 0:
- raise RuntimeError('Readelf does not work')
+ import shlex
+ return shlex.split(os.environ[evar])
+ return [name]
+
+def call_tool(name: str, args: T.List[str], **kwargs: T.Any) -> str:
+ tool = get_tool(name)
+ try:
+ p, output, e = Popen_safe(tool + args, **kwargs)
+ except FileNotFoundError:
+ print_tool_warning(tool, 'not found')
+ return None
+ except PermissionError:
+ print_tool_warning(tool, 'not usable')
+ return None
+ if p.returncode != 0:
+ print_tool_warning(tool, 'does not work', e)
+ return None
+ return output
+
+def call_tool_nowarn(tool: T.List[str], **kwargs: T.Any) -> T.Tuple[str, str]:
+ try:
+ p, output, e = Popen_safe(tool, **kwargs)
+ except FileNotFoundError:
+ return None, '{!r} not found\n'.format(tool[0])
+ except PermissionError:
+ return None, '{!r} not usable\n'.format(tool[0])
+ if p.returncode != 0:
+ return None, e
+ return output, None
+
+def gnu_syms(libfilename: str, outfilename: str) -> None:
+ # Get the name of the library
+ output = call_tool('readelf', ['-d', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
result = [x for x in output.split('\n') if 'SONAME' in x]
- assert(len(result) <= 1)
- pnm, output = Popen_safe([nmbin, '--dynamic', '--extern-only',
- '--defined-only', '--format=posix',
- libfilename])[0:2]
- if pnm.returncode != 0:
- raise RuntimeError('nm does not work.')
+ assert len(result) <= 1
+ # Get a list of all symbols exported
+ output = call_tool('nm', ['--dynamic', '--extern-only', '--defined-only',
+ '--format=posix', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
for line in output.split('\n'):
if not line:
continue
line_split = line.split()
entry = line_split[0:2]
- if len(line_split) >= 4:
+ # Store the size of symbols pointing to data objects so we relink
+ # when those change, which is needed because of copy relocations
+ # https://github.com/mesonbuild/meson/pull/7132#issuecomment-628353702
+ if line_split[1].upper() in ('B', 'G', 'D') and len(line_split) >= 4:
entry += [line_split[3]]
result += [' '.join(entry)]
write_if_changed('\n'.join(result) + '\n', outfilename)
-def osx_syms(libfilename, outfilename):
- pe, output = Popen_safe(['otool', '-l', libfilename])[0:2]
- if pe.returncode != 0:
- raise RuntimeError('Otool does not work.')
+def solaris_syms(libfilename: str, outfilename: str) -> None:
+ # gnu_syms() works with GNU nm & readelf, not Solaris nm & elfdump
+ origpath = os.environ['PATH']
+ try:
+ os.environ['PATH'] = '/usr/gnu/bin:' + origpath
+ gnu_syms(libfilename, outfilename)
+ finally:
+ os.environ['PATH'] = origpath
+
+def osx_syms(libfilename: str, outfilename: str) -> None:
+ # Get the name of the library
+ output = call_tool('otool', ['-l', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
arr = output.split('\n')
for (i, val) in enumerate(arr):
if 'LC_ID_DYLIB' in val:
match = i
break
result = [arr[match + 2], arr[match + 5]] # Libreoffice stores all 5 lines but the others seem irrelevant.
- pnm, output = Popen_safe(['nm', '-g', '-P', libfilename])[0:2]
- if pnm.returncode != 0:
- raise RuntimeError('nm does not work.')
- result += [' '.join(x.split()[0:2]) for x in output.split('\n') if x and not x.endswith('U')]
+ # Get a list of all symbols exported
+ output = call_tool('nm', ['--extern-only', '--defined-only',
+ '--format=posix', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+ result += [' '.join(x.split()[0:2]) for x in output.split('\n')]
+ write_if_changed('\n'.join(result) + '\n', outfilename)
+
+def openbsd_syms(libfilename: str, outfilename: str) -> None:
+ # Get the name of the library
+ output = call_tool('readelf', ['-d', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+ result = [x for x in output.split('\n') if 'SONAME' in x]
+ assert len(result) <= 1
+ # Get a list of all symbols exported
+ output = call_tool('nm', ['-D', '-P', '-g', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+ # U = undefined (cope with the lack of --defined-only option)
+ result += [' '.join(x.split()[0:2]) for x in output.split('\n') if x and not x.endswith('U ')]
+ write_if_changed('\n'.join(result) + '\n', outfilename)
+
+def freebsd_syms(libfilename: str, outfilename: str) -> None:
+ # Get the name of the library
+ output = call_tool('readelf', ['-d', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+ result = [x for x in output.split('\n') if 'SONAME' in x]
+ assert len(result) <= 1
+ # Get a list of all symbols exported
+ output = call_tool('nm', ['--dynamic', '--extern-only', '--defined-only',
+ '--format=posix', libfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+
+ result += [' '.join(x.split()[0:2]) for x in output.split('\n')]
+ write_if_changed('\n'.join(result) + '\n', outfilename)
+
+def cygwin_syms(impfilename: str, outfilename: str) -> None:
+ # Get the name of the library
+ output = call_tool('dlltool', ['-I', impfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+ result = [output]
+ # Get the list of all symbols exported
+ output = call_tool('nm', ['--extern-only', '--defined-only',
+ '--format=posix', impfilename])
+ if not output:
+ dummy_syms(outfilename)
+ return
+ for line in output.split('\n'):
+ if ' T ' not in line:
+ continue
+ result.append(line.split(maxsplit=1)[0])
+ write_if_changed('\n'.join(result) + '\n', outfilename)
+
+def _get_implib_dllname(impfilename: str) -> T.Tuple[T.List[str], str]:
+ all_stderr = ''
+ # First try lib.exe, which is provided by MSVC. Then llvm-lib.exe, by LLVM
+ # for clang-cl.
+ #
+ # We cannot call get_tool on `lib` because it will look at the `LIB` env
+ # var which is the list of library paths MSVC will search for import
+ # libraries while linking.
+ for lib in (['lib'], get_tool('llvm-lib')):
+ output, e = call_tool_nowarn(lib + ['-list', impfilename])
+ if output:
+ # The output is a list of DLLs that each symbol exported by the import
+ # library is available in. We only build import libraries that point to
+ # a single DLL, so we can pick any of these. Pick the last one for
+ # simplicity. Also skip the last line, which is empty.
+ return output.split('\n')[-2:-1], None
+ all_stderr += e
+ # Next, try dlltool.exe which is provided by MinGW
+ output, e = call_tool_nowarn(get_tool('dlltool') + ['-I', impfilename])
+ if output:
+ return [output], None
+ all_stderr += e
+ return ([], all_stderr)
+
+def _get_implib_exports(impfilename: str) -> T.Tuple[T.List[str], str]:
+ all_stderr = ''
+ # Force dumpbin.exe to use en-US so we can parse its output
+ env = os.environ.copy()
+ env['VSLANG'] = '1033'
+ output, e = call_tool_nowarn(get_tool('dumpbin') + ['-exports', impfilename], env=env)
+ if output:
+ lines = output.split('\n')
+ start = lines.index('File Type: LIBRARY')
+ end = lines.index(' Summary')
+ return lines[start:end], None
+ all_stderr += e
+ # Next, try llvm-nm.exe provided by LLVM, then nm.exe provided by MinGW
+ for nm in ('llvm-nm', 'nm'):
+ output, e = call_tool_nowarn(get_tool(nm) + ['--extern-only', '--defined-only',
+ '--format=posix', impfilename])
+ if output:
+ result = []
+ for line in output.split('\n'):
+ if ' T ' not in line or line.startswith('.text'):
+ continue
+ result.append(line.split(maxsplit=1)[0])
+ return result, None
+ all_stderr += e
+ return ([], all_stderr)
+
+def windows_syms(impfilename: str, outfilename: str) -> None:
+ # Get the name of the library
+ result, e = _get_implib_dllname(impfilename)
+ if not result:
+ print_tool_warning(['lib', 'llvm-lib', 'dlltool'], 'do not work or were not found', e)
+ dummy_syms(outfilename)
+ return
+ # Get a list of all symbols exported
+ symbols, e = _get_implib_exports(impfilename)
+ if not symbols:
+ print_tool_warning(['dumpbin', 'llvm-nm', 'nm'], 'do not work or were not found', e)
+ dummy_syms(outfilename)
+ return
+ result += symbols
write_if_changed('\n'.join(result) + '\n', outfilename)
-def gen_symbols(libfilename, outfilename, cross_host):
+def gen_symbols(libfilename: str, impfilename: str, outfilename: str, cross_host: str) -> None:
if cross_host is not None:
- # In case of cross builds just always relink.
- # In theory we could determine the correct
- # toolset but there are more important things
- # to do.
+ # In case of cross builds just always relink. In theory we could
+ # determine the correct toolset, but we would need to use the correct
+ # `nm`, `readelf`, etc, from the cross info which requires refactoring.
dummy_syms(outfilename)
- elif mesonlib.is_linux():
- linux_syms(libfilename, outfilename)
+ elif mesonlib.is_linux() or mesonlib.is_hurd():
+ gnu_syms(libfilename, outfilename)
elif mesonlib.is_osx():
osx_syms(libfilename, outfilename)
+ elif mesonlib.is_openbsd():
+ openbsd_syms(libfilename, outfilename)
+ elif mesonlib.is_freebsd():
+ freebsd_syms(libfilename, outfilename)
+ elif mesonlib.is_windows():
+ if os.path.isfile(impfilename):
+ windows_syms(impfilename, outfilename)
+ else:
+ # No import library. Not sure how the DLL is being used, so just
+ # rebuild everything that links to it every time.
+ dummy_syms(outfilename)
+ elif mesonlib.is_cygwin():
+ if os.path.isfile(impfilename):
+ cygwin_syms(impfilename, outfilename)
+ else:
+ # No import library. Not sure how the DLL is being used, so just
+ # rebuild everything that links to it every time.
+ dummy_syms(outfilename)
+ elif mesonlib.is_sunos():
+ solaris_syms(libfilename, outfilename)
else:
+ if not os.path.exists(TOOL_WARNING_FILE):
+ mlog.warning('Symbol extracting has not been implemented for this '
+ 'platform. ' + RELINKING_WARNING)
+ # Write it out so we don't warn again
+ with open(TOOL_WARNING_FILE, 'w', encoding='utf-8'):
+ pass
dummy_syms(outfilename)
-def run(args):
+def run(args: T.List[str]) -> int:
+ global TOOL_WARNING_FILE
options = parser.parse_args(args)
- if len(options.args) != 2:
- print('symbolextractor.py