summaryrefslogtreecommitdiffstats
path: root/mesonbuild/cmake
diff options
context:
space:
mode:
Diffstat (limited to 'mesonbuild/cmake')
-rw-r--r--mesonbuild/cmake/__init__.py48
-rw-r--r--mesonbuild/cmake/common.py348
-rw-r--r--mesonbuild/cmake/data/__init__.py0
-rw-r--r--mesonbuild/cmake/data/preload.cmake82
-rw-r--r--mesonbuild/cmake/executor.py254
-rw-r--r--mesonbuild/cmake/fileapi.py321
-rw-r--r--mesonbuild/cmake/generator.py196
-rw-r--r--mesonbuild/cmake/interpreter.py1266
-rw-r--r--mesonbuild/cmake/toolchain.py258
-rw-r--r--mesonbuild/cmake/traceparser.py825
-rw-r--r--mesonbuild/cmake/tracetargets.py119
11 files changed, 3717 insertions, 0 deletions
diff --git a/mesonbuild/cmake/__init__.py b/mesonbuild/cmake/__init__.py
new file mode 100644
index 0000000..16c1322
--- /dev/null
+++ b/mesonbuild/cmake/__init__.py
@@ -0,0 +1,48 @@
+# 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.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+
+__all__ = [
+ 'CMakeExecutor',
+ 'CMakeExecScope',
+ 'CMakeException',
+ 'CMakeFileAPI',
+ 'CMakeInterpreter',
+ 'CMakeTarget',
+ 'CMakeToolchain',
+ 'CMakeTraceLine',
+ 'CMakeTraceParser',
+ 'SingleTargetOptions',
+ 'TargetOptions',
+ 'parse_generator_expressions',
+ 'language_map',
+ 'backend_generator_map',
+ 'cmake_get_generator_args',
+ 'cmake_defines_to_args',
+ 'check_cmake_args',
+ 'cmake_is_debug',
+ 'resolve_cmake_trace_targets',
+ 'ResolvedTarget',
+]
+
+from .common import CMakeException, SingleTargetOptions, TargetOptions, cmake_defines_to_args, language_map, backend_generator_map, cmake_get_generator_args, check_cmake_args, cmake_is_debug
+from .executor import CMakeExecutor
+from .fileapi import CMakeFileAPI
+from .generator import parse_generator_expressions
+from .interpreter import CMakeInterpreter
+from .toolchain import CMakeToolchain, CMakeExecScope
+from .traceparser import CMakeTarget, CMakeTraceLine, CMakeTraceParser
+from .tracetargets import resolve_cmake_trace_targets, ResolvedTarget
diff --git a/mesonbuild/cmake/common.py b/mesonbuild/cmake/common.py
new file mode 100644
index 0000000..accb7c9
--- /dev/null
+++ b/mesonbuild/cmake/common.py
@@ -0,0 +1,348 @@
+# 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.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+from __future__ import annotations
+
+from ..mesonlib import MesonException, OptionKey
+from .. import mlog
+from pathlib import Path
+import typing as T
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
+language_map = {
+ 'c': 'C',
+ 'cpp': 'CXX',
+ 'cuda': 'CUDA',
+ 'objc': 'OBJC',
+ 'objcpp': 'OBJCXX',
+ 'cs': 'CSharp',
+ 'java': 'Java',
+ 'fortran': 'Fortran',
+ 'swift': 'Swift',
+}
+
+backend_generator_map = {
+ 'ninja': 'Ninja',
+ 'xcode': 'Xcode',
+ 'vs2010': 'Visual Studio 10 2010',
+ 'vs2012': 'Visual Studio 11 2012',
+ 'vs2013': 'Visual Studio 12 2013',
+ 'vs2015': 'Visual Studio 14 2015',
+ 'vs2017': 'Visual Studio 15 2017',
+ 'vs2019': 'Visual Studio 16 2019',
+ 'vs2022': 'Visual Studio 17 2022',
+}
+
+blacklist_cmake_defs = [
+ 'CMAKE_TOOLCHAIN_FILE',
+ 'CMAKE_PROJECT_INCLUDE',
+ 'MESON_PRELOAD_FILE',
+ 'MESON_PS_CMAKE_CURRENT_BINARY_DIR',
+ 'MESON_PS_CMAKE_CURRENT_SOURCE_DIR',
+ 'MESON_PS_DELAYED_CALLS',
+ 'MESON_PS_LOADED',
+ 'MESON_FIND_ROOT_PATH',
+ 'MESON_CMAKE_SYSROOT',
+ 'MESON_PATHS_LIST',
+ 'MESON_CMAKE_ROOT',
+]
+
+def cmake_is_debug(env: 'Environment') -> bool:
+ if OptionKey('b_vscrt') in env.coredata.options:
+ is_debug = env.coredata.get_option(OptionKey('buildtype')) == 'debug'
+ if env.coredata.options[OptionKey('b_vscrt')].value in {'mdd', 'mtd'}:
+ is_debug = True
+ return is_debug
+ else:
+ # Don't directly assign to is_debug to make mypy happy
+ debug_opt = env.coredata.get_option(OptionKey('debug'))
+ assert isinstance(debug_opt, bool)
+ return debug_opt
+
+class CMakeException(MesonException):
+ pass
+
+class CMakeBuildFile:
+ def __init__(self, file: Path, is_cmake: bool, is_temp: bool) -> None:
+ self.file = file
+ self.is_cmake = is_cmake
+ self.is_temp = is_temp
+
+ def __repr__(self) -> str:
+ return f'<{self.__class__.__name__}: {self.file}; cmake={self.is_cmake}; temp={self.is_temp}>'
+
+def _flags_to_list(raw: str) -> T.List[str]:
+ # Convert a raw commandline string into a list of strings
+ res = []
+ curr = ''
+ escape = False
+ in_string = False
+ for i in raw:
+ if escape:
+ # If the current char is not a quote, the '\' is probably important
+ if i not in ['"', "'"]:
+ curr += '\\'
+ curr += i
+ escape = False
+ elif i == '\\':
+ escape = True
+ elif i in {'"', "'"}:
+ in_string = not in_string
+ elif i in {' ', '\n'}:
+ if in_string:
+ curr += i
+ else:
+ res += [curr]
+ curr = ''
+ else:
+ curr += i
+ res += [curr]
+ res = [r for r in res if len(r) > 0]
+ return res
+
+def cmake_get_generator_args(env: 'Environment') -> T.List[str]:
+ backend_name = env.coredata.get_option(OptionKey('backend'))
+ assert isinstance(backend_name, str)
+ assert backend_name in backend_generator_map
+ return ['-G', backend_generator_map[backend_name]]
+
+def cmake_defines_to_args(raw: T.Any, permissive: bool = False) -> T.List[str]:
+ res = [] # type: T.List[str]
+ if not isinstance(raw, list):
+ raw = [raw]
+
+ for i in raw:
+ if not isinstance(i, dict):
+ raise MesonException('Invalid CMake defines. Expected a dict, but got a {}'.format(type(i).__name__))
+ for key, val in i.items():
+ assert isinstance(key, str)
+ if key in blacklist_cmake_defs:
+ mlog.warning('Setting', mlog.bold(key), 'is not supported. See the meson docs for cross compilation support:')
+ mlog.warning(' - URL: https://mesonbuild.com/CMake-module.html#cross-compilation')
+ mlog.warning(' --> Ignoring this option')
+ continue
+ if isinstance(val, (str, int, float)):
+ res += [f'-D{key}={val}']
+ elif isinstance(val, bool):
+ val_str = 'ON' if val else 'OFF'
+ res += [f'-D{key}={val_str}']
+ else:
+ raise MesonException('Type "{}" of "{}" is not supported as for a CMake define value'.format(type(val).__name__, key))
+
+ return res
+
+# TODO: this functuin will become obsolete once the `cmake_args` kwarg is dropped
+def check_cmake_args(args: T.List[str]) -> T.List[str]:
+ res = [] # type: T.List[str]
+ dis = ['-D' + x for x in blacklist_cmake_defs]
+ assert dis # Ensure that dis is not empty.
+ for i in args:
+ if any(i.startswith(x) for x in dis):
+ mlog.warning('Setting', mlog.bold(i), 'is not supported. See the meson docs for cross compilation support:')
+ mlog.warning(' - URL: https://mesonbuild.com/CMake-module.html#cross-compilation')
+ mlog.warning(' --> Ignoring this option')
+ continue
+ res += [i]
+ return res
+
+class CMakeInclude:
+ def __init__(self, path: Path, isSystem: bool = False):
+ self.path = path
+ self.isSystem = isSystem
+
+ def __repr__(self) -> str:
+ return f'<CMakeInclude: {self.path} -- isSystem = {self.isSystem}>'
+
+class CMakeFileGroup:
+ def __init__(self, data: T.Dict[str, T.Any]) -> None:
+ self.defines = data.get('defines', '') # type: str
+ self.flags = _flags_to_list(data.get('compileFlags', '')) # type: T.List[str]
+ self.is_generated = data.get('isGenerated', False) # type: bool
+ self.language = data.get('language', 'C') # type: str
+ self.sources = [Path(x) for x in data.get('sources', [])] # type: T.List[Path]
+
+ # Fix the include directories
+ self.includes = [] # type: T.List[CMakeInclude]
+ for i in data.get('includePath', []):
+ if isinstance(i, dict) and 'path' in i:
+ isSystem = i.get('isSystem', False)
+ assert isinstance(isSystem, bool)
+ assert isinstance(i['path'], str)
+ self.includes += [CMakeInclude(Path(i['path']), isSystem)]
+ elif isinstance(i, str):
+ self.includes += [CMakeInclude(Path(i))]
+
+ def log(self) -> None:
+ mlog.log('flags =', mlog.bold(', '.join(self.flags)))
+ mlog.log('defines =', mlog.bold(', '.join(self.defines)))
+ mlog.log('includes =', mlog.bold(', '.join([str(x) for x in self.includes])))
+ mlog.log('is_generated =', mlog.bold('true' if self.is_generated else 'false'))
+ mlog.log('language =', mlog.bold(self.language))
+ mlog.log('sources:')
+ for i in self.sources:
+ with mlog.nested():
+ mlog.log(i.as_posix())
+
+class CMakeTarget:
+ def __init__(self, data: T.Dict[str, T.Any]) -> None:
+ self.artifacts = [Path(x) for x in data.get('artifacts', [])] # type: T.List[Path]
+ self.src_dir = Path(data.get('sourceDirectory', '')) # type: Path
+ self.build_dir = Path(data.get('buildDirectory', '')) # type: Path
+ self.name = data.get('name', '') # type: str
+ self.full_name = data.get('fullName', '') # type: str
+ self.install = data.get('hasInstallRule', False) # type: bool
+ self.install_paths = [Path(x) for x in set(data.get('installPaths', []))] # type: T.List[Path]
+ self.link_lang = data.get('linkerLanguage', '') # type: str
+ self.link_libraries = _flags_to_list(data.get('linkLibraries', '')) # type: T.List[str]
+ self.link_flags = _flags_to_list(data.get('linkFlags', '')) # type: T.List[str]
+ self.link_lang_flags = _flags_to_list(data.get('linkLanguageFlags', '')) # type: T.List[str]
+ # self.link_path = Path(data.get('linkPath', '')) # type: Path
+ self.type = data.get('type', 'EXECUTABLE') # type: str
+ # self.is_generator_provided = data.get('isGeneratorProvided', False) # type: bool
+ self.files = [] # type: T.List[CMakeFileGroup]
+
+ for i in data.get('fileGroups', []):
+ self.files += [CMakeFileGroup(i)]
+
+ def log(self) -> None:
+ mlog.log('artifacts =', mlog.bold(', '.join([x.as_posix() for x in self.artifacts])))
+ mlog.log('src_dir =', mlog.bold(self.src_dir.as_posix()))
+ mlog.log('build_dir =', mlog.bold(self.build_dir.as_posix()))
+ mlog.log('name =', mlog.bold(self.name))
+ mlog.log('full_name =', mlog.bold(self.full_name))
+ mlog.log('install =', mlog.bold('true' if self.install else 'false'))
+ mlog.log('install_paths =', mlog.bold(', '.join([x.as_posix() for x in self.install_paths])))
+ mlog.log('link_lang =', mlog.bold(self.link_lang))
+ mlog.log('link_libraries =', mlog.bold(', '.join(self.link_libraries)))
+ mlog.log('link_flags =', mlog.bold(', '.join(self.link_flags)))
+ mlog.log('link_lang_flags =', mlog.bold(', '.join(self.link_lang_flags)))
+ # mlog.log('link_path =', mlog.bold(self.link_path))
+ mlog.log('type =', mlog.bold(self.type))
+ # mlog.log('is_generator_provided =', mlog.bold('true' if self.is_generator_provided else 'false'))
+ for idx, i in enumerate(self.files):
+ mlog.log(f'Files {idx}:')
+ with mlog.nested():
+ i.log()
+
+class CMakeProject:
+ def __init__(self, data: T.Dict[str, T.Any]) -> None:
+ self.src_dir = Path(data.get('sourceDirectory', '')) # type: Path
+ self.build_dir = Path(data.get('buildDirectory', '')) # type: Path
+ self.name = data.get('name', '') # type: str
+ self.targets = [] # type: T.List[CMakeTarget]
+
+ for i in data.get('targets', []):
+ self.targets += [CMakeTarget(i)]
+
+ def log(self) -> None:
+ mlog.log('src_dir =', mlog.bold(self.src_dir.as_posix()))
+ mlog.log('build_dir =', mlog.bold(self.build_dir.as_posix()))
+ mlog.log('name =', mlog.bold(self.name))
+ for idx, i in enumerate(self.targets):
+ mlog.log(f'Target {idx}:')
+ with mlog.nested():
+ i.log()
+
+class CMakeConfiguration:
+ def __init__(self, data: T.Dict[str, T.Any]) -> None:
+ self.name = data.get('name', '') # type: str
+ self.projects = [] # type: T.List[CMakeProject]
+ for i in data.get('projects', []):
+ self.projects += [CMakeProject(i)]
+
+ def log(self) -> None:
+ mlog.log('name =', mlog.bold(self.name))
+ for idx, i in enumerate(self.projects):
+ mlog.log(f'Project {idx}:')
+ with mlog.nested():
+ i.log()
+
+class SingleTargetOptions:
+ def __init__(self) -> None:
+ self.opts = {} # type: T.Dict[str, str]
+ self.lang_args = {} # type: T.Dict[str, T.List[str]]
+ self.link_args = [] # type: T.List[str]
+ self.install = 'preserve'
+
+ def set_opt(self, opt: str, val: str) -> None:
+ self.opts[opt] = val
+
+ def append_args(self, lang: str, args: T.List[str]) -> None:
+ if lang not in self.lang_args:
+ self.lang_args[lang] = []
+ self.lang_args[lang] += args
+
+ def append_link_args(self, args: T.List[str]) -> None:
+ self.link_args += args
+
+ def set_install(self, install: bool) -> None:
+ self.install = 'true' if install else 'false'
+
+ def get_override_options(self, initial: T.List[str]) -> T.List[str]:
+ res = [] # type: T.List[str]
+ for i in initial:
+ opt = i[:i.find('=')]
+ if opt not in self.opts:
+ res += [i]
+ res += [f'{k}={v}' for k, v in self.opts.items()]
+ return res
+
+ def get_compile_args(self, lang: str, initial: T.List[str]) -> T.List[str]:
+ if lang in self.lang_args:
+ return initial + self.lang_args[lang]
+ return initial
+
+ def get_link_args(self, initial: T.List[str]) -> T.List[str]:
+ return initial + self.link_args
+
+ def get_install(self, initial: bool) -> bool:
+ return {'preserve': initial, 'true': True, 'false': False}[self.install]
+
+class TargetOptions:
+ def __init__(self) -> None:
+ self.global_options = SingleTargetOptions()
+ self.target_options = {} # type: T.Dict[str, SingleTargetOptions]
+
+ def __getitem__(self, tgt: str) -> SingleTargetOptions:
+ if tgt not in self.target_options:
+ self.target_options[tgt] = SingleTargetOptions()
+ return self.target_options[tgt]
+
+ def get_override_options(self, tgt: str, initial: T.List[str]) -> T.List[str]:
+ initial = self.global_options.get_override_options(initial)
+ if tgt in self.target_options:
+ initial = self.target_options[tgt].get_override_options(initial)
+ return initial
+
+ def get_compile_args(self, tgt: str, lang: str, initial: T.List[str]) -> T.List[str]:
+ initial = self.global_options.get_compile_args(lang, initial)
+ if tgt in self.target_options:
+ initial = self.target_options[tgt].get_compile_args(lang, initial)
+ return initial
+
+ def get_link_args(self, tgt: str, initial: T.List[str]) -> T.List[str]:
+ initial = self.global_options.get_link_args(initial)
+ if tgt in self.target_options:
+ initial = self.target_options[tgt].get_link_args(initial)
+ return initial
+
+ def get_install(self, tgt: str, initial: bool) -> bool:
+ initial = self.global_options.get_install(initial)
+ if tgt in self.target_options:
+ initial = self.target_options[tgt].get_install(initial)
+ return initial
diff --git a/mesonbuild/cmake/data/__init__.py b/mesonbuild/cmake/data/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/mesonbuild/cmake/data/__init__.py
diff --git a/mesonbuild/cmake/data/preload.cmake b/mesonbuild/cmake/data/preload.cmake
new file mode 100644
index 0000000..234860b
--- /dev/null
+++ b/mesonbuild/cmake/data/preload.cmake
@@ -0,0 +1,82 @@
+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)
diff --git a/mesonbuild/cmake/executor.py b/mesonbuild/cmake/executor.py
new file mode 100644
index 0000000..c22c0ca
--- /dev/null
+++ b/mesonbuild/cmake/executor.py
@@ -0,0 +1,254 @@
+# 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.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+from __future__ import annotations
+
+import subprocess as S
+from threading import Thread
+import typing as T
+import re
+import os
+
+from .. import mlog
+from ..mesonlib import PerMachine, Popen_safe, version_compare, is_windows, OptionKey
+from ..programs import find_external_program, NonExistingExternalProgram
+
+if T.TYPE_CHECKING:
+ from pathlib import Path
+
+ from ..environment import Environment
+ from ..mesonlib import MachineChoice
+ from ..programs import ExternalProgram
+
+ TYPE_result = T.Tuple[int, T.Optional[str], T.Optional[str]]
+ TYPE_cache_key = T.Tuple[str, T.Tuple[str, ...], str, T.FrozenSet[T.Tuple[str, str]]]
+
+class CMakeExecutor:
+ # The class's copy of the CMake path. Avoids having to search for it
+ # multiple times in the same Meson invocation.
+ class_cmakebin = PerMachine(None, None) # type: PerMachine[T.Optional[ExternalProgram]]
+ class_cmakevers = PerMachine(None, None) # type: PerMachine[T.Optional[str]]
+ class_cmake_cache = {} # type: T.Dict[T.Any, TYPE_result]
+
+ def __init__(self, environment: 'Environment', version: str, for_machine: MachineChoice, silent: bool = False):
+ self.min_version = version
+ self.environment = environment
+ self.for_machine = for_machine
+ self.cmakebin, self.cmakevers = self.find_cmake_binary(self.environment, silent=silent)
+ self.always_capture_stderr = True
+ self.print_cmout = False
+ self.prefix_paths = [] # type: T.List[str]
+ self.extra_cmake_args = [] # type: T.List[str]
+
+ if self.cmakebin is None:
+ return
+
+ if not version_compare(self.cmakevers, self.min_version):
+ mlog.warning(
+ 'The version of CMake', mlog.bold(self.cmakebin.get_path()),
+ 'is', mlog.bold(self.cmakevers), 'but version', mlog.bold(self.min_version),
+ 'is required')
+ self.cmakebin = None
+ return
+
+ self.prefix_paths = self.environment.coredata.options[OptionKey('cmake_prefix_path', machine=self.for_machine)].value
+ if self.prefix_paths:
+ self.extra_cmake_args += ['-DCMAKE_PREFIX_PATH={}'.format(';'.join(self.prefix_paths))]
+
+ def find_cmake_binary(self, environment: 'Environment', silent: bool = False) -> T.Tuple[T.Optional['ExternalProgram'], T.Optional[str]]:
+ # Only search for CMake the first time and store the result in the class
+ # definition
+ if isinstance(CMakeExecutor.class_cmakebin[self.for_machine], NonExistingExternalProgram):
+ mlog.debug(f'CMake binary for {self.for_machine} is cached as not found')
+ return None, None
+ elif CMakeExecutor.class_cmakebin[self.for_machine] is not None:
+ mlog.debug(f'CMake binary for {self.for_machine} is cached.')
+ else:
+ assert CMakeExecutor.class_cmakebin[self.for_machine] is None
+
+ mlog.debug(f'CMake binary for {self.for_machine} is not cached')
+ for potential_cmakebin in find_external_program(
+ environment, self.for_machine, 'cmake', 'CMake',
+ environment.default_cmake, allow_default_for_cross=False):
+ version_if_ok = self.check_cmake(potential_cmakebin)
+ if not version_if_ok:
+ continue
+ if not silent:
+ mlog.log('Found CMake:', mlog.bold(potential_cmakebin.get_path()),
+ f'({version_if_ok})')
+ CMakeExecutor.class_cmakebin[self.for_machine] = potential_cmakebin
+ CMakeExecutor.class_cmakevers[self.for_machine] = version_if_ok
+ break
+ else:
+ if not silent:
+ mlog.log('Found CMake:', mlog.red('NO'))
+ # Set to False instead of None to signify that we've already
+ # searched for it and not found it
+ CMakeExecutor.class_cmakebin[self.for_machine] = NonExistingExternalProgram()
+ CMakeExecutor.class_cmakevers[self.for_machine] = None
+ return None, None
+
+ return CMakeExecutor.class_cmakebin[self.for_machine], CMakeExecutor.class_cmakevers[self.for_machine]
+
+ def check_cmake(self, cmakebin: 'ExternalProgram') -> T.Optional[str]:
+ if not cmakebin.found():
+ mlog.log(f'Did not find CMake {cmakebin.name!r}')
+ return None
+ try:
+ cmd = cmakebin.get_command()
+ p, out = Popen_safe(cmd + ['--version'])[0:2]
+ if p.returncode != 0:
+ mlog.warning('Found CMake {!r} but couldn\'t run it'
+ ''.format(' '.join(cmd)))
+ return None
+ except FileNotFoundError:
+ mlog.warning('We thought we found CMake {!r} but now it\'s not there. How odd!'
+ ''.format(' '.join(cmd)))
+ return None
+ except PermissionError:
+ msg = 'Found CMake {!r} but didn\'t have permissions to run it.'.format(' '.join(cmd))
+ if not is_windows():
+ msg += '\n\nOn Unix-like systems this is often caused by scripts that are not executable.'
+ mlog.warning(msg)
+ return None
+
+ cmvers = re.search(r'(cmake|cmake3)\s*version\s*([\d.]+)', out)
+ if cmvers is not None:
+ return cmvers.group(2)
+ mlog.warning(f'We thought we found CMake {cmd!r}, but it was missing the expected '
+ 'version string in its output.')
+ return None
+
+ def set_exec_mode(self, print_cmout: T.Optional[bool] = None, always_capture_stderr: T.Optional[bool] = None) -> None:
+ if print_cmout is not None:
+ self.print_cmout = print_cmout
+ if always_capture_stderr is not None:
+ self.always_capture_stderr = always_capture_stderr
+
+ def _cache_key(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_cache_key:
+ fenv = frozenset(env.items()) if env is not None else frozenset()
+ targs = tuple(args)
+ return (self.cmakebin.get_path(), targs, build_dir.as_posix(), fenv)
+
+ def _call_cmout_stderr(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+ cmd = self.cmakebin.get_command() + args
+ proc = S.Popen(cmd, stdout=S.PIPE, stderr=S.PIPE, cwd=str(build_dir), env=env) # TODO [PYTHON_37]: drop Path conversion
+
+ # stdout and stderr MUST be read at the same time to avoid pipe
+ # blocking issues. The easiest way to do this is with a separate
+ # thread for one of the pipes.
+ def print_stdout() -> None:
+ while True:
+ line = proc.stdout.readline()
+ if not line:
+ break
+ mlog.log(line.decode(errors='ignore').strip('\n'))
+ proc.stdout.close()
+
+ t = Thread(target=print_stdout)
+ t.start()
+
+ try:
+ # Read stderr line by line and log non trace lines
+ raw_trace = ''
+ tline_start_reg = re.compile(r'^\s*(.*\.(cmake|txt))\(([0-9]+)\):\s*(\w+)\(.*$')
+ inside_multiline_trace = False
+ while True:
+ line_raw = proc.stderr.readline()
+ if not line_raw:
+ break
+ line = line_raw.decode(errors='ignore')
+ if tline_start_reg.match(line):
+ raw_trace += line
+ inside_multiline_trace = not line.endswith(' )\n')
+ elif inside_multiline_trace:
+ raw_trace += line
+ else:
+ mlog.warning(line.strip('\n'))
+
+ finally:
+ proc.stderr.close()
+ t.join()
+ proc.wait()
+
+ return proc.returncode, None, raw_trace
+
+ def _call_cmout(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+ cmd = self.cmakebin.get_command() + args
+ proc = S.Popen(cmd, stdout=S.PIPE, stderr=S.STDOUT, cwd=str(build_dir), env=env) # TODO [PYTHON_37]: drop Path conversion
+ while True:
+ line = proc.stdout.readline()
+ if not line:
+ break
+ mlog.log(line.decode(errors='ignore').strip('\n'))
+ proc.stdout.close()
+ proc.wait()
+ return proc.returncode, None, None
+
+ def _call_quiet(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+ build_dir.mkdir(parents=True, exist_ok=True)
+ cmd = self.cmakebin.get_command() + args
+ ret = S.run(cmd, env=env, cwd=str(build_dir), close_fds=False,
+ stdout=S.PIPE, stderr=S.PIPE, universal_newlines=False) # TODO [PYTHON_37]: drop Path conversion
+ rc = ret.returncode
+ out = ret.stdout.decode(errors='ignore')
+ err = ret.stderr.decode(errors='ignore')
+ return rc, out, err
+
+ def _call_impl(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]]) -> TYPE_result:
+ mlog.debug(f'Calling CMake ({self.cmakebin.get_command()}) in {build_dir} with:')
+ for i in args:
+ mlog.debug(f' - "{i}"')
+ if not self.print_cmout:
+ return self._call_quiet(args, build_dir, env)
+ else:
+ if self.always_capture_stderr:
+ return self._call_cmout_stderr(args, build_dir, env)
+ else:
+ return self._call_cmout(args, build_dir, env)
+
+ def call(self, args: T.List[str], build_dir: Path, env: T.Optional[T.Dict[str, str]] = None, disable_cache: bool = False) -> TYPE_result:
+ if env is None:
+ env = os.environ.copy()
+
+ args = args + self.extra_cmake_args
+ if disable_cache:
+ return self._call_impl(args, build_dir, env)
+
+ # First check if cached, if not call the real cmake function
+ cache = CMakeExecutor.class_cmake_cache
+ key = self._cache_key(args, build_dir, env)
+ if key not in cache:
+ cache[key] = self._call_impl(args, build_dir, env)
+ return cache[key]
+
+ def found(self) -> bool:
+ return self.cmakebin is not None
+
+ def version(self) -> str:
+ return self.cmakevers
+
+ def executable_path(self) -> str:
+ return self.cmakebin.get_path()
+
+ def get_command(self) -> T.List[str]:
+ return self.cmakebin.get_command()
+
+ def get_cmake_prefix_paths(self) -> T.List[str]:
+ return self.prefix_paths
+
+ def machine_choice(self) -> MachineChoice:
+ return self.for_machine
diff --git a/mesonbuild/cmake/fileapi.py b/mesonbuild/cmake/fileapi.py
new file mode 100644
index 0000000..9605f92
--- /dev/null
+++ b/mesonbuild/cmake/fileapi.py
@@ -0,0 +1,321 @@
+# 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.
+from __future__ import annotations
+
+from .common import CMakeException, CMakeBuildFile, CMakeConfiguration
+import typing as T
+from .. import mlog
+from pathlib import Path
+import json
+import re
+
+STRIP_KEYS = ['cmake', 'reply', 'backtrace', 'backtraceGraph', 'version']
+
+class CMakeFileAPI:
+ def __init__(self, build_dir: Path):
+ self.build_dir = build_dir
+ self.api_base_dir = self.build_dir / '.cmake' / 'api' / 'v1'
+ self.request_dir = self.api_base_dir / 'query' / 'client-meson'
+ self.reply_dir = self.api_base_dir / 'reply'
+ self.cmake_sources = [] # type: T.List[CMakeBuildFile]
+ self.cmake_configurations = [] # type: T.List[CMakeConfiguration]
+ self.kind_resolver_map = {
+ 'codemodel': self._parse_codemodel,
+ 'cmakeFiles': self._parse_cmakeFiles,
+ }
+
+ def get_cmake_sources(self) -> T.List[CMakeBuildFile]:
+ return self.cmake_sources
+
+ def get_cmake_configurations(self) -> T.List[CMakeConfiguration]:
+ return self.cmake_configurations
+
+ def setup_request(self) -> None:
+ self.request_dir.mkdir(parents=True, exist_ok=True)
+
+ query = {
+ 'requests': [
+ {'kind': 'codemodel', 'version': {'major': 2, 'minor': 0}},
+ {'kind': 'cmakeFiles', 'version': {'major': 1, 'minor': 0}},
+ ]
+ }
+
+ query_file = self.request_dir / 'query.json'
+ query_file.write_text(json.dumps(query, indent=2), encoding='utf-8')
+
+ def load_reply(self) -> None:
+ if not self.reply_dir.is_dir():
+ raise CMakeException('No response from the CMake file API')
+
+ root = None
+ reg_index = re.compile(r'^index-.*\.json$')
+ for i in self.reply_dir.iterdir():
+ if reg_index.match(i.name):
+ root = i
+ break
+
+ if not root:
+ raise CMakeException('Failed to find the CMake file API index')
+
+ index = self._reply_file_content(root) # Load the root index
+ index = self._strip_data(index) # Avoid loading duplicate files
+ index = self._resolve_references(index) # Load everything
+ index = self._strip_data(index) # Strip unused data (again for loaded files)
+
+ # Debug output
+ debug_json = self.build_dir / '..' / 'fileAPI.json'
+ debug_json = debug_json.resolve()
+ debug_json.write_text(json.dumps(index, indent=2), encoding='utf-8')
+ mlog.cmd_ci_include(debug_json.as_posix())
+
+ # parse the JSON
+ for i in index['objects']:
+ assert isinstance(i, dict)
+ assert 'kind' in i
+ assert i['kind'] in self.kind_resolver_map
+
+ self.kind_resolver_map[i['kind']](i)
+
+ def _parse_codemodel(self, data: T.Dict[str, T.Any]) -> None:
+ assert 'configurations' in data
+ assert 'paths' in data
+
+ source_dir = data['paths']['source']
+ build_dir = data['paths']['build']
+
+ # The file API output differs quite a bit from the server
+ # output. It is more flat than the server output and makes
+ # heavy use of references. Here these references are
+ # resolved and the resulting data structure is identical
+ # to the CMake serve output.
+
+ def helper_parse_dir(dir_entry: T.Dict[str, T.Any]) -> T.Tuple[Path, Path]:
+ src_dir = Path(dir_entry.get('source', '.'))
+ bld_dir = Path(dir_entry.get('build', '.'))
+ src_dir = src_dir if src_dir.is_absolute() else source_dir / src_dir
+ bld_dir = bld_dir if bld_dir.is_absolute() else build_dir / bld_dir
+ src_dir = src_dir.resolve()
+ bld_dir = bld_dir.resolve()
+
+ return src_dir, bld_dir
+
+ def parse_sources(comp_group: T.Dict[str, T.Any], tgt: T.Dict[str, T.Any]) -> T.Tuple[T.List[Path], T.List[Path], T.List[int]]:
+ gen = []
+ src = []
+ idx = []
+
+ src_list_raw = tgt.get('sources', [])
+ for i in comp_group.get('sourceIndexes', []):
+ if i >= len(src_list_raw) or 'path' not in src_list_raw[i]:
+ continue
+ if src_list_raw[i].get('isGenerated', False):
+ gen += [Path(src_list_raw[i]['path'])]
+ else:
+ src += [Path(src_list_raw[i]['path'])]
+ idx += [i]
+
+ return src, gen, idx
+
+ def parse_target(tgt: T.Dict[str, T.Any]) -> T.Dict[str, T.Any]:
+ src_dir, bld_dir = helper_parse_dir(cnf.get('paths', {}))
+
+ # Parse install paths (if present)
+ install_paths = []
+ if 'install' in tgt:
+ prefix = Path(tgt['install']['prefix']['path'])
+ install_paths = [prefix / x['path'] for x in tgt['install']['destinations']]
+ install_paths = list(set(install_paths))
+
+ # On the first look, it looks really nice that the CMake devs have
+ # decided to use arrays for the linker flags. However, this feeling
+ # soon turns into despair when you realize that there only one entry
+ # per type in most cases, and we still have to do manual string splitting.
+ link_flags = []
+ link_libs = []
+ for i in tgt.get('link', {}).get('commandFragments', []):
+ if i['role'] == 'flags':
+ link_flags += [i['fragment']]
+ elif i['role'] == 'libraries':
+ link_libs += [i['fragment']]
+ elif i['role'] == 'libraryPath':
+ link_flags += ['-L{}'.format(i['fragment'])]
+ elif i['role'] == 'frameworkPath':
+ link_flags += ['-F{}'.format(i['fragment'])]
+ for i in tgt.get('archive', {}).get('commandFragments', []):
+ if i['role'] == 'flags':
+ link_flags += [i['fragment']]
+
+ # TODO The `dependencies` entry is new in the file API.
+ # maybe we can make use of that in addition to the
+ # implicit dependency detection
+ tgt_data = {
+ 'artifacts': [Path(x.get('path', '')) for x in tgt.get('artifacts', [])],
+ 'sourceDirectory': src_dir,
+ 'buildDirectory': bld_dir,
+ 'name': tgt.get('name', ''),
+ 'fullName': tgt.get('nameOnDisk', ''),
+ 'hasInstallRule': 'install' in tgt,
+ 'installPaths': install_paths,
+ 'linkerLanguage': tgt.get('link', {}).get('language', 'CXX'),
+ 'linkLibraries': ' '.join(link_libs), # See previous comment block why we join the array
+ 'linkFlags': ' '.join(link_flags), # See previous comment block why we join the array
+ 'type': tgt.get('type', 'EXECUTABLE'),
+ 'fileGroups': [],
+ }
+
+ processed_src_idx = []
+ for cg in tgt.get('compileGroups', []):
+ # Again, why an array, when there is usually only one element
+ # and arguments are separated with spaces...
+ flags = []
+ for i in cg.get('compileCommandFragments', []):
+ flags += [i['fragment']]
+
+ cg_data = {
+ 'defines': [x.get('define', '') for x in cg.get('defines', [])],
+ 'compileFlags': ' '.join(flags),
+ 'language': cg.get('language', 'C'),
+ 'isGenerated': None, # Set later, flag is stored per source file
+ 'sources': [],
+ 'includePath': cg.get('includes', []),
+ }
+
+ normal_src, generated_src, src_idx = parse_sources(cg, tgt)
+ if normal_src:
+ cg_data = dict(cg_data)
+ cg_data['isGenerated'] = False
+ cg_data['sources'] = normal_src
+ tgt_data['fileGroups'] += [cg_data]
+ if generated_src:
+ cg_data = dict(cg_data)
+ cg_data['isGenerated'] = True
+ cg_data['sources'] = generated_src
+ tgt_data['fileGroups'] += [cg_data]
+ processed_src_idx += src_idx
+
+ # Object libraries have no compile groups, only source groups.
+ # So we add all the source files to a dummy source group that were
+ # not found in the previous loop
+ normal_src = []
+ generated_src = []
+ for idx, src in enumerate(tgt.get('sources', [])):
+ if idx in processed_src_idx:
+ continue
+
+ if src.get('isGenerated', False):
+ generated_src += [src['path']]
+ else:
+ normal_src += [src['path']]
+
+ if normal_src:
+ tgt_data['fileGroups'] += [{
+ 'isGenerated': False,
+ 'sources': normal_src,
+ }]
+ if generated_src:
+ tgt_data['fileGroups'] += [{
+ 'isGenerated': True,
+ 'sources': generated_src,
+ }]
+ return tgt_data
+
+ def parse_project(pro: T.Dict[str, T.Any]) -> T.Dict[str, T.Any]:
+ # Only look at the first directory specified in directoryIndexes
+ # TODO Figure out what the other indexes are there for
+ p_src_dir = source_dir
+ p_bld_dir = build_dir
+ try:
+ p_src_dir, p_bld_dir = helper_parse_dir(cnf['directories'][pro['directoryIndexes'][0]])
+ except (IndexError, KeyError):
+ pass
+
+ pro_data = {
+ 'name': pro.get('name', ''),
+ 'sourceDirectory': p_src_dir,
+ 'buildDirectory': p_bld_dir,
+ 'targets': [],
+ }
+
+ for ref in pro.get('targetIndexes', []):
+ tgt = {}
+ try:
+ tgt = cnf['targets'][ref]
+ except (IndexError, KeyError):
+ pass
+ pro_data['targets'] += [parse_target(tgt)]
+
+ return pro_data
+
+ for cnf in data.get('configurations', []):
+ cnf_data = {
+ 'name': cnf.get('name', ''),
+ 'projects': [],
+ }
+
+ for pro in cnf.get('projects', []):
+ cnf_data['projects'] += [parse_project(pro)]
+
+ self.cmake_configurations += [CMakeConfiguration(cnf_data)]
+
+ def _parse_cmakeFiles(self, data: T.Dict[str, T.Any]) -> None:
+ assert 'inputs' in data
+ assert 'paths' in data
+
+ src_dir = Path(data['paths']['source'])
+
+ for i in data['inputs']:
+ path = Path(i['path'])
+ path = path if path.is_absolute() else src_dir / path
+ self.cmake_sources += [CMakeBuildFile(path, i.get('isCMake', False), i.get('isGenerated', False))]
+
+ def _strip_data(self, data: T.Any) -> T.Any:
+ if isinstance(data, list):
+ for idx, i in enumerate(data):
+ data[idx] = self._strip_data(i)
+
+ elif isinstance(data, dict):
+ new = {}
+ for key, val in data.items():
+ if key not in STRIP_KEYS:
+ new[key] = self._strip_data(val)
+ data = new
+
+ return data
+
+ def _resolve_references(self, data: T.Any) -> T.Any:
+ if isinstance(data, list):
+ for idx, i in enumerate(data):
+ data[idx] = self._resolve_references(i)
+
+ elif isinstance(data, dict):
+ # Check for the "magic" reference entry and insert
+ # it into the root data dict
+ if 'jsonFile' in data:
+ data.update(self._reply_file_content(data['jsonFile']))
+
+ for key, val in data.items():
+ data[key] = self._resolve_references(val)
+
+ return data
+
+ def _reply_file_content(self, filename: Path) -> T.Dict[str, T.Any]:
+ real_path = self.reply_dir / filename
+ if not real_path.exists():
+ raise CMakeException(f'File "{real_path}" does not exist')
+
+ data = json.loads(real_path.read_text(encoding='utf-8'))
+ assert isinstance(data, dict)
+ for i in data.keys():
+ assert isinstance(i, str)
+ return data
diff --git a/mesonbuild/cmake/generator.py b/mesonbuild/cmake/generator.py
new file mode 100644
index 0000000..7903dd4
--- /dev/null
+++ b/mesonbuild/cmake/generator.py
@@ -0,0 +1,196 @@
+# 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.
+from __future__ import annotations
+
+from .. import mesonlib
+from .. import mlog
+from .common import cmake_is_debug
+import typing as T
+
+if T.TYPE_CHECKING:
+ from .traceparser import CMakeTraceParser, CMakeTarget
+
+def parse_generator_expressions(
+ raw: str,
+ trace: 'CMakeTraceParser',
+ *,
+ context_tgt: T.Optional['CMakeTarget'] = None,
+ ) -> str:
+ '''Parse CMake generator expressions
+
+ Most generator expressions are simply ignored for
+ simplicety, however some are required for some common
+ use cases.
+ '''
+
+ # Early abort if no generator expression present
+ if '$<' not in raw:
+ return raw
+
+ out = '' # type: str
+ i = 0 # type: int
+
+ def equal(arg: str) -> str:
+ col_pos = arg.find(',')
+ if col_pos < 0:
+ return '0'
+ else:
+ return '1' if arg[:col_pos] == arg[col_pos + 1:] else '0'
+
+ def vers_comp(op: str, arg: str) -> str:
+ col_pos = arg.find(',')
+ if col_pos < 0:
+ return '0'
+ else:
+ return '1' if mesonlib.version_compare(arg[:col_pos], '{}{}'.format(op, arg[col_pos + 1:])) else '0'
+
+ def target_property(arg: str) -> str:
+ # We can't really support this since we don't have any context
+ if ',' not in arg:
+ if context_tgt is None:
+ return ''
+ return ';'.join(context_tgt.properties.get(arg, []))
+
+ args = arg.split(',')
+ props = trace.targets[args[0]].properties.get(args[1], []) if args[0] in trace.targets else []
+ return ';'.join(props)
+
+ def target_file(arg: str) -> str:
+ if arg not in trace.targets:
+ mlog.warning(f"Unable to evaluate the cmake variable '$<TARGET_FILE:{arg}>'.")
+ return ''
+ tgt = trace.targets[arg]
+
+ cfgs = []
+ cfg = ''
+
+ if 'IMPORTED_CONFIGURATIONS' in tgt.properties:
+ cfgs = [x for x in tgt.properties['IMPORTED_CONFIGURATIONS'] if x]
+ cfg = cfgs[0]
+
+ if cmake_is_debug(trace.env):
+ if 'DEBUG' in cfgs:
+ cfg = 'DEBUG'
+ elif 'RELEASE' in cfgs:
+ cfg = 'RELEASE'
+ else:
+ if 'RELEASE' in cfgs:
+ cfg = 'RELEASE'
+
+ if f'IMPORTED_IMPLIB_{cfg}' in tgt.properties:
+ return ';'.join([x for x in tgt.properties[f'IMPORTED_IMPLIB_{cfg}'] if x])
+ elif 'IMPORTED_IMPLIB' in tgt.properties:
+ return ';'.join([x for x in tgt.properties['IMPORTED_IMPLIB'] if x])
+ elif f'IMPORTED_LOCATION_{cfg}' in tgt.properties:
+ return ';'.join([x for x in tgt.properties[f'IMPORTED_LOCATION_{cfg}'] if x])
+ elif 'IMPORTED_LOCATION' in tgt.properties:
+ return ';'.join([x for x in tgt.properties['IMPORTED_LOCATION'] if x])
+ return ''
+
+ supported = {
+ # Boolean functions
+ 'BOOL': lambda x: '0' if x.upper() in {'0', 'FALSE', 'OFF', 'N', 'NO', 'IGNORE', 'NOTFOUND'} or x.endswith('-NOTFOUND') else '1',
+ 'AND': lambda x: '1' if all(y == '1' for y in x.split(',')) else '0',
+ 'OR': lambda x: '1' if any(y == '1' for y in x.split(',')) else '0',
+ 'NOT': lambda x: '0' if x == '1' else '1',
+
+ 'IF': lambda x: x.split(',')[1] if x.split(',')[0] == '1' else x.split(',')[2],
+
+ '0': lambda x: '',
+ '1': lambda x: x,
+
+ # String operations
+ 'STREQUAL': equal,
+ 'EQUAL': equal,
+ 'VERSION_LESS': lambda x: vers_comp('<', x),
+ 'VERSION_GREATER': lambda x: vers_comp('>', x),
+ 'VERSION_EQUAL': lambda x: vers_comp('=', x),
+ 'VERSION_LESS_EQUAL': lambda x: vers_comp('<=', x),
+ 'VERSION_GREATER_EQUAL': lambda x: vers_comp('>=', x),
+
+ # String modification
+ 'LOWER_CASE': lambda x: x.lower(),
+ 'UPPER_CASE': lambda x: x.upper(),
+
+ # Always assume the BUILD_INTERFACE is valid.
+ # INSTALL_INTERFACE is always invalid for subprojects and
+ # it should also never appear in CMake config files, used
+ # for dependencies
+ 'INSTALL_INTERFACE': lambda x: '',
+ 'BUILD_INTERFACE': lambda x: x,
+
+ # Constants
+ 'ANGLE-R': lambda x: '>',
+ 'COMMA': lambda x: ',',
+ 'SEMICOLON': lambda x: ';',
+
+ # Target related expressions
+ 'TARGET_EXISTS': lambda x: '1' if x in trace.targets else '0',
+ 'TARGET_NAME_IF_EXISTS': lambda x: x if x in trace.targets else '',
+ 'TARGET_PROPERTY': target_property,
+ 'TARGET_FILE': target_file,
+ } # type: T.Dict[str, T.Callable[[str], str]]
+
+ # Recursively evaluate generator expressions
+ def eval_generator_expressions() -> str:
+ nonlocal i
+ i += 2
+
+ func = '' # type: str
+ args = '' # type: str
+ res = '' # type: str
+ exp = '' # type: str
+
+ # Determine the body of the expression
+ while i < len(raw):
+ if raw[i] == '>':
+ # End of the generator expression
+ break
+ elif i < len(raw) - 1 and raw[i] == '$' and raw[i + 1] == '<':
+ # Nested generator expression
+ exp += eval_generator_expressions()
+ else:
+ # Generator expression body
+ exp += raw[i]
+
+ i += 1
+
+ # Split the expression into a function and arguments part
+ col_pos = exp.find(':')
+ if col_pos < 0:
+ func = exp
+ else:
+ func = exp[:col_pos]
+ args = exp[col_pos + 1:]
+
+ func = func.strip()
+ args = args.strip()
+
+ # Evaluate the function
+ if func in supported:
+ res = supported[func](args)
+
+ return res
+
+ while i < len(raw):
+ if i < len(raw) - 1 and raw[i] == '$' and raw[i + 1] == '<':
+ # Generator expression detected --> try resolving it
+ out += eval_generator_expressions()
+ else:
+ # Normal string, leave unchanged
+ out += raw[i]
+
+ i += 1
+
+ return out
diff --git a/mesonbuild/cmake/interpreter.py b/mesonbuild/cmake/interpreter.py
new file mode 100644
index 0000000..f88d091
--- /dev/null
+++ b/mesonbuild/cmake/interpreter.py
@@ -0,0 +1,1266 @@
+# 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.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+from __future__ import annotations
+
+from functools import lru_cache
+from os import environ
+from pathlib import Path
+import re
+import typing as T
+
+from .common import CMakeException, CMakeTarget, language_map, cmake_get_generator_args, check_cmake_args
+from .fileapi import CMakeFileAPI
+from .executor import CMakeExecutor
+from .toolchain import CMakeToolchain, CMakeExecScope
+from .traceparser import CMakeTraceParser
+from .tracetargets import resolve_cmake_trace_targets
+from .. import mlog, mesonlib
+from ..mesonlib import MachineChoice, OrderedSet, path_is_in_root, relative_to_if_possible, OptionKey
+from ..mesondata import DataFile
+from ..compilers.compilers import assembler_suffixes, lang_suffixes, header_suffixes, obj_suffixes, lib_suffixes, is_header
+from ..programs import ExternalProgram
+from ..coredata import FORBIDDEN_TARGET_NAMES
+from ..mparser import (
+ Token,
+ BaseNode,
+ CodeBlockNode,
+ FunctionNode,
+ ArrayNode,
+ ArgumentNode,
+ AssignmentNode,
+ BooleanNode,
+ StringNode,
+ IdNode,
+ IndexNode,
+ MethodNode,
+ NumberNode,
+)
+
+
+if T.TYPE_CHECKING:
+ from .common import CMakeConfiguration, TargetOptions
+ from .traceparser import CMakeGeneratorTarget
+ from .._typing import ImmutableListProtocol
+ from ..build import Build
+ from ..backend.backends import Backend
+ from ..environment import Environment
+
+ TYPE_mixed = T.Union[str, int, bool, Path, BaseNode]
+ TYPE_mixed_list = T.Union[TYPE_mixed, T.Sequence[TYPE_mixed]]
+ TYPE_mixed_kwargs = T.Dict[str, TYPE_mixed_list]
+
+# Disable all warnings automatically enabled with --trace and friends
+# See https://cmake.org/cmake/help/latest/variable/CMAKE_POLICY_WARNING_CMPNNNN.html
+disable_policy_warnings = [
+ 'CMP0025',
+ 'CMP0047',
+ 'CMP0056',
+ 'CMP0060',
+ 'CMP0065',
+ 'CMP0066',
+ 'CMP0067',
+ 'CMP0082',
+ 'CMP0089',
+ 'CMP0102',
+]
+
+target_type_map = {
+ 'STATIC_LIBRARY': 'static_library',
+ 'MODULE_LIBRARY': 'shared_module',
+ 'SHARED_LIBRARY': 'shared_library',
+ 'EXECUTABLE': 'executable',
+ 'OBJECT_LIBRARY': 'static_library',
+ 'INTERFACE_LIBRARY': 'header_only'
+}
+
+skip_targets = ['UTILITY']
+
+blacklist_compiler_flags = [
+ '-Wall', '-Wextra', '-Weverything', '-Werror', '-Wpedantic', '-pedantic', '-w',
+ '/W1', '/W2', '/W3', '/W4', '/Wall', '/WX', '/w',
+ '/O1', '/O2', '/Ob', '/Od', '/Og', '/Oi', '/Os', '/Ot', '/Ox', '/Oy', '/Ob0',
+ '/RTC1', '/RTCc', '/RTCs', '/RTCu',
+ '/Z7', '/Zi', '/ZI',
+]
+
+blacklist_link_flags = [
+ '/machine:x64', '/machine:x86', '/machine:arm', '/machine:ebc',
+ '/debug', '/debug:fastlink', '/debug:full', '/debug:none',
+ '/incremental',
+]
+
+blacklist_clang_cl_link_flags = ['/GR', '/EHsc', '/MDd', '/Zi', '/RTC1']
+
+blacklist_link_libs = [
+ 'kernel32.lib',
+ 'user32.lib',
+ 'gdi32.lib',
+ 'winspool.lib',
+ 'shell32.lib',
+ 'ole32.lib',
+ 'oleaut32.lib',
+ 'uuid.lib',
+ 'comdlg32.lib',
+ 'advapi32.lib'
+]
+
+transfer_dependencies_from = ['header_only']
+
+_cmake_name_regex = re.compile(r'[^_a-zA-Z0-9]')
+def _sanitize_cmake_name(name: str) -> str:
+ name = _cmake_name_regex.sub('_', name)
+ if name in FORBIDDEN_TARGET_NAMES or name.startswith('meson'):
+ name = 'cm_' + name
+ return name
+
+class OutputTargetMap:
+ rm_so_version = re.compile(r'(\.[0-9]+)+$')
+
+ def __init__(self, build_dir: Path):
+ self.tgt_map: T.Dict[str, T.Union['ConverterTarget', 'ConverterCustomTarget']] = {}
+ self.build_dir = build_dir
+
+ def add(self, tgt: T.Union['ConverterTarget', 'ConverterCustomTarget']) -> None:
+ def assign_keys(keys: T.List[str]) -> None:
+ for i in [x for x in keys if x]:
+ self.tgt_map[i] = tgt
+ keys = [self._target_key(tgt.cmake_name)]
+ if isinstance(tgt, ConverterTarget):
+ keys += [tgt.full_name]
+ keys += [self._rel_artifact_key(x) for x in tgt.artifacts]
+ keys += [self._base_artifact_key(x) for x in tgt.artifacts]
+ if isinstance(tgt, ConverterCustomTarget):
+ keys += [self._rel_generated_file_key(x) for x in tgt.original_outputs]
+ keys += [self._base_generated_file_key(x) for x in tgt.original_outputs]
+ assign_keys(keys)
+
+ def _return_first_valid_key(self, keys: T.List[str]) -> T.Optional[T.Union['ConverterTarget', 'ConverterCustomTarget']]:
+ for i in keys:
+ if i and i in self.tgt_map:
+ return self.tgt_map[i]
+ return None
+
+ def target(self, name: str) -> T.Optional[T.Union['ConverterTarget', 'ConverterCustomTarget']]:
+ return self._return_first_valid_key([self._target_key(name)])
+
+ def executable(self, name: str) -> T.Optional['ConverterTarget']:
+ tgt = self.target(name)
+ if tgt is None or not isinstance(tgt, ConverterTarget):
+ return None
+ if tgt.meson_func() != 'executable':
+ return None
+ return tgt
+
+ def artifact(self, name: str) -> T.Optional[T.Union['ConverterTarget', 'ConverterCustomTarget']]:
+ keys = []
+ candidates = [name, OutputTargetMap.rm_so_version.sub('', name)]
+ for i in lib_suffixes:
+ if not name.endswith('.' + i):
+ continue
+ new_name = name[:-len(i) - 1]
+ new_name = OutputTargetMap.rm_so_version.sub('', new_name)
+ candidates += [f'{new_name}.{i}']
+ for i in candidates:
+ keys += [self._rel_artifact_key(Path(i)), Path(i).name, self._base_artifact_key(Path(i))]
+ return self._return_first_valid_key(keys)
+
+ def generated(self, name: Path) -> T.Optional['ConverterCustomTarget']:
+ res = self._return_first_valid_key([self._rel_generated_file_key(name), self._base_generated_file_key(name)])
+ assert res is None or isinstance(res, ConverterCustomTarget)
+ return res
+
+ # Utility functions to generate local keys
+ def _rel_path(self, fname: Path) -> T.Optional[Path]:
+ try:
+ return fname.resolve().relative_to(self.build_dir)
+ except ValueError:
+ pass
+ return None
+
+ def _target_key(self, tgt_name: str) -> str:
+ return f'__tgt_{tgt_name}__'
+
+ def _rel_generated_file_key(self, fname: Path) -> T.Optional[str]:
+ path = self._rel_path(fname)
+ return f'__relgen_{path.as_posix()}__' if path else None
+
+ def _base_generated_file_key(self, fname: Path) -> str:
+ return f'__gen_{fname.name}__'
+
+ def _rel_artifact_key(self, fname: Path) -> T.Optional[str]:
+ path = self._rel_path(fname)
+ return f'__relart_{path.as_posix()}__' if path else None
+
+ def _base_artifact_key(self, fname: Path) -> str:
+ return f'__art_{fname.name}__'
+
+class ConverterTarget:
+ def __init__(self, target: CMakeTarget, env: 'Environment', for_machine: MachineChoice) -> None:
+ self.env = env
+ self.for_machine = for_machine
+ self.artifacts = target.artifacts
+ self.src_dir = target.src_dir
+ self.build_dir = target.build_dir
+ self.name = target.name
+ self.cmake_name = target.name
+ self.full_name = target.full_name
+ self.type = target.type
+ self.install = target.install
+ self.install_dir: T.Optional[Path] = None
+ self.link_libraries = target.link_libraries
+ self.link_flags = target.link_flags + target.link_lang_flags
+ self.depends_raw: T.List[str] = []
+ self.depends: T.List[T.Union[ConverterTarget, ConverterCustomTarget]] = []
+
+ if target.install_paths:
+ self.install_dir = target.install_paths[0]
+
+ self.languages: T.Set[str] = set()
+ self.sources: T.List[Path] = []
+ self.generated: T.List[Path] = []
+ self.generated_ctgt: T.List[CustomTargetReference] = []
+ self.includes: T.List[Path] = []
+ self.sys_includes: T.List[Path] = []
+ self.link_with: T.List[T.Union[ConverterTarget, ConverterCustomTarget]] = []
+ self.object_libs: T.List[ConverterTarget] = []
+ self.compile_opts: T.Dict[str, T.List[str]] = {}
+ self.public_compile_opts: T.List[str] = []
+ self.pie = False
+
+ # Project default override options (c_std, cpp_std, etc.)
+ self.override_options: T.List[str] = []
+
+ # Convert the target name to a valid meson target name
+ self.name = _sanitize_cmake_name(self.name)
+
+ self.generated_raw: T.List[Path] = []
+
+ for i in target.files:
+ languages: T.Set[str] = set()
+ src_suffixes: T.Set[str] = set()
+
+ # Insert suffixes
+ for j in i.sources:
+ if not j.suffix:
+ continue
+ src_suffixes.add(j.suffix[1:])
+
+ # Determine the meson language(s)
+ # Extract the default language from the explicit CMake field
+ lang_cmake_to_meson = {val.lower(): key for key, val in language_map.items()}
+ languages.add(lang_cmake_to_meson.get(i.language.lower(), 'c'))
+
+ # Determine missing languages from the source suffixes
+ for sfx in src_suffixes:
+ for key, val in lang_suffixes.items():
+ if sfx in val:
+ languages.add(key)
+ break
+
+ # Register the new languages and initialize the compile opts array
+ for lang in languages:
+ self.languages.add(lang)
+ if lang not in self.compile_opts:
+ self.compile_opts[lang] = []
+
+ # Add arguments, but avoid duplicates
+ args = i.flags
+ args += [f'-D{x}' for x in i.defines]
+ for lang in languages:
+ self.compile_opts[lang] += [x for x in args if x not in self.compile_opts[lang]]
+
+ # Handle include directories
+ self.includes += [x.path for x in i.includes if x.path not in self.includes and not x.isSystem]
+ self.sys_includes += [x.path for x in i.includes if x.path not in self.sys_includes and x.isSystem]
+
+ # Add sources to the right array
+ if i.is_generated:
+ self.generated_raw += i.sources
+ else:
+ self.sources += i.sources
+
+ def __repr__(self) -> str:
+ return f'<{self.__class__.__name__}: {self.name}>'
+
+ std_regex = re.compile(r'([-]{1,2}std=|/std:v?|[-]{1,2}std:)(.*)')
+
+ def postprocess(self, output_target_map: OutputTargetMap, root_src_dir: Path, subdir: Path, install_prefix: Path, trace: CMakeTraceParser) -> None:
+ # Detect setting the C and C++ standard and do additional compiler args manipulation
+ for i in ['c', 'cpp']:
+ if i not in self.compile_opts:
+ continue
+
+ temp = []
+ for j in self.compile_opts[i]:
+ m = ConverterTarget.std_regex.match(j)
+ ctgt = output_target_map.generated(Path(j))
+ if m:
+ std = m.group(2)
+ supported = self._all_lang_stds(i)
+ if std not in supported:
+ mlog.warning(
+ 'Unknown {0}_std "{1}" -> Ignoring. Try setting the project-'
+ 'level {0}_std if build errors occur. Known '
+ '{0}_stds are: {2}'.format(i, std, ' '.join(supported)),
+ once=True
+ )
+ continue
+ self.override_options += [f'{i}_std={std}']
+ elif j in {'-fPIC', '-fpic', '-fPIE', '-fpie'}:
+ self.pie = True
+ elif isinstance(ctgt, ConverterCustomTarget):
+ # Sometimes projects pass generated source files as compiler
+ # flags. Add these as generated sources to ensure that the
+ # corresponding custom target is run.2
+ self.generated_raw += [Path(j)]
+ temp += [j]
+ elif j in blacklist_compiler_flags:
+ pass
+ else:
+ temp += [j]
+
+ self.compile_opts[i] = temp
+
+ # Make sure to force enable -fPIC for OBJECT libraries
+ if self.type.upper() == 'OBJECT_LIBRARY':
+ self.pie = True
+
+ # Use the CMake trace, if required
+ tgt = trace.targets.get(self.cmake_name)
+ if tgt:
+ self.depends_raw = trace.targets[self.cmake_name].depends
+
+ rtgt = resolve_cmake_trace_targets(self.cmake_name, trace, self.env)
+ self.includes += [Path(x) for x in rtgt.include_directories]
+ self.link_flags += rtgt.link_flags
+ self.public_compile_opts += rtgt.public_compile_opts
+ self.link_libraries += rtgt.libraries
+
+ elif self.type.upper() not in ['EXECUTABLE', 'OBJECT_LIBRARY']:
+ mlog.warning('CMake: Target', mlog.bold(self.cmake_name), 'not found in CMake trace. This can lead to build errors')
+
+ temp = []
+ for i in self.link_libraries:
+ # Let meson handle this arcane magic
+ if ',-rpath,' in i:
+ continue
+ if not Path(i).is_absolute():
+ link_with = output_target_map.artifact(i)
+ if link_with:
+ self.link_with += [link_with]
+ continue
+
+ temp += [i]
+ self.link_libraries = temp
+
+ # Filter out files that are not supported by the language
+ supported = list(assembler_suffixes) + list(header_suffixes) + list(obj_suffixes)
+ for i in self.languages:
+ supported += list(lang_suffixes[i])
+ supported = [f'.{x}' for x in supported]
+ self.sources = [x for x in self.sources if any(x.name.endswith(y) for y in supported)]
+ self.generated_raw = [x for x in self.generated_raw if any(x.name.endswith(y) for y in supported)]
+
+ # Make paths relative
+ def rel_path(x: Path, is_header: bool, is_generated: bool) -> T.Optional[Path]:
+ if not x.is_absolute():
+ x = self.src_dir / x
+ x = x.resolve()
+ assert x.is_absolute()
+ if not x.exists() and not any(x.name.endswith(y) for y in obj_suffixes) and not is_generated:
+ if path_is_in_root(x, Path(self.env.get_build_dir()), resolve=True):
+ x.mkdir(parents=True, exist_ok=True)
+ return x.relative_to(Path(self.env.get_build_dir()) / subdir)
+ else:
+ mlog.warning('CMake: path', mlog.bold(x.as_posix()), 'does not exist.')
+ mlog.warning(' --> Ignoring. This can lead to build errors.')
+ return None
+ if x in trace.explicit_headers:
+ return None
+ if (
+ path_is_in_root(x, Path(self.env.get_source_dir()))
+ and not (
+ path_is_in_root(x, root_src_dir) or
+ path_is_in_root(x, Path(self.env.get_build_dir()))
+ )
+ ):
+ mlog.warning('CMake: path', mlog.bold(x.as_posix()), 'is inside the root project but', mlog.bold('not'), 'inside the subproject.')
+ mlog.warning(' --> Ignoring. This can lead to build errors.')
+ return None
+ if path_is_in_root(x, Path(self.env.get_build_dir())) and is_header:
+ return x.relative_to(Path(self.env.get_build_dir()) / subdir)
+ if path_is_in_root(x, root_src_dir):
+ return x.relative_to(root_src_dir)
+ return x
+
+ build_dir_rel = self.build_dir.relative_to(Path(self.env.get_build_dir()) / subdir)
+ self.generated_raw = [rel_path(x, False, True) for x in self.generated_raw]
+ self.includes = list(OrderedSet([rel_path(x, True, False) for x in OrderedSet(self.includes)] + [build_dir_rel]))
+ self.sys_includes = list(OrderedSet([rel_path(x, True, False) for x in OrderedSet(self.sys_includes)]))
+ self.sources = [rel_path(x, False, False) for x in self.sources]
+
+ # Resolve custom targets
+ for gen_file in self.generated_raw:
+ ctgt = output_target_map.generated(gen_file)
+ if ctgt:
+ assert isinstance(ctgt, ConverterCustomTarget)
+ ref = ctgt.get_ref(gen_file)
+ assert isinstance(ref, CustomTargetReference) and ref.valid()
+ self.generated_ctgt += [ref]
+ elif gen_file is not None:
+ self.generated += [gen_file]
+
+ # Remove delete entries
+ self.includes = [x for x in self.includes if x is not None]
+ self.sys_includes = [x for x in self.sys_includes if x is not None]
+ self.sources = [x for x in self.sources if x is not None]
+
+ # Make sure '.' is always in the include directories
+ if Path('.') not in self.includes:
+ self.includes += [Path('.')]
+
+ # make install dir relative to the install prefix
+ if self.install_dir and self.install_dir.is_absolute():
+ if path_is_in_root(self.install_dir, install_prefix):
+ self.install_dir = self.install_dir.relative_to(install_prefix)
+
+ # Remove blacklisted options and libs
+ def check_flag(flag: str) -> bool:
+ if flag.lower() in blacklist_link_flags or flag in blacklist_compiler_flags + blacklist_clang_cl_link_flags:
+ return False
+ if flag.startswith('/D'):
+ return False
+ return True
+
+ self.link_libraries = [x for x in self.link_libraries if x.lower() not in blacklist_link_libs]
+ self.link_flags = [x for x in self.link_flags if check_flag(x)]
+
+ # Handle OSX frameworks
+ def handle_frameworks(flags: T.List[str]) -> T.List[str]:
+ res: T.List[str] = []
+ for i in flags:
+ p = Path(i)
+ if not p.exists() or not p.name.endswith('.framework'):
+ res += [i]
+ continue
+ res += ['-framework', p.stem]
+ return res
+
+ self.link_libraries = handle_frameworks(self.link_libraries)
+ self.link_flags = handle_frameworks(self.link_flags)
+
+ # Handle explicit CMake add_dependency() calls
+ for i in self.depends_raw:
+ dep_tgt = output_target_map.target(i)
+ if dep_tgt:
+ self.depends.append(dep_tgt)
+
+ def process_object_libs(self, obj_target_list: T.List['ConverterTarget'], linker_workaround: bool) -> None:
+ # Try to detect the object library(s) from the generated input sources
+ temp = [x for x in self.generated if any(x.name.endswith('.' + y) for y in obj_suffixes)]
+ stem = [x.stem for x in temp]
+ exts = self._all_source_suffixes()
+ # Temp now stores the source filenames of the object files
+ for i in obj_target_list:
+ source_files = [x.name for x in i.sources + i.generated]
+ for j in stem:
+ # On some platforms (specifically looking at you Windows with vs20xy backend) CMake does
+ # not produce object files with the format `foo.cpp.obj`, instead it skipps the language
+ # suffix and just produces object files like `foo.obj`. Thus we have to do our best to
+ # undo this step and guess the correct language suffix of the object file. This is done
+ # by trying all language suffixes meson knows and checking if one of them fits.
+ candidates = [j]
+ if not any(j.endswith('.' + x) for x in exts):
+ mlog.warning('Object files do not contain source file extensions, thus falling back to guessing them.', once=True)
+ candidates += [f'{j}.{x}' for x in exts]
+ if any(x in source_files for x in candidates):
+ if linker_workaround:
+ self._append_objlib_sources(i)
+ else:
+ self.includes += i.includes
+ self.includes = list(OrderedSet(self.includes))
+ self.object_libs += [i]
+ break
+
+ # Filter out object files from the sources
+ self.generated = [x for x in self.generated if not any(x.name.endswith('.' + y) for y in obj_suffixes)]
+
+ def _append_objlib_sources(self, tgt: 'ConverterTarget') -> None:
+ self.includes += tgt.includes
+ self.sources += tgt.sources
+ self.generated += tgt.generated
+ self.generated_ctgt += tgt.generated_ctgt
+ self.includes = list(OrderedSet(self.includes))
+ self.sources = list(OrderedSet(self.sources))
+ self.generated = list(OrderedSet(self.generated))
+ self.generated_ctgt = list(OrderedSet(self.generated_ctgt))
+
+ # Inherit compiler arguments since they may be required for building
+ for lang, opts in tgt.compile_opts.items():
+ if lang not in self.compile_opts:
+ self.compile_opts[lang] = []
+ self.compile_opts[lang] += [x for x in opts if x not in self.compile_opts[lang]]
+
+ @lru_cache(maxsize=None)
+ def _all_source_suffixes(self) -> 'ImmutableListProtocol[str]':
+ suffixes: T.List[str] = []
+ for exts in lang_suffixes.values():
+ suffixes.extend(exts)
+ return suffixes
+
+ @lru_cache(maxsize=None)
+ def _all_lang_stds(self, lang: str) -> 'ImmutableListProtocol[str]':
+ try:
+ res = self.env.coredata.options[OptionKey('std', machine=MachineChoice.BUILD, lang=lang)].choices
+ except KeyError:
+ return []
+
+ # TODO: Get rid of this once we have proper typing for options
+ assert isinstance(res, list)
+ for i in res:
+ assert isinstance(i, str)
+
+ return res
+
+ def process_inter_target_dependencies(self) -> None:
+ # Move the dependencies from all transfer_dependencies_from to the target
+ to_process = list(self.depends)
+ processed = []
+ new_deps = []
+ for i in to_process:
+ processed += [i]
+ if isinstance(i, ConverterTarget) and i.meson_func() in transfer_dependencies_from:
+ to_process += [x for x in i.depends if x not in processed]
+ else:
+ new_deps += [i]
+ self.depends = list(OrderedSet(new_deps))
+
+ def cleanup_dependencies(self) -> None:
+ # Clear the dependencies from targets that where moved from
+ if self.meson_func() in transfer_dependencies_from:
+ self.depends = []
+
+ def meson_func(self) -> str:
+ return target_type_map.get(self.type.upper())
+
+ def log(self) -> None:
+ mlog.log('Target', mlog.bold(self.name), f'({self.cmake_name})')
+ mlog.log(' -- artifacts: ', mlog.bold(str(self.artifacts)))
+ mlog.log(' -- full_name: ', mlog.bold(self.full_name))
+ mlog.log(' -- type: ', mlog.bold(self.type))
+ mlog.log(' -- install: ', mlog.bold('true' if self.install else 'false'))
+ mlog.log(' -- install_dir: ', mlog.bold(self.install_dir.as_posix() if self.install_dir else ''))
+ mlog.log(' -- link_libraries: ', mlog.bold(str(self.link_libraries)))
+ mlog.log(' -- link_with: ', mlog.bold(str(self.link_with)))
+ mlog.log(' -- object_libs: ', mlog.bold(str(self.object_libs)))
+ mlog.log(' -- link_flags: ', mlog.bold(str(self.link_flags)))
+ mlog.log(' -- languages: ', mlog.bold(str(self.languages)))
+ mlog.log(' -- includes: ', mlog.bold(str(self.includes)))
+ mlog.log(' -- sys_includes: ', mlog.bold(str(self.sys_includes)))
+ mlog.log(' -- sources: ', mlog.bold(str(self.sources)))
+ mlog.log(' -- generated: ', mlog.bold(str(self.generated)))
+ mlog.log(' -- generated_ctgt: ', mlog.bold(str(self.generated_ctgt)))
+ mlog.log(' -- pie: ', mlog.bold('true' if self.pie else 'false'))
+ mlog.log(' -- override_opts: ', mlog.bold(str(self.override_options)))
+ mlog.log(' -- depends: ', mlog.bold(str(self.depends)))
+ mlog.log(' -- options:')
+ for key, val in self.compile_opts.items():
+ mlog.log(' -', key, '=', mlog.bold(str(val)))
+
+class CustomTargetReference:
+ def __init__(self, ctgt: 'ConverterCustomTarget', index: int) -> None:
+ self.ctgt = ctgt
+ self.index = index
+
+ def __repr__(self) -> str:
+ if self.valid():
+ return '<{}: {} [{}]>'.format(self.__class__.__name__, self.ctgt.name, self.ctgt.outputs[self.index])
+ else:
+ return f'<{self.__class__.__name__}: INVALID REFERENCE>'
+
+ def valid(self) -> bool:
+ return self.ctgt is not None and self.index >= 0
+
+ def filename(self) -> str:
+ return self.ctgt.outputs[self.index]
+
+class ConverterCustomTarget:
+ tgt_counter = 0
+ out_counter = 0
+
+ def __init__(self, target: CMakeGeneratorTarget, env: 'Environment', for_machine: MachineChoice) -> None:
+ assert target.current_bin_dir is not None
+ assert target.current_src_dir is not None
+ self.name = target.name
+ if not self.name:
+ self.name = f'custom_tgt_{ConverterCustomTarget.tgt_counter}'
+ ConverterCustomTarget.tgt_counter += 1
+ self.cmake_name = str(self.name)
+ self.original_outputs = list(target.outputs)
+ self.outputs = [x.name for x in self.original_outputs]
+ self.conflict_map: T.Dict[str, str] = {}
+ self.command: T.List[T.List[T.Union[str, ConverterTarget]]] = []
+ self.working_dir = target.working_dir
+ self.depends_raw = target.depends
+ self.inputs: T.List[T.Union[str, CustomTargetReference]] = []
+ self.depends: T.List[T.Union[ConverterTarget, ConverterCustomTarget]] = []
+ self.current_bin_dir = target.current_bin_dir
+ self.current_src_dir = target.current_src_dir
+ self.env = env
+ self.for_machine = for_machine
+ self._raw_target = target
+
+ # Convert the target name to a valid meson target name
+ self.name = _sanitize_cmake_name(self.name)
+
+ def __repr__(self) -> str:
+ return f'<{self.__class__.__name__}: {self.name} {self.outputs}>'
+
+ def postprocess(self, output_target_map: OutputTargetMap, root_src_dir: Path, all_outputs: T.List[str], trace: CMakeTraceParser) -> None:
+ # Default the working directory to ${CMAKE_CURRENT_BINARY_DIR}
+ if self.working_dir is None:
+ self.working_dir = self.current_bin_dir
+
+ # relative paths in the working directory are always relative
+ # to ${CMAKE_CURRENT_BINARY_DIR}
+ if not self.working_dir.is_absolute():
+ self.working_dir = self.current_bin_dir / self.working_dir
+
+ # Modify the original outputs if they are relative. Again,
+ # relative paths are relative to ${CMAKE_CURRENT_BINARY_DIR}
+ def ensure_absolute(x: Path) -> Path:
+ if x.is_absolute():
+ return x
+ else:
+ return self.current_bin_dir / x
+ self.original_outputs = [ensure_absolute(x) for x in self.original_outputs]
+
+ # Ensure that there is no duplicate output in the project so
+ # that meson can handle cases where the same filename is
+ # generated in multiple directories
+ temp_outputs: T.List[str] = []
+ for i in self.outputs:
+ if i in all_outputs:
+ old = str(i)
+ i = f'c{ConverterCustomTarget.out_counter}_{i}'
+ ConverterCustomTarget.out_counter += 1
+ self.conflict_map[old] = i
+ all_outputs += [i]
+ temp_outputs += [i]
+ self.outputs = temp_outputs
+
+ # Check if the command is a build target
+ commands: T.List[T.List[T.Union[str, ConverterTarget]]] = []
+ for curr_cmd in self._raw_target.command:
+ assert isinstance(curr_cmd, list)
+ assert curr_cmd[0] != '', "An empty string is not a valid executable"
+ cmd: T.List[T.Union[str, ConverterTarget]] = []
+
+ for j in curr_cmd:
+ if not j:
+ continue
+ target = output_target_map.executable(j)
+ if target:
+ # When cross compiling, binaries have to be executed with an exe_wrapper (for instance wine for mingw-w64)
+ if self.env.exe_wrapper is not None and self.env.properties[self.for_machine].get_cmake_use_exe_wrapper():
+ assert isinstance(self.env.exe_wrapper, ExternalProgram)
+ cmd += self.env.exe_wrapper.get_command()
+ cmd += [target]
+ continue
+ elif j in trace.targets:
+ trace_tgt = trace.targets[j]
+ if trace_tgt.type == 'EXECUTABLE' and 'IMPORTED_LOCATION' in trace_tgt.properties:
+ cmd += trace_tgt.properties['IMPORTED_LOCATION']
+ continue
+ mlog.debug(f'CMake: Found invalid CMake target "{j}" --> ignoring \n{trace_tgt}')
+
+ # Fallthrough on error
+ cmd += [j]
+
+ commands += [cmd]
+ self.command = commands
+
+ # If the custom target does not declare any output, create a dummy
+ # one that can be used as dependency.
+ if not self.outputs:
+ self.outputs = [self.name + '.h']
+
+ # Check dependencies and input files
+ for i in self.depends_raw:
+ if not i:
+ continue
+ raw = Path(i)
+ art = output_target_map.artifact(i)
+ tgt = output_target_map.target(i)
+ gen = output_target_map.generated(raw)
+
+ rel_to_root = None
+ try:
+ rel_to_root = raw.relative_to(root_src_dir)
+ except ValueError:
+ rel_to_root = None
+
+ # First check for existing files. Only then check for existing
+ # targets, etc. This reduces the chance of misdetecting input files
+ # as outputs from other targets.
+ # See https://github.com/mesonbuild/meson/issues/6632
+ if not raw.is_absolute() and (self.current_src_dir / raw).is_file():
+ self.inputs += [(self.current_src_dir / raw).relative_to(root_src_dir).as_posix()]
+ elif raw.is_absolute() and raw.exists() and rel_to_root is not None:
+ self.inputs += [rel_to_root.as_posix()]
+ elif art:
+ self.depends += [art]
+ elif tgt:
+ self.depends += [tgt]
+ elif gen:
+ ctgt_ref = gen.get_ref(raw)
+ assert ctgt_ref is not None
+ self.inputs += [ctgt_ref]
+
+ def process_inter_target_dependencies(self) -> None:
+ # Move the dependencies from all transfer_dependencies_from to the target
+ to_process = list(self.depends)
+ processed = []
+ new_deps = []
+ for i in to_process:
+ processed += [i]
+ if isinstance(i, ConverterTarget) and i.meson_func() in transfer_dependencies_from:
+ to_process += [x for x in i.depends if x not in processed]
+ else:
+ new_deps += [i]
+ self.depends = list(OrderedSet(new_deps))
+
+ def get_ref(self, fname: Path) -> T.Optional[CustomTargetReference]:
+ name = fname.name
+ try:
+ if name in self.conflict_map:
+ name = self.conflict_map[name]
+ idx = self.outputs.index(name)
+ return CustomTargetReference(self, idx)
+ except ValueError:
+ return None
+
+ def log(self) -> None:
+ mlog.log('Custom Target', mlog.bold(self.name), f'({self.cmake_name})')
+ mlog.log(' -- command: ', mlog.bold(str(self.command)))
+ mlog.log(' -- outputs: ', mlog.bold(str(self.outputs)))
+ mlog.log(' -- conflict_map: ', mlog.bold(str(self.conflict_map)))
+ mlog.log(' -- working_dir: ', mlog.bold(str(self.working_dir)))
+ mlog.log(' -- depends_raw: ', mlog.bold(str(self.depends_raw)))
+ mlog.log(' -- inputs: ', mlog.bold(str(self.inputs)))
+ mlog.log(' -- depends: ', mlog.bold(str(self.depends)))
+
+class CMakeInterpreter:
+ def __init__(self, build: 'Build', subdir: Path, src_dir: Path, install_prefix: Path, env: 'Environment', backend: 'Backend'):
+ self.build = build
+ self.subdir = subdir
+ self.src_dir = src_dir
+ self.build_dir_rel = subdir / '__CMake_build'
+ self.build_dir = Path(env.get_build_dir()) / self.build_dir_rel
+ self.install_prefix = install_prefix
+ self.env = env
+ self.for_machine = MachineChoice.HOST # TODO make parameter
+ self.backend_name = backend.name
+ self.linkers: T.Set[str] = set()
+ self.fileapi = CMakeFileAPI(self.build_dir)
+
+ # Raw CMake results
+ self.bs_files: T.List[Path] = []
+ self.codemodel_configs: T.Optional[T.List[CMakeConfiguration]] = None
+ self.cmake_stderr: T.Optional[str] = None
+
+ # Analysed data
+ self.project_name = ''
+ self.languages: T.List[str] = []
+ self.targets: T.List[ConverterTarget] = []
+ self.custom_targets: T.List[ConverterCustomTarget] = []
+ self.trace: CMakeTraceParser
+ self.output_target_map = OutputTargetMap(self.build_dir)
+
+ # Generated meson data
+ self.generated_targets: T.Dict[str, T.Dict[str, T.Optional[str]]] = {}
+ self.internal_name_map: T.Dict[str, str] = {}
+
+ # Do some special handling for object libraries for certain configurations
+ self._object_lib_workaround = False
+ if self.backend_name.startswith('vs'):
+ for comp in self.env.coredata.compilers[self.for_machine].values():
+ if comp.get_linker_id() == 'link':
+ self._object_lib_workaround = True
+ break
+
+ def configure(self, extra_cmake_options: T.List[str]) -> CMakeExecutor:
+ # Find CMake
+ # TODO: Using MachineChoice.BUILD should always be correct here, but also evaluate the use of self.for_machine
+ cmake_exe = CMakeExecutor(self.env, '>=3.14', MachineChoice.BUILD)
+ if not cmake_exe.found():
+ raise CMakeException('Unable to find CMake')
+ self.trace = CMakeTraceParser(cmake_exe.version(), self.build_dir, self.env, permissive=True)
+
+ preload_file = DataFile('cmake/data/preload.cmake').write_to_private(self.env)
+ toolchain = CMakeToolchain(cmake_exe, self.env, self.for_machine, CMakeExecScope.SUBPROJECT, self.build_dir, preload_file)
+ toolchain_file = toolchain.write()
+
+ # TODO: drop this check once the deprecated `cmake_args` kwarg is removed
+ extra_cmake_options = check_cmake_args(extra_cmake_options)
+
+ cmake_args = []
+ cmake_args += cmake_get_generator_args(self.env)
+ cmake_args += [f'-DCMAKE_INSTALL_PREFIX={self.install_prefix}']
+ cmake_args += extra_cmake_options
+ trace_args = self.trace.trace_args()
+ cmcmp_args = [f'-DCMAKE_POLICY_WARNING_{x}=OFF' for x in disable_policy_warnings]
+
+ self.fileapi.setup_request()
+
+ # Run CMake
+ mlog.log()
+ with mlog.nested():
+ mlog.log('Configuring the build directory with', mlog.bold('CMake'), 'version', mlog.cyan(cmake_exe.version()))
+ mlog.log(mlog.bold('Running CMake with:'), ' '.join(cmake_args))
+ mlog.log(mlog.bold(' - build directory: '), self.build_dir.as_posix())
+ mlog.log(mlog.bold(' - source directory: '), self.src_dir.as_posix())
+ mlog.log(mlog.bold(' - toolchain file: '), toolchain_file.as_posix())
+ mlog.log(mlog.bold(' - preload file: '), preload_file.as_posix())
+ mlog.log(mlog.bold(' - trace args: '), ' '.join(trace_args))
+ mlog.log(mlog.bold(' - disabled policy warnings:'), '[{}]'.format(', '.join(disable_policy_warnings)))
+ mlog.log()
+ self.build_dir.mkdir(parents=True, exist_ok=True)
+ os_env = environ.copy()
+ os_env['LC_ALL'] = 'C'
+ final_args = cmake_args + trace_args + cmcmp_args + toolchain.get_cmake_args() + [self.src_dir.as_posix()]
+
+ cmake_exe.set_exec_mode(print_cmout=True, always_capture_stderr=self.trace.requires_stderr())
+ rc, _, self.cmake_stderr = cmake_exe.call(final_args, self.build_dir, env=os_env, disable_cache=True)
+
+ mlog.log()
+ h = mlog.green('SUCCEEDED') if rc == 0 else mlog.red('FAILED')
+ mlog.log('CMake configuration:', h)
+ if rc != 0:
+ # get the last CMake error - We only need the message function for this:
+ self.trace.functions = {'message': self.trace.functions['message']}
+ self.trace.parse(self.cmake_stderr)
+ error = f': {self.trace.errors[-1]}' if self.trace.errors else ''
+ raise CMakeException(f'Failed to configure the CMake subproject{error}')
+
+ return cmake_exe
+
+ def initialise(self, extra_cmake_options: T.List[str]) -> None:
+ # Configure the CMake project to generate the file API data
+ self.configure(extra_cmake_options)
+
+ # Parse the result
+ self.fileapi.load_reply()
+
+ # Load the buildsystem file list
+ cmake_files = self.fileapi.get_cmake_sources()
+ self.bs_files = [x.file for x in cmake_files if not x.is_cmake and not x.is_temp]
+ self.bs_files = [relative_to_if_possible(x, Path(self.env.get_source_dir())) for x in self.bs_files]
+ self.bs_files = [x for x in self.bs_files if not path_is_in_root(x, Path(self.env.get_build_dir()), resolve=True)]
+ self.bs_files = list(OrderedSet(self.bs_files))
+
+ # Load the codemodel configurations
+ self.codemodel_configs = self.fileapi.get_cmake_configurations()
+
+ def analyse(self) -> None:
+ if self.codemodel_configs is None:
+ raise CMakeException('CMakeInterpreter was not initialized')
+
+ # Clear analyser data
+ self.project_name = ''
+ self.languages = []
+ self.targets = []
+ self.custom_targets = []
+
+ # Parse the trace
+ self.trace.parse(self.cmake_stderr)
+
+ # Find all targets
+ added_target_names: T.List[str] = []
+ for i_0 in self.codemodel_configs:
+ for j_0 in i_0.projects:
+ if not self.project_name:
+ self.project_name = j_0.name
+ for k_0 in j_0.targets:
+ # Avoid duplicate targets from different configurations and known
+ # dummy CMake internal target types
+ if k_0.type not in skip_targets and k_0.name not in added_target_names:
+ added_target_names += [k_0.name]
+ self.targets += [ConverterTarget(k_0, self.env, self.for_machine)]
+
+ # Add interface targets from trace, if not already present.
+ # This step is required because interface targets were removed from
+ # the CMake file API output.
+ api_target_name_list = [x.name for x in self.targets]
+ for i_1 in self.trace.targets.values():
+ if i_1.type != 'INTERFACE' or i_1.name in api_target_name_list or i_1.imported:
+ continue
+ dummy = CMakeTarget({
+ 'name': i_1.name,
+ 'type': 'INTERFACE_LIBRARY',
+ 'sourceDirectory': self.src_dir,
+ 'buildDirectory': self.build_dir,
+ })
+ self.targets += [ConverterTarget(dummy, self.env, self.for_machine)]
+
+ for i_2 in self.trace.custom_targets:
+ self.custom_targets += [ConverterCustomTarget(i_2, self.env, self.for_machine)]
+
+ # generate the output_target_map
+ for i_3 in [*self.targets, *self.custom_targets]:
+ assert isinstance(i_3, (ConverterTarget, ConverterCustomTarget))
+ self.output_target_map.add(i_3)
+
+ # First pass: Basic target cleanup
+ object_libs = []
+ custom_target_outputs: T.List[str] = []
+ for ctgt in self.custom_targets:
+ ctgt.postprocess(self.output_target_map, self.src_dir, custom_target_outputs, self.trace)
+ for tgt in self.targets:
+ tgt.postprocess(self.output_target_map, self.src_dir, self.subdir, self.install_prefix, self.trace)
+ if tgt.type == 'OBJECT_LIBRARY':
+ object_libs += [tgt]
+ self.languages += [x for x in tgt.languages if x not in self.languages]
+
+ # Second pass: Detect object library dependencies
+ for tgt in self.targets:
+ tgt.process_object_libs(object_libs, self._object_lib_workaround)
+
+ # Third pass: Reassign dependencies to avoid some loops
+ for tgt in self.targets:
+ tgt.process_inter_target_dependencies()
+ for ctgt in self.custom_targets:
+ ctgt.process_inter_target_dependencies()
+
+ # Fourth pass: Remove rassigned dependencies
+ for tgt in self.targets:
+ tgt.cleanup_dependencies()
+
+ mlog.log('CMake project', mlog.bold(self.project_name), 'has', mlog.bold(str(len(self.targets) + len(self.custom_targets))), 'build targets.')
+
+ def pretend_to_be_meson(self, options: TargetOptions) -> CodeBlockNode:
+ if not self.project_name:
+ raise CMakeException('CMakeInterpreter was not analysed')
+
+ def token(tid: str = 'string', val: TYPE_mixed = '') -> Token:
+ return Token(tid, self.subdir.as_posix(), 0, 0, 0, None, val)
+
+ def string(value: str) -> StringNode:
+ return StringNode(token(val=value))
+
+ def id_node(value: str) -> IdNode:
+ return IdNode(token(val=value))
+
+ def number(value: int) -> NumberNode:
+ return NumberNode(token(val=value))
+
+ def nodeify(value: TYPE_mixed_list) -> BaseNode:
+ if isinstance(value, str):
+ return string(value)
+ if isinstance(value, Path):
+ return string(value.as_posix())
+ elif isinstance(value, bool):
+ return BooleanNode(token(val=value))
+ elif isinstance(value, int):
+ return number(value)
+ elif isinstance(value, list):
+ return array(value)
+ elif isinstance(value, BaseNode):
+ return value
+ raise RuntimeError('invalid type of value: {} ({})'.format(type(value).__name__, str(value)))
+
+ def indexed(node: BaseNode, index: int) -> IndexNode:
+ return IndexNode(node, nodeify(index))
+
+ def array(elements: TYPE_mixed_list) -> ArrayNode:
+ args = ArgumentNode(token())
+ if not isinstance(elements, list):
+ elements = [args]
+ args.arguments += [nodeify(x) for x in elements if x is not None]
+ return ArrayNode(args, 0, 0, 0, 0)
+
+ def function(name: str, args: T.Optional[TYPE_mixed_list] = None, kwargs: T.Optional[TYPE_mixed_kwargs] = None) -> FunctionNode:
+ args = [] if args is None else args
+ kwargs = {} if kwargs is None else kwargs
+ args_n = ArgumentNode(token())
+ if not isinstance(args, list):
+ assert isinstance(args, (str, int, bool, Path, BaseNode))
+ args = [args]
+ args_n.arguments = [nodeify(x) for x in args if x is not None]
+ args_n.kwargs = {id_node(k): nodeify(v) for k, v in kwargs.items() if v is not None}
+ func_n = FunctionNode(self.subdir.as_posix(), 0, 0, 0, 0, name, args_n)
+ return func_n
+
+ def method(obj: BaseNode, name: str, args: T.Optional[TYPE_mixed_list] = None, kwargs: T.Optional[TYPE_mixed_kwargs] = None) -> MethodNode:
+ args = [] if args is None else args
+ kwargs = {} if kwargs is None else kwargs
+ args_n = ArgumentNode(token())
+ if not isinstance(args, list):
+ assert isinstance(args, (str, int, bool, Path, BaseNode))
+ args = [args]
+ args_n.arguments = [nodeify(x) for x in args if x is not None]
+ args_n.kwargs = {id_node(k): nodeify(v) for k, v in kwargs.items() if v is not None}
+ return MethodNode(self.subdir.as_posix(), 0, 0, obj, name, args_n)
+
+ def assign(var_name: str, value: BaseNode) -> AssignmentNode:
+ return AssignmentNode(self.subdir.as_posix(), 0, 0, var_name, value)
+
+ # Generate the root code block and the project function call
+ root_cb = CodeBlockNode(token())
+ root_cb.lines += [function('project', [self.project_name] + self.languages)]
+
+ # Add the run script for custom commands
+
+ # Add the targets
+ processing: T.List[str] = []
+ processed: T.Dict[str, T.Dict[str, T.Optional[str]]] = {}
+ name_map: T.Dict[str, str] = {}
+
+ def extract_tgt(tgt: T.Union[ConverterTarget, ConverterCustomTarget, CustomTargetReference]) -> IdNode:
+ tgt_name = None
+ if isinstance(tgt, (ConverterTarget, ConverterCustomTarget)):
+ tgt_name = tgt.name
+ elif isinstance(tgt, CustomTargetReference):
+ tgt_name = tgt.ctgt.name
+ assert tgt_name is not None and tgt_name in processed
+ res_var = processed[tgt_name]['tgt']
+ return id_node(res_var) if res_var else None
+
+ def detect_cycle(tgt: T.Union[ConverterTarget, ConverterCustomTarget]) -> None:
+ if tgt.name in processing:
+ raise CMakeException('Cycle in CMake inputs/dependencies detected')
+ processing.append(tgt.name)
+
+ def resolve_ctgt_ref(ref: CustomTargetReference) -> T.Union[IdNode, IndexNode]:
+ tgt_var = extract_tgt(ref)
+ if len(ref.ctgt.outputs) == 1:
+ return tgt_var
+ else:
+ return indexed(tgt_var, ref.index)
+
+ def process_target(tgt: ConverterTarget) -> None:
+ detect_cycle(tgt)
+
+ # First handle inter target dependencies
+ link_with: T.List[IdNode] = []
+ objec_libs: T.List[IdNode] = []
+ sources: T.List[Path] = []
+ generated: T.List[T.Union[IdNode, IndexNode]] = []
+ generated_filenames: T.List[str] = []
+ custom_targets: T.List[ConverterCustomTarget] = []
+ dependencies: T.List[IdNode] = []
+ for i in tgt.link_with:
+ assert isinstance(i, ConverterTarget)
+ if i.name not in processed:
+ process_target(i)
+ link_with += [extract_tgt(i)]
+ for i in tgt.object_libs:
+ assert isinstance(i, ConverterTarget)
+ if i.name not in processed:
+ process_target(i)
+ objec_libs += [extract_tgt(i)]
+ for i in tgt.depends:
+ if not isinstance(i, ConverterCustomTarget):
+ continue
+ if i.name not in processed:
+ process_custom_target(i)
+ dependencies += [extract_tgt(i)]
+
+ # Generate the source list and handle generated sources
+ sources += tgt.sources
+ sources += tgt.generated
+
+ for ctgt_ref in tgt.generated_ctgt:
+ ctgt = ctgt_ref.ctgt
+ if ctgt.name not in processed:
+ process_custom_target(ctgt)
+ generated += [resolve_ctgt_ref(ctgt_ref)]
+ generated_filenames += [ctgt_ref.filename()]
+ if ctgt not in custom_targets:
+ custom_targets += [ctgt]
+
+ # Add all header files from all used custom targets. This
+ # ensures that all custom targets are built before any
+ # sources of the current target are compiled and thus all
+ # header files are present. This step is necessary because
+ # CMake always ensures that a custom target is executed
+ # before another target if at least one output is used.
+ for ctgt in custom_targets:
+ for j in ctgt.outputs:
+ if not is_header(j) or j in generated_filenames:
+ continue
+
+ generated += [resolve_ctgt_ref(ctgt.get_ref(Path(j)))]
+ generated_filenames += [j]
+
+ # Determine the meson function to use for the build target
+ tgt_func = tgt.meson_func()
+ if not tgt_func:
+ raise CMakeException(f'Unknown target type "{tgt.type}"')
+
+ # Determine the variable names
+ inc_var = f'{tgt.name}_inc'
+ dir_var = f'{tgt.name}_dir'
+ sys_var = f'{tgt.name}_sys'
+ src_var = f'{tgt.name}_src'
+ dep_var = f'{tgt.name}_dep'
+ tgt_var = tgt.name
+
+ install_tgt = options.get_install(tgt.cmake_name, tgt.install)
+
+ # Generate target kwargs
+ tgt_kwargs: TYPE_mixed_kwargs = {
+ 'build_by_default': install_tgt,
+ 'link_args': options.get_link_args(tgt.cmake_name, tgt.link_flags + tgt.link_libraries),
+ 'link_with': link_with,
+ 'include_directories': id_node(inc_var),
+ 'install': install_tgt,
+ 'override_options': options.get_override_options(tgt.cmake_name, tgt.override_options),
+ 'objects': [method(x, 'extract_all_objects') for x in objec_libs],
+ }
+
+ # Only set if installed and only override if it is set
+ if install_tgt and tgt.install_dir:
+ tgt_kwargs['install_dir'] = tgt.install_dir
+
+ # Handle compiler args
+ for key, val in tgt.compile_opts.items():
+ tgt_kwargs[f'{key}_args'] = options.get_compile_args(tgt.cmake_name, key, val)
+
+ # Handle -fPCI, etc
+ if tgt_func == 'executable':
+ tgt_kwargs['pie'] = tgt.pie
+ elif tgt_func == 'static_library':
+ tgt_kwargs['pic'] = tgt.pie
+
+ # declare_dependency kwargs
+ dep_kwargs: TYPE_mixed_kwargs = {
+ 'link_args': tgt.link_flags + tgt.link_libraries,
+ 'link_with': id_node(tgt_var),
+ 'compile_args': tgt.public_compile_opts,
+ 'include_directories': id_node(inc_var),
+ }
+
+ if dependencies:
+ generated += dependencies
+
+ # Generate the function nodes
+ dir_node = assign(dir_var, function('include_directories', tgt.includes))
+ sys_node = assign(sys_var, function('include_directories', tgt.sys_includes, {'is_system': True}))
+ inc_node = assign(inc_var, array([id_node(dir_var), id_node(sys_var)]))
+ node_list = [dir_node, sys_node, inc_node]
+ if tgt_func == 'header_only':
+ del dep_kwargs['link_with']
+ dep_node = assign(dep_var, function('declare_dependency', kwargs=dep_kwargs))
+ node_list += [dep_node]
+ src_var = None
+ tgt_var = None
+ else:
+ src_node = assign(src_var, function('files', sources))
+ tgt_node = assign(tgt_var, function(tgt_func, [tgt_var, id_node(src_var), *generated], tgt_kwargs))
+ node_list += [src_node, tgt_node]
+ if tgt_func in {'static_library', 'shared_library'}:
+ dep_node = assign(dep_var, function('declare_dependency', kwargs=dep_kwargs))
+ node_list += [dep_node]
+ elif tgt_func == 'shared_module':
+ del dep_kwargs['link_with']
+ dep_node = assign(dep_var, function('declare_dependency', kwargs=dep_kwargs))
+ node_list += [dep_node]
+ else:
+ dep_var = None
+
+ # Add the nodes to the ast
+ root_cb.lines += node_list
+ processed[tgt.name] = {'inc': inc_var, 'src': src_var, 'dep': dep_var, 'tgt': tgt_var, 'func': tgt_func}
+ name_map[tgt.cmake_name] = tgt.name
+
+ def process_custom_target(tgt: ConverterCustomTarget) -> None:
+ # CMake allows to specify multiple commands in a custom target.
+ # To map this to meson, a helper script is used to execute all
+ # commands in order. This additionally allows setting the working
+ # directory.
+
+ detect_cycle(tgt)
+ tgt_var = tgt.name
+
+ def resolve_source(x: T.Union[str, ConverterTarget, ConverterCustomTarget, CustomTargetReference]) -> T.Union[str, IdNode, IndexNode]:
+ if isinstance(x, ConverterTarget):
+ if x.name not in processed:
+ process_target(x)
+ return extract_tgt(x)
+ if isinstance(x, ConverterCustomTarget):
+ if x.name not in processed:
+ process_custom_target(x)
+ return extract_tgt(x)
+ elif isinstance(x, CustomTargetReference):
+ if x.ctgt.name not in processed:
+ process_custom_target(x.ctgt)
+ return resolve_ctgt_ref(x)
+ else:
+ return x
+
+ # Generate the command list
+ command: T.List[T.Union[str, IdNode, IndexNode]] = []
+ command += mesonlib.get_meson_command()
+ command += ['--internal', 'cmake_run_ctgt']
+ command += ['-o', '@OUTPUT@']
+ if tgt.original_outputs:
+ command += ['-O'] + [x.as_posix() for x in tgt.original_outputs]
+ command += ['-d', tgt.working_dir.as_posix()]
+
+ # Generate the commands. Subcommands are separated by ';;;'
+ for cmd in tgt.command:
+ command += [resolve_source(x) for x in cmd] + [';;;']
+
+ tgt_kwargs: TYPE_mixed_kwargs = {
+ 'input': [resolve_source(x) for x in tgt.inputs],
+ 'output': tgt.outputs,
+ 'command': command,
+ 'depends': [resolve_source(x) for x in tgt.depends],
+ }
+
+ root_cb.lines += [assign(tgt_var, function('custom_target', [tgt.name], tgt_kwargs))]
+ processed[tgt.name] = {'inc': None, 'src': None, 'dep': None, 'tgt': tgt_var, 'func': 'custom_target'}
+ name_map[tgt.cmake_name] = tgt.name
+
+ # Now generate the target function calls
+ for ctgt in self.custom_targets:
+ if ctgt.name not in processed:
+ process_custom_target(ctgt)
+ for tgt in self.targets:
+ if tgt.name not in processed:
+ process_target(tgt)
+
+ self.generated_targets = processed
+ self.internal_name_map = name_map
+ return root_cb
+
+ def target_info(self, target: str) -> T.Optional[T.Dict[str, str]]:
+ # Try resolving the target name
+ # start by checking if there is a 100% match (excluding the name prefix)
+ prx_tgt = _sanitize_cmake_name(target)
+ if prx_tgt in self.generated_targets:
+ return self.generated_targets[prx_tgt]
+ # check if there exists a name mapping
+ if target in self.internal_name_map:
+ target = self.internal_name_map[target]
+ assert target in self.generated_targets
+ return self.generated_targets[target]
+ return None
+
+ def target_list(self) -> T.List[str]:
+ return list(self.internal_name_map.keys())
diff --git a/mesonbuild/cmake/toolchain.py b/mesonbuild/cmake/toolchain.py
new file mode 100644
index 0000000..477629e
--- /dev/null
+++ b/mesonbuild/cmake/toolchain.py
@@ -0,0 +1,258 @@
+# 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 __future__ import annotations
+
+from pathlib import Path
+from .traceparser import CMakeTraceParser
+from ..envconfig import CMakeSkipCompilerTest
+from .common import language_map, cmake_get_generator_args
+from .. import mlog
+
+import shutil
+import typing as T
+from enum import Enum
+from textwrap import dedent
+
+if T.TYPE_CHECKING:
+ from .executor import CMakeExecutor
+ from ..environment import Environment
+ from ..compilers import Compiler
+ from ..mesonlib import MachineChoice
+
+class CMakeExecScope(Enum):
+ SUBPROJECT = 'subproject'
+ DEPENDENCY = 'dependency'
+
+class CMakeToolchain:
+ def __init__(self, cmakebin: 'CMakeExecutor', env: 'Environment', for_machine: MachineChoice, exec_scope: CMakeExecScope, build_dir: Path, preload_file: T.Optional[Path] = None) -> None:
+ self.env = env
+ self.cmakebin = cmakebin
+ self.for_machine = for_machine
+ self.exec_scope = exec_scope
+ self.preload_file = preload_file
+ self.build_dir = build_dir
+ self.build_dir = self.build_dir.resolve()
+ self.toolchain_file = build_dir / 'CMakeMesonToolchainFile.cmake'
+ self.cmcache_file = build_dir / 'CMakeCache.txt'
+ self.minfo = self.env.machines[self.for_machine]
+ self.properties = self.env.properties[self.for_machine]
+ self.compilers = self.env.coredata.compilers[self.for_machine]
+ self.cmakevars = self.env.cmakevars[self.for_machine]
+ self.cmakestate = self.env.coredata.cmake_cache[self.for_machine]
+
+ self.variables = self.get_defaults()
+ self.variables.update(self.cmakevars.get_variables())
+
+ # Determine whether CMake the compiler test should be skipped
+ skip_status = self.properties.get_cmake_skip_compiler_test()
+ self.skip_check = skip_status == CMakeSkipCompilerTest.ALWAYS
+ if skip_status == CMakeSkipCompilerTest.DEP_ONLY and self.exec_scope == CMakeExecScope.DEPENDENCY:
+ self.skip_check = True
+ if not self.properties.get_cmake_defaults():
+ self.skip_check = False
+
+ assert self.toolchain_file.is_absolute()
+
+ def write(self) -> Path:
+ if not self.toolchain_file.parent.exists():
+ self.toolchain_file.parent.mkdir(parents=True)
+ self.toolchain_file.write_text(self.generate(), encoding='utf-8')
+ self.cmcache_file.write_text(self.generate_cache(), encoding='utf-8')
+ mlog.cmd_ci_include(self.toolchain_file.as_posix())
+ return self.toolchain_file
+
+ def get_cmake_args(self) -> T.List[str]:
+ args = ['-DCMAKE_TOOLCHAIN_FILE=' + self.toolchain_file.as_posix()]
+ if self.preload_file is not None:
+ args += ['-DMESON_PRELOAD_FILE=' + self.preload_file.as_posix()]
+ return args
+
+ @staticmethod
+ def _print_vars(vars: T.Dict[str, T.List[str]]) -> str:
+ res = ''
+ for key, value in vars.items():
+ res += 'set(' + key
+ for i in value:
+ res += f' "{i}"'
+ res += ')\n'
+ return res
+
+ def generate(self) -> str:
+ res = dedent('''\
+ ######################################
+ ### AUTOMATICALLY GENERATED FILE ###
+ ######################################
+
+ # This file was generated from the configuration in the
+ # relevant meson machine file. See the meson documentation
+ # https://mesonbuild.com/Machine-files.html for more information
+
+ if(DEFINED MESON_PRELOAD_FILE)
+ include("${MESON_PRELOAD_FILE}")
+ endif()
+
+ ''')
+
+ # Escape all \ in the values
+ for key, value in self.variables.items():
+ self.variables[key] = [x.replace('\\', '/') for x in value]
+
+ # Set compiler
+ if self.skip_check:
+ self.update_cmake_compiler_state()
+ res += '# CMake compiler state variables\n'
+ for lang, vars in self.cmakestate:
+ res += f'# -- Variables for language {lang}\n'
+ res += self._print_vars(vars)
+ res += '\n'
+ res += '\n'
+
+ # Set variables from the current machine config
+ res += '# Variables from meson\n'
+ res += self._print_vars(self.variables)
+ res += '\n'
+
+ # Add the user provided toolchain file
+ user_file = self.properties.get_cmake_toolchain_file()
+ if user_file is not None:
+ res += dedent('''
+ # Load the CMake toolchain file specified by the user
+ include("{}")
+
+ '''.format(user_file.as_posix()))
+
+ return res
+
+ def generate_cache(self) -> str:
+ if not self.skip_check:
+ return ''
+
+ res = ''
+ for name, v in self.cmakestate.cmake_cache.items():
+ res += f'{name}:{v.type}={";".join(v.value)}\n'
+ return res
+
+ def get_defaults(self) -> T.Dict[str, T.List[str]]:
+ defaults = {} # type: T.Dict[str, T.List[str]]
+
+ # Do nothing if the user does not want automatic defaults
+ if not self.properties.get_cmake_defaults():
+ return defaults
+
+ # Best effort to map the meson system name to CMAKE_SYSTEM_NAME, which
+ # is not trivial since CMake lacks a list of all supported
+ # CMAKE_SYSTEM_NAME values.
+ SYSTEM_MAP = {
+ 'android': 'Android',
+ 'linux': 'Linux',
+ 'windows': 'Windows',
+ 'freebsd': 'FreeBSD',
+ 'darwin': 'Darwin',
+ } # type: T.Dict[str, str]
+
+ # Only set these in a cross build. Otherwise CMake will trip up in native
+ # builds and thing they are cross (which causes TRY_RUN() to break)
+ if self.env.is_cross_build(when_building_for=self.for_machine):
+ defaults['CMAKE_SYSTEM_NAME'] = [SYSTEM_MAP.get(self.minfo.system, self.minfo.system)]
+ defaults['CMAKE_SYSTEM_PROCESSOR'] = [self.minfo.cpu_family]
+
+ defaults['CMAKE_SIZEOF_VOID_P'] = ['8' if self.minfo.is_64_bit else '4']
+
+ sys_root = self.properties.get_sys_root()
+ if sys_root:
+ defaults['CMAKE_SYSROOT'] = [sys_root]
+
+ def make_abs(exe: str) -> str:
+ if Path(exe).is_absolute():
+ return exe
+
+ p = shutil.which(exe)
+ if p is None:
+ return exe
+ return p
+
+ # Set the compiler variables
+ for lang, comp_obj in self.compilers.items():
+ prefix = 'CMAKE_{}_'.format(language_map.get(lang, lang.upper()))
+
+ exe_list = comp_obj.get_exelist()
+ if not exe_list:
+ continue
+
+ if len(exe_list) >= 2 and not self.is_cmdline_option(comp_obj, exe_list[1]):
+ defaults[prefix + 'COMPILER_LAUNCHER'] = [make_abs(exe_list[0])]
+ exe_list = exe_list[1:]
+
+ exe_list[0] = make_abs(exe_list[0])
+ defaults[prefix + 'COMPILER'] = exe_list
+ if comp_obj.get_id() == 'clang-cl':
+ defaults['CMAKE_LINKER'] = comp_obj.get_linker_exelist()
+
+ return defaults
+
+ @staticmethod
+ def is_cmdline_option(compiler: 'Compiler', arg: str) -> bool:
+ if compiler.get_argument_syntax() == 'msvc':
+ return arg.startswith('/')
+ else:
+ return arg.startswith('-')
+
+ def update_cmake_compiler_state(self) -> None:
+ # Check if all variables are already cached
+ if self.cmakestate.languages.issuperset(self.compilers.keys()):
+ return
+
+ # Generate the CMakeLists.txt
+ mlog.debug('CMake Toolchain: Calling CMake once to generate the compiler state')
+ languages = list(self.compilers.keys())
+ lang_ids = [language_map.get(x, x.upper()) for x in languages]
+ cmake_content = dedent(f'''
+ cmake_minimum_required(VERSION 3.7)
+ project(CompInfo {' '.join(lang_ids)})
+ ''')
+
+ build_dir = Path(self.env.scratch_dir) / '__CMake_compiler_info__'
+ build_dir.mkdir(parents=True, exist_ok=True)
+ cmake_file = build_dir / 'CMakeLists.txt'
+ cmake_file.write_text(cmake_content, encoding='utf-8')
+
+ # Generate the temporary toolchain file
+ temp_toolchain_file = build_dir / 'CMakeMesonTempToolchainFile.cmake'
+ temp_toolchain_file.write_text(CMakeToolchain._print_vars(self.variables), encoding='utf-8')
+
+ # Configure
+ trace = CMakeTraceParser(self.cmakebin.version(), build_dir, self.env)
+ self.cmakebin.set_exec_mode(print_cmout=False, always_capture_stderr=trace.requires_stderr())
+ cmake_args = []
+ cmake_args += trace.trace_args()
+ cmake_args += cmake_get_generator_args(self.env)
+ cmake_args += [f'-DCMAKE_TOOLCHAIN_FILE={temp_toolchain_file.as_posix()}', '.']
+ rc, _, raw_trace = self.cmakebin.call(cmake_args, build_dir=build_dir, disable_cache=True)
+
+ if rc != 0:
+ mlog.warning('CMake Toolchain: Failed to determine CMake compilers state')
+ return
+
+ # Parse output
+ trace.parse(raw_trace)
+ self.cmakestate.cmake_cache = {**trace.cache}
+
+ vars_by_file = {k.name: v for (k, v) in trace.vars_by_file.items()}
+
+ for lang in languages:
+ lang_cmake = language_map.get(lang, lang.upper())
+ file_name = f'CMake{lang_cmake}Compiler.cmake'
+ vars = vars_by_file.setdefault(file_name, {})
+ vars[f'CMAKE_{lang_cmake}_COMPILER_FORCED'] = ['1']
+ self.cmakestate.update(lang, vars)
diff --git a/mesonbuild/cmake/traceparser.py b/mesonbuild/cmake/traceparser.py
new file mode 100644
index 0000000..5fcba80
--- /dev/null
+++ b/mesonbuild/cmake/traceparser.py
@@ -0,0 +1,825 @@
+# 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.
+
+# This class contains the basic functionality needed to run any interpreter
+# or an interpreter-based tool.
+from __future__ import annotations
+
+from .common import CMakeException
+from .generator import parse_generator_expressions
+from .. import mlog
+from ..mesonlib import version_compare
+
+import typing as T
+from pathlib import Path
+from functools import lru_cache
+import re
+import json
+import textwrap
+
+if T.TYPE_CHECKING:
+ from ..environment import Environment
+
+class CMakeTraceLine:
+ def __init__(self, file_str: str, line: int, func: str, args: T.List[str]) -> None:
+ self.file = CMakeTraceLine._to_path(file_str)
+ self.line = line
+ self.func = func.lower()
+ self.args = args
+
+ @staticmethod
+ @lru_cache(maxsize=None)
+ def _to_path(file_str: str) -> Path:
+ return Path(file_str)
+
+ def __repr__(self) -> str:
+ s = 'CMake TRACE: {0}:{1} {2}({3})'
+ return s.format(self.file, self.line, self.func, self.args)
+
+class CMakeCacheEntry(T.NamedTuple):
+ value: T.List[str]
+ type: str
+
+class CMakeTarget:
+ def __init__(
+ self,
+ name: str,
+ target_type: str,
+ properties: T.Optional[T.Dict[str, T.List[str]]] = None,
+ imported: bool = False,
+ tline: T.Optional[CMakeTraceLine] = None
+ ):
+ if properties is None:
+ properties = {}
+ self.name = name
+ self.type = target_type
+ self.properties = properties
+ self.imported = imported
+ self.tline = tline
+ self.depends = [] # type: T.List[str]
+ self.current_bin_dir = None # type: T.Optional[Path]
+ self.current_src_dir = None # type: T.Optional[Path]
+
+ def __repr__(self) -> str:
+ s = 'CMake TARGET:\n -- name: {}\n -- type: {}\n -- imported: {}\n -- properties: {{\n{} }}\n -- tline: {}'
+ propSTR = ''
+ for i in self.properties:
+ propSTR += " '{}': {}\n".format(i, self.properties[i])
+ return s.format(self.name, self.type, self.imported, propSTR, self.tline)
+
+ def strip_properties(self) -> None:
+ # Strip the strings in the properties
+ if not self.properties:
+ return
+ for key, val in self.properties.items():
+ self.properties[key] = [x.strip() for x in val]
+ assert all(';' not in x for x in self.properties[key])
+
+class CMakeGeneratorTarget(CMakeTarget):
+ def __init__(self, name: str) -> None:
+ super().__init__(name, 'CUSTOM', {})
+ self.outputs = [] # type: T.List[Path]
+ self._outputs_str = [] # type: T.List[str]
+ self.command = [] # type: T.List[T.List[str]]
+ self.working_dir = None # type: T.Optional[Path]
+
+class CMakeTraceParser:
+ def __init__(self, cmake_version: str, build_dir: Path, env: 'Environment', permissive: bool = True) -> None:
+ self.vars: T.Dict[str, T.List[str]] = {}
+ self.vars_by_file: T.Dict[Path, T.Dict[str, T.List[str]]] = {}
+ self.targets: T.Dict[str, CMakeTarget] = {}
+ self.cache: T.Dict[str, CMakeCacheEntry] = {}
+
+ self.explicit_headers = set() # type: T.Set[Path]
+
+ # T.List of targes that were added with add_custom_command to generate files
+ self.custom_targets = [] # type: T.List[CMakeGeneratorTarget]
+
+ self.env = env
+ self.permissive = permissive # type: bool
+ self.cmake_version = cmake_version # type: str
+ self.trace_file = 'cmake_trace.txt'
+ self.trace_file_path = build_dir / self.trace_file
+ self.trace_format = 'json-v1' if version_compare(cmake_version, '>=3.17') else 'human'
+
+ self.errors: T.List[str] = []
+
+ # State for delayed command execution. Delayed command execution is realised
+ # with a custom CMake file that overrides some functions and adds some
+ # introspection information to the trace.
+ self.delayed_commands = [] # type: T.List[str]
+ self.stored_commands = [] # type: T.List[CMakeTraceLine]
+
+ # All supported functions
+ self.functions = {
+ 'set': self._cmake_set,
+ 'unset': self._cmake_unset,
+ 'add_executable': self._cmake_add_executable,
+ 'add_library': self._cmake_add_library,
+ 'add_custom_command': self._cmake_add_custom_command,
+ 'add_custom_target': self._cmake_add_custom_target,
+ 'set_property': self._cmake_set_property,
+ 'set_target_properties': self._cmake_set_target_properties,
+ 'target_compile_definitions': self._cmake_target_compile_definitions,
+ 'target_compile_options': self._cmake_target_compile_options,
+ 'target_include_directories': self._cmake_target_include_directories,
+ 'target_link_libraries': self._cmake_target_link_libraries,
+ 'target_link_options': self._cmake_target_link_options,
+ 'add_dependencies': self._cmake_add_dependencies,
+ 'message': self._cmake_message,
+
+ # Special functions defined in the preload script.
+ # These functions do nothing in the CMake code, but have special
+ # meaning here in the trace parser.
+ 'meson_ps_execute_delayed_calls': self._meson_ps_execute_delayed_calls,
+ 'meson_ps_reload_vars': self._meson_ps_reload_vars,
+ 'meson_ps_disabled_function': self._meson_ps_disabled_function,
+ } # type: T.Dict[str, T.Callable[[CMakeTraceLine], None]]
+
+ if version_compare(self.cmake_version, '<3.17.0'):
+ mlog.deprecation(textwrap.dedent(f'''\
+ CMake support for versions <3.17 is deprecated since Meson 0.62.0.
+ |
+ | However, Meson was only able to find CMake {self.cmake_version}.
+ |
+ | Support for all CMake versions below 3.17.0 will be removed once
+ | newer CMake versions are more widely adopted. If you encounter
+ | any errors please try upgrading CMake to a newer version first.
+ '''), once=True)
+
+ def trace_args(self) -> T.List[str]:
+ arg_map = {
+ 'human': ['--trace', '--trace-expand'],
+ 'json-v1': ['--trace-expand', '--trace-format=json-v1'],
+ }
+
+ base_args = ['--no-warn-unused-cli']
+ if not self.requires_stderr():
+ base_args += [f'--trace-redirect={self.trace_file}']
+
+ return arg_map[self.trace_format] + base_args
+
+ def requires_stderr(self) -> bool:
+ return version_compare(self.cmake_version, '<3.16')
+
+ def parse(self, trace: T.Optional[str] = None) -> None:
+ # First load the trace (if required)
+ if not self.requires_stderr():
+ if not self.trace_file_path.exists and not self.trace_file_path.is_file():
+ raise CMakeException(f'CMake: Trace file "{self.trace_file_path!s}" not found')
+ trace = self.trace_file_path.read_text(errors='ignore', encoding='utf-8')
+ if not trace:
+ raise CMakeException('CMake: The CMake trace was not provided or is empty')
+
+ # Second parse the trace
+ lexer1 = None
+ if self.trace_format == 'human':
+ lexer1 = self._lex_trace_human(trace)
+ elif self.trace_format == 'json-v1':
+ lexer1 = self._lex_trace_json(trace)
+ else:
+ raise CMakeException(f'CMake: Internal error: Invalid trace format {self.trace_format}. Expected [human, json-v1]')
+
+ # Primary pass -- parse everything
+ for l in lexer1:
+ # store the function if its execution should be delayed
+ if l.func in self.delayed_commands:
+ self.stored_commands += [l]
+ continue
+
+ # "Execute" the CMake function if supported
+ fn = self.functions.get(l.func, None)
+ if fn:
+ fn(l)
+
+ # Evaluate generator expressions
+ strlist_gen: T.Callable[[T.List[str]], T.List[str]] = lambda strlist: parse_generator_expressions(';'.join(strlist), self).split(';') if strlist else []
+ pathlist_gen: T.Callable[[T.List[str]], T.List[Path]] = lambda strlist: [Path(x) for x in parse_generator_expressions(';'.join(strlist), self).split(';')] if strlist else []
+
+ self.vars = {k: strlist_gen(v) for k, v in self.vars.items()}
+ self.vars_by_file = {
+ p: {k: strlist_gen(v) for k, v in d.items()}
+ for p, d in self.vars_by_file.items()
+ }
+ self.explicit_headers = {Path(parse_generator_expressions(str(x), self)) for x in self.explicit_headers}
+ self.cache = {
+ k: CMakeCacheEntry(
+ strlist_gen(v.value),
+ v.type
+ )
+ for k, v in self.cache.items()
+ }
+
+ for tgt in self.targets.values():
+ tgtlist_gen: T.Callable[[T.List[str], CMakeTarget], T.List[str]] = lambda strlist, t: parse_generator_expressions(';'.join(strlist), self, context_tgt=t).split(';') if strlist else []
+ tgt.name = parse_generator_expressions(tgt.name, self, context_tgt=tgt)
+ tgt.type = parse_generator_expressions(tgt.type, self, context_tgt=tgt)
+ tgt.properties = {
+ k: tgtlist_gen(v, tgt) for k, v in tgt.properties.items()
+ } if tgt.properties is not None else None
+ tgt.depends = tgtlist_gen(tgt.depends, tgt)
+
+ for ctgt in self.custom_targets:
+ ctgt.outputs = pathlist_gen(ctgt._outputs_str)
+ temp = ctgt.command
+ ctgt.command = [strlist_gen(x) for x in ctgt.command]
+ for command, src in zip(ctgt.command, temp):
+ if command[0] == "":
+ raise CMakeException(
+ "We evaluated the cmake variable '{}' to an empty string, which is not a valid path to an executable.".format(src[0])
+ )
+ ctgt.working_dir = Path(parse_generator_expressions(str(ctgt.working_dir), self)) if ctgt.working_dir is not None else None
+
+ # Postprocess
+ for tgt in self.targets.values():
+ tgt.strip_properties()
+
+ def get_first_cmake_var_of(self, var_list: T.List[str]) -> T.List[str]:
+ # Return the first found CMake variable in list var_list
+ for i in var_list:
+ if i in self.vars:
+ return self.vars[i]
+
+ return []
+
+ def get_cmake_var(self, var: str) -> T.List[str]:
+ # Return the value of the CMake variable var or an empty list if var does not exist
+ if var in self.vars:
+ return self.vars[var]
+
+ return []
+
+ def var_to_str(self, var: str) -> T.Optional[str]:
+ if var in self.vars and self.vars[var]:
+ return self.vars[var][0]
+
+ return None
+
+ def _str_to_bool(self, expr: T.Union[str, T.List[str]]) -> bool:
+ if not expr:
+ return False
+ if isinstance(expr, list):
+ expr_str = expr[0]
+ else:
+ expr_str = expr
+ expr_str = expr_str.upper()
+ return expr_str not in ['0', 'OFF', 'NO', 'FALSE', 'N', 'IGNORE'] and not expr_str.endswith('NOTFOUND')
+
+ def var_to_bool(self, var: str) -> bool:
+ return self._str_to_bool(self.vars.get(var, []))
+
+ def _gen_exception(self, function: str, error: str, tline: CMakeTraceLine) -> None:
+ # Generate an exception if the parser is not in permissive mode
+
+ if self.permissive:
+ mlog.debug(f'CMake trace warning: {function}() {error}\n{tline}')
+ return None
+ raise CMakeException(f'CMake: {function}() {error}\n{tline}')
+
+ def _cmake_set(self, tline: CMakeTraceLine) -> None:
+ """Handler for the CMake set() function in all variaties.
+
+ comes in three flavors:
+ set(<var> <value> [PARENT_SCOPE])
+ set(<var> <value> CACHE <type> <docstring> [FORCE])
+ set(ENV{<var>} <value>)
+
+ We don't support the ENV variant, and any uses of it will be ignored
+ silently. the other two variates are supported, with some caveats:
+ - we don't properly handle scoping, so calls to set() inside a
+ function without PARENT_SCOPE set could incorrectly shadow the
+ outer scope.
+ - We don't honor the type of CACHE arguments
+ """
+ # DOC: https://cmake.org/cmake/help/latest/command/set.html
+
+ cache_type = None
+ cache_force = 'FORCE' in tline.args
+ try:
+ cache_idx = tline.args.index('CACHE')
+ cache_type = tline.args[cache_idx + 1]
+ except (ValueError, IndexError):
+ pass
+
+ # 1st remove PARENT_SCOPE and CACHE from args
+ args = []
+ for i in tline.args:
+ if not i or i == 'PARENT_SCOPE':
+ continue
+
+ # Discard everything after the CACHE keyword
+ if i == 'CACHE':
+ break
+
+ args.append(i)
+
+ if len(args) < 1:
+ return self._gen_exception('set', 'requires at least one argument', tline)
+
+ # Now that we've removed extra arguments all that should be left is the
+ # variable identifier and the value, join the value back together to
+ # ensure spaces in the value are correctly handled. This assumes that
+ # variable names don't have spaces. Please don't do that...
+ identifier = args.pop(0)
+ value = ' '.join(args)
+
+ # Write to the CMake cache instead
+ if cache_type:
+ # Honor how the CMake FORCE parameter works
+ if identifier not in self.cache or cache_force:
+ self.cache[identifier] = CMakeCacheEntry(value.split(';'), cache_type)
+
+ if not value:
+ # Same as unset
+ if identifier in self.vars:
+ del self.vars[identifier]
+ else:
+ self.vars[identifier] = value.split(';')
+ self.vars_by_file.setdefault(tline.file, {})[identifier] = value.split(';')
+
+ def _cmake_unset(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/unset.html
+ if len(tline.args) < 1:
+ return self._gen_exception('unset', 'requires at least one argument', tline)
+
+ if tline.args[0] in self.vars:
+ del self.vars[tline.args[0]]
+
+ def _cmake_add_executable(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/add_executable.html
+ args = list(tline.args) # Make a working copy
+
+ # Make sure the exe is imported
+ is_imported = True
+ if 'IMPORTED' not in args:
+ return self._gen_exception('add_executable', 'non imported executables are not supported', tline)
+
+ args.remove('IMPORTED')
+
+ if len(args) < 1:
+ return self._gen_exception('add_executable', 'requires at least 1 argument', tline)
+
+ self.targets[args[0]] = CMakeTarget(args[0], 'EXECUTABLE', {}, tline=tline, imported=is_imported)
+
+ def _cmake_add_library(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/add_library.html
+ args = list(tline.args) # Make a working copy
+
+ # Make sure the lib is imported
+ if 'INTERFACE' in args:
+ args.remove('INTERFACE')
+
+ if len(args) < 1:
+ return self._gen_exception('add_library', 'interface library name not specified', tline)
+
+ self.targets[args[0]] = CMakeTarget(args[0], 'INTERFACE', {}, tline=tline, imported='IMPORTED' in args)
+ elif 'IMPORTED' in args:
+ args.remove('IMPORTED')
+
+ # Now, only look at the first two arguments (target_name and target_type) and ignore the rest
+ if len(args) < 2:
+ return self._gen_exception('add_library', 'requires at least 2 arguments', tline)
+
+ self.targets[args[0]] = CMakeTarget(args[0], args[1], {}, tline=tline, imported=True)
+ elif 'ALIAS' in args:
+ args.remove('ALIAS')
+
+ # Now, only look at the first two arguments (target_name and target_ref) and ignore the rest
+ if len(args) < 2:
+ return self._gen_exception('add_library', 'requires at least 2 arguments', tline)
+
+ # Simulate the ALIAS with INTERFACE_LINK_LIBRARIES
+ self.targets[args[0]] = CMakeTarget(args[0], 'ALIAS', {'INTERFACE_LINK_LIBRARIES': [args[1]]}, tline=tline)
+ elif 'OBJECT' in args:
+ return self._gen_exception('add_library', 'OBJECT libraries are not supported', tline)
+ else:
+ self.targets[args[0]] = CMakeTarget(args[0], 'NORMAL', {}, tline=tline)
+
+ def _cmake_add_custom_command(self, tline: CMakeTraceLine, name: T.Optional[str] = None) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/add_custom_command.html
+ args = self._flatten_args(list(tline.args)) # Commands can be passed as ';' separated lists
+
+ if not args:
+ return self._gen_exception('add_custom_command', 'requires at least 1 argument', tline)
+
+ # Skip the second function signature
+ if args[0] == 'TARGET':
+ return self._gen_exception('add_custom_command', 'TARGET syntax is currently not supported', tline)
+
+ magic_keys = ['OUTPUT', 'COMMAND', 'MAIN_DEPENDENCY', 'DEPENDS', 'BYPRODUCTS',
+ 'IMPLICIT_DEPENDS', 'WORKING_DIRECTORY', 'COMMENT', 'DEPFILE',
+ 'JOB_POOL', 'VERBATIM', 'APPEND', 'USES_TERMINAL', 'COMMAND_EXPAND_LISTS']
+
+ target = CMakeGeneratorTarget(name)
+
+ def handle_output(key: str, target: CMakeGeneratorTarget) -> None:
+ target._outputs_str += [key]
+
+ def handle_command(key: str, target: CMakeGeneratorTarget) -> None:
+ if key == 'ARGS':
+ return
+ target.command[-1] += [key]
+
+ def handle_depends(key: str, target: CMakeGeneratorTarget) -> None:
+ target.depends += [key]
+
+ working_dir = None
+
+ def handle_working_dir(key: str, target: CMakeGeneratorTarget) -> None:
+ nonlocal working_dir
+ if working_dir is None:
+ working_dir = key
+ else:
+ working_dir += ' '
+ working_dir += key
+
+ fn = None
+
+ for i in args:
+ if i in magic_keys:
+ if i == 'OUTPUT':
+ fn = handle_output
+ elif i == 'DEPENDS':
+ fn = handle_depends
+ elif i == 'WORKING_DIRECTORY':
+ fn = handle_working_dir
+ elif i == 'COMMAND':
+ fn = handle_command
+ target.command += [[]]
+ else:
+ fn = None
+ continue
+
+ if fn is not None:
+ fn(i, target)
+
+ cbinary_dir = self.var_to_str('MESON_PS_CMAKE_CURRENT_BINARY_DIR')
+ csource_dir = self.var_to_str('MESON_PS_CMAKE_CURRENT_SOURCE_DIR')
+
+ target.working_dir = Path(working_dir) if working_dir else None
+ target.current_bin_dir = Path(cbinary_dir) if cbinary_dir else None
+ target.current_src_dir = Path(csource_dir) if csource_dir else None
+ target._outputs_str = self._guess_files(target._outputs_str)
+ target.depends = self._guess_files(target.depends)
+ target.command = [self._guess_files(x) for x in target.command]
+
+ self.custom_targets += [target]
+ if name:
+ self.targets[name] = target
+
+ def _cmake_add_custom_target(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/add_custom_target.html
+ # We only the first parameter (the target name) is interesting
+ if len(tline.args) < 1:
+ return self._gen_exception('add_custom_target', 'requires at least one argument', tline)
+
+ # It's pretty much the same as a custom command
+ self._cmake_add_custom_command(tline, tline.args[0])
+
+ def _cmake_set_property(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/set_property.html
+ args = list(tline.args)
+
+ scope = args.pop(0)
+
+ append = False
+ targets = []
+ while args:
+ curr = args.pop(0)
+ # XXX: APPEND_STRING is specifically *not* supposed to create a
+ # list, is treating them as aliases really okay?
+ if curr in {'APPEND', 'APPEND_STRING'}:
+ append = True
+ continue
+
+ if curr == 'PROPERTY':
+ break
+
+ targets += curr.split(';')
+
+ if not args:
+ return self._gen_exception('set_property', 'faild to parse argument list', tline)
+
+ if len(args) == 1:
+ # Tries to set property to nothing so nothing has to be done
+ return
+
+ identifier = args.pop(0)
+ if self.trace_format == 'human':
+ value = ' '.join(args).split(';')
+ else:
+ value = [y for x in args for y in x.split(';')]
+ if not value:
+ return
+
+ def do_target(t: str) -> None:
+ if t not in self.targets:
+ return self._gen_exception('set_property', f'TARGET {t} not found', tline)
+
+ tgt = self.targets[t]
+ if identifier not in tgt.properties:
+ tgt.properties[identifier] = []
+
+ if append:
+ tgt.properties[identifier] += value
+ else:
+ tgt.properties[identifier] = value
+
+ def do_source(src: str) -> None:
+ if identifier != 'HEADER_FILE_ONLY' or not self._str_to_bool(value):
+ return
+
+ current_src_dir = self.var_to_str('MESON_PS_CMAKE_CURRENT_SOURCE_DIR')
+ if not current_src_dir:
+ mlog.warning(textwrap.dedent('''\
+ CMake trace: set_property(SOURCE) called before the preload script was loaded.
+ Unable to determine CMAKE_CURRENT_SOURCE_DIR. This can lead to build errors.
+ '''))
+ current_src_dir = '.'
+
+ cur_p = Path(current_src_dir)
+ src_p = Path(src)
+
+ if not src_p.is_absolute():
+ src_p = cur_p / src_p
+ self.explicit_headers.add(src_p)
+
+ if scope == 'TARGET':
+ for i in targets:
+ do_target(i)
+ elif scope == 'SOURCE':
+ files = self._guess_files(targets)
+ for i in files:
+ do_source(i)
+
+ def _cmake_set_target_properties(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/set_target_properties.html
+ args = list(tline.args)
+
+ targets = []
+ while args:
+ curr = args.pop(0)
+ if curr == 'PROPERTIES':
+ break
+
+ targets.append(curr)
+
+ # Now we need to try to reconsitute the original quoted format of the
+ # arguments, as a property value could have spaces in it. Unlike
+ # set_property() this is not context free. There are two approaches I
+ # can think of, both have drawbacks:
+ #
+ # 1. Assume that the property will be capitalized ([A-Z_]), this is
+ # convention but cmake doesn't require it.
+ # 2. Maintain a copy of the list here: https://cmake.org/cmake/help/latest/manual/cmake-properties.7.html#target-properties
+ #
+ # Neither of these is awesome for obvious reasons. I'm going to try
+ # option 1 first and fall back to 2, as 1 requires less code and less
+ # synchroniztion for cmake changes.
+ #
+ # With the JSON output format, introduced in CMake 3.17, spaces are
+ # handled properly and we don't have to do either options
+
+ arglist = [] # type: T.List[T.Tuple[str, T.List[str]]]
+ if self.trace_format == 'human':
+ name = args.pop(0)
+ values = [] # type: T.List[str]
+ prop_regex = re.compile(r'^[A-Z_]+$')
+ for a in args:
+ if prop_regex.match(a):
+ if values:
+ arglist.append((name, ' '.join(values).split(';')))
+ name = a
+ values = []
+ else:
+ values.append(a)
+ if values:
+ arglist.append((name, ' '.join(values).split(';')))
+ else:
+ arglist = [(x[0], x[1].split(';')) for x in zip(args[::2], args[1::2])]
+
+ for name, value in arglist:
+ for i in targets:
+ if i not in self.targets:
+ return self._gen_exception('set_target_properties', f'TARGET {i} not found', tline)
+
+ self.targets[i].properties[name] = value
+
+ def _cmake_add_dependencies(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/add_dependencies.html
+ args = list(tline.args)
+
+ if len(args) < 2:
+ return self._gen_exception('add_dependencies', 'takes at least 2 arguments', tline)
+
+ target = self.targets.get(args[0])
+ if not target:
+ return self._gen_exception('add_dependencies', 'target not found', tline)
+
+ for i in args[1:]:
+ target.depends += i.split(';')
+
+ def _cmake_target_compile_definitions(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/target_compile_definitions.html
+ self._parse_common_target_options('target_compile_definitions', 'COMPILE_DEFINITIONS', 'INTERFACE_COMPILE_DEFINITIONS', tline)
+
+ def _cmake_target_compile_options(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/target_compile_options.html
+ self._parse_common_target_options('target_compile_options', 'COMPILE_OPTIONS', 'INTERFACE_COMPILE_OPTIONS', tline)
+
+ def _cmake_target_include_directories(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/target_include_directories.html
+ self._parse_common_target_options('target_include_directories', 'INCLUDE_DIRECTORIES', 'INTERFACE_INCLUDE_DIRECTORIES', tline, ignore=['SYSTEM', 'BEFORE'], paths=True)
+
+ def _cmake_target_link_options(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/target_link_options.html
+ self._parse_common_target_options('target_link_options', 'LINK_OPTIONS', 'INTERFACE_LINK_OPTIONS', tline)
+
+ def _cmake_target_link_libraries(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/target_link_libraries.html
+ self._parse_common_target_options('target_link_options', 'LINK_LIBRARIES', 'INTERFACE_LINK_LIBRARIES', tline)
+
+ def _cmake_message(self, tline: CMakeTraceLine) -> None:
+ # DOC: https://cmake.org/cmake/help/latest/command/message.html
+ args = list(tline.args)
+
+ if len(args) < 1:
+ return self._gen_exception('message', 'takes at least 1 argument', tline)
+
+ if args[0].upper().strip() not in ['FATAL_ERROR', 'SEND_ERROR']:
+ return
+
+ self.errors += [' '.join(args[1:])]
+
+ def _parse_common_target_options(self, func: str, private_prop: str, interface_prop: str, tline: CMakeTraceLine, ignore: T.Optional[T.List[str]] = None, paths: bool = False) -> None:
+ if ignore is None:
+ ignore = ['BEFORE']
+
+ args = list(tline.args)
+
+ if len(args) < 1:
+ return self._gen_exception(func, 'requires at least one argument', tline)
+
+ target = args[0]
+ if target not in self.targets:
+ return self._gen_exception(func, f'TARGET {target} not found', tline)
+
+ interface = []
+ private = []
+
+ mode = 'PUBLIC'
+ for i in args[1:]:
+ if i in ignore:
+ continue
+
+ if i in {'INTERFACE', 'LINK_INTERFACE_LIBRARIES', 'PUBLIC', 'PRIVATE', 'LINK_PUBLIC', 'LINK_PRIVATE'}:
+ mode = i
+ continue
+
+ if mode in {'INTERFACE', 'LINK_INTERFACE_LIBRARIES', 'PUBLIC', 'LINK_PUBLIC'}:
+ interface += i.split(';')
+
+ if mode in {'PUBLIC', 'PRIVATE', 'LINK_PRIVATE'}:
+ private += i.split(';')
+
+ if paths:
+ interface = self._guess_files(interface)
+ private = self._guess_files(private)
+
+ interface = [x for x in interface if x]
+ private = [x for x in private if x]
+
+ for j in [(private_prop, private), (interface_prop, interface)]:
+ if not j[0] in self.targets[target].properties:
+ self.targets[target].properties[j[0]] = []
+
+ self.targets[target].properties[j[0]] += j[1]
+
+ def _meson_ps_execute_delayed_calls(self, tline: CMakeTraceLine) -> None:
+ for l in self.stored_commands:
+ fn = self.functions.get(l.func, None)
+ if fn:
+ fn(l)
+
+ # clear the stored commands
+ self.stored_commands = []
+
+ def _meson_ps_reload_vars(self, tline: CMakeTraceLine) -> None:
+ self.delayed_commands = self.get_cmake_var('MESON_PS_DELAYED_CALLS')
+
+ def _meson_ps_disabled_function(self, tline: CMakeTraceLine) -> None:
+ args = list(tline.args)
+ if not args:
+ mlog.error('Invalid preload.cmake script! At least one argument to `meson_ps_disabled_function` is expected')
+ return
+ mlog.warning(f'The CMake function "{args[0]}" was disabled to avoid compatibility issues with Meson.')
+
+ def _lex_trace_human(self, trace: str) -> T.Generator[CMakeTraceLine, None, None]:
+ # The trace format is: '<file>(<line>): <func>(<args -- can contain \n> )\n'
+ reg_tline = re.compile(r'\s*(.*\.(cmake|txt))\(([0-9]+)\):\s*(\w+)\(([\s\S]*?) ?\)\s*\n', re.MULTILINE)
+ reg_other = re.compile(r'[^\n]*\n')
+ loc = 0
+ while loc < len(trace):
+ mo_file_line = reg_tline.match(trace, loc)
+ if not mo_file_line:
+ skip_match = reg_other.match(trace, loc)
+ if not skip_match:
+ print(trace[loc:])
+ raise CMakeException('Failed to parse CMake trace')
+
+ loc = skip_match.end()
+ continue
+
+ loc = mo_file_line.end()
+
+ file = mo_file_line.group(1)
+ line = mo_file_line.group(3)
+ func = mo_file_line.group(4)
+ args = mo_file_line.group(5)
+ argl = args.split(' ')
+ argl = [a.strip() for a in argl]
+
+ yield CMakeTraceLine(file, int(line), func, argl)
+
+ def _lex_trace_json(self, trace: str) -> T.Generator[CMakeTraceLine, None, None]:
+ lines = trace.splitlines(keepends=False)
+ lines.pop(0) # The first line is the version
+ for i in lines:
+ data = json.loads(i)
+ assert isinstance(data['file'], str)
+ assert isinstance(data['line'], int)
+ assert isinstance(data['cmd'], str)
+ assert isinstance(data['args'], list)
+ args = data['args']
+ for j in args:
+ assert isinstance(j, str)
+ yield CMakeTraceLine(data['file'], data['line'], data['cmd'], args)
+
+ def _flatten_args(self, args: T.List[str]) -> T.List[str]:
+ # Split lists in arguments
+ res = [] # type: T.List[str]
+ for i in args:
+ res += i.split(';')
+ return res
+
+ def _guess_files(self, broken_list: T.List[str]) -> T.List[str]:
+ # Nothing has to be done for newer formats
+ if self.trace_format != 'human':
+ return broken_list
+
+ # Try joining file paths that contain spaces
+
+ reg_start = re.compile(r'^([A-Za-z]:)?/(.*/)*[^./]+$')
+ reg_end = re.compile(r'^.*\.[a-zA-Z]+$')
+
+ fixed_list = [] # type: T.List[str]
+ curr_str = None # type: T.Optional[str]
+ path_found = False # type: bool
+
+ for i in broken_list:
+ if curr_str is None:
+ curr_str = i
+ path_found = False
+ elif Path(curr_str).is_file():
+ # Abort concatenation if curr_str is an existing file
+ fixed_list += [curr_str]
+ curr_str = i
+ path_found = False
+ elif not reg_start.match(curr_str):
+ # Abort concatenation if curr_str no longer matches the regex
+ fixed_list += [curr_str]
+ curr_str = i
+ path_found = False
+ elif reg_end.match(i):
+ # File detected
+ curr_str = f'{curr_str} {i}'
+ fixed_list += [curr_str]
+ curr_str = None
+ path_found = False
+ elif Path(f'{curr_str} {i}').exists():
+ # Path detected
+ curr_str = f'{curr_str} {i}'
+ path_found = True
+ elif path_found:
+ # Add path to fixed_list after ensuring the whole path is in curr_str
+ fixed_list += [curr_str]
+ curr_str = i
+ path_found = False
+ else:
+ curr_str = f'{curr_str} {i}'
+ path_found = False
+
+ if curr_str:
+ fixed_list += [curr_str]
+ return fixed_list
diff --git a/mesonbuild/cmake/tracetargets.py b/mesonbuild/cmake/tracetargets.py
new file mode 100644
index 0000000..338364d
--- /dev/null
+++ b/mesonbuild/cmake/tracetargets.py
@@ -0,0 +1,119 @@
+# SPDX-License-Identifer: Apache-2.0
+# Copyright 2021 The Meson development team
+from __future__ import annotations
+
+from .common import cmake_is_debug
+from .. import mlog
+
+from pathlib import Path
+import re
+import typing as T
+
+if T.TYPE_CHECKING:
+ from .traceparser import CMakeTraceParser
+ from ..environment import Environment
+ from ..compilers import Compiler
+ from ..dependencies import MissingCompiler
+
+class ResolvedTarget:
+ def __init__(self) -> None:
+ self.include_directories: T.List[str] = []
+ self.link_flags: T.List[str] = []
+ self.public_compile_opts: T.List[str] = []
+ self.libraries: T.List[str] = []
+
+def resolve_cmake_trace_targets(target_name: str,
+ trace: 'CMakeTraceParser',
+ env: 'Environment',
+ *,
+ clib_compiler: T.Union['MissingCompiler', 'Compiler'] = None,
+ not_found_warning: T.Callable[[str], None] = lambda x: None) -> ResolvedTarget:
+ res = ResolvedTarget()
+ targets = [target_name]
+
+ # recognise arguments we should pass directly to the linker
+ reg_is_lib = re.compile(r'^(-l[a-zA-Z0-9_]+|-l?pthread)$')
+ reg_is_maybe_bare_lib = re.compile(r'^[a-zA-Z0-9_]+$')
+
+ is_debug = cmake_is_debug(env)
+
+ processed_targets: T.List[str] = []
+ while len(targets) > 0:
+ curr = targets.pop(0)
+
+ # Skip already processed targets
+ if curr in processed_targets:
+ continue
+
+ if curr not in trace.targets:
+ if reg_is_lib.match(curr):
+ res.libraries += [curr]
+ elif Path(curr).is_absolute() and Path(curr).exists():
+ res.libraries += [curr]
+ elif env.machines.build.is_windows() and reg_is_maybe_bare_lib.match(curr) and clib_compiler:
+ # On Windows, CMake library dependencies can be passed as bare library names,
+ # CMake brute-forces a combination of prefix/suffix combinations to find the
+ # right library. Assume any bare argument passed which is not also a CMake
+ # target must be a system library we should try to link against.
+ res.libraries += clib_compiler.find_library(curr, env, [])
+ else:
+ not_found_warning(curr)
+ continue
+
+ tgt = trace.targets[curr]
+ cfgs = []
+ cfg = ''
+ mlog.debug(tgt)
+
+ if 'INTERFACE_INCLUDE_DIRECTORIES' in tgt.properties:
+ res.include_directories += [x for x in tgt.properties['INTERFACE_INCLUDE_DIRECTORIES'] if x]
+
+ if 'INTERFACE_LINK_OPTIONS' in tgt.properties:
+ res.link_flags += [x for x in tgt.properties['INTERFACE_LINK_OPTIONS'] if x]
+
+ if 'INTERFACE_COMPILE_DEFINITIONS' in tgt.properties:
+ res.public_compile_opts += ['-D' + re.sub('^-D', '', x) for x in tgt.properties['INTERFACE_COMPILE_DEFINITIONS'] if x]
+
+ if 'INTERFACE_COMPILE_OPTIONS' in tgt.properties:
+ res.public_compile_opts += [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 is_debug:
+ if 'DEBUG' in cfgs:
+ cfg = 'DEBUG'
+ elif 'RELEASE' in cfgs:
+ cfg = 'RELEASE'
+ else:
+ if 'RELEASE' in cfgs:
+ cfg = 'RELEASE'
+
+ if f'IMPORTED_IMPLIB_{cfg}' in tgt.properties:
+ res.libraries += [x for x in tgt.properties[f'IMPORTED_IMPLIB_{cfg}'] if x]
+ elif 'IMPORTED_IMPLIB' in tgt.properties:
+ res.libraries += [x for x in tgt.properties['IMPORTED_IMPLIB'] if x]
+ elif f'IMPORTED_LOCATION_{cfg}' in tgt.properties:
+ res.libraries += [x for x in tgt.properties[f'IMPORTED_LOCATION_{cfg}'] if x]
+ elif 'IMPORTED_LOCATION' in tgt.properties:
+ res.libraries += [x for x in tgt.properties['IMPORTED_LOCATION'] if x]
+
+ if 'LINK_LIBRARIES' in tgt.properties:
+ targets += [x for x in tgt.properties['LINK_LIBRARIES'] if x]
+ if 'INTERFACE_LINK_LIBRARIES' in tgt.properties:
+ targets += [x for x in tgt.properties['INTERFACE_LINK_LIBRARIES'] if x]
+
+ if f'IMPORTED_LINK_DEPENDENT_LIBRARIES_{cfg}' in tgt.properties:
+ targets += [x for x in tgt.properties[f'IMPORTED_LINK_DEPENDENT_LIBRARIES_{cfg}'] if x]
+ elif 'IMPORTED_LINK_DEPENDENT_LIBRARIES' in tgt.properties:
+ targets += [x for x in tgt.properties['IMPORTED_LINK_DEPENDENT_LIBRARIES'] if x]
+
+ processed_targets += [curr]
+
+ res.include_directories = sorted(set(res.include_directories))
+ res.link_flags = sorted(set(res.link_flags))
+ res.public_compile_opts = sorted(set(res.public_compile_opts))
+ res.libraries = sorted(set(res.libraries))
+
+ return res
generated by cgit v1.2.3 (git 2.39.1) at 2024-10-02 11:20:35 +0000