| # SPDX-License-Identifier: Apache-2.0 | |
| # Copyright 2019 The Meson development team | |
| # 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: T.List[str] = [] | |
| self.current_bin_dir: T.Optional[Path] = None | |
| self.current_src_dir: T.Optional[Path] = None | |
| 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: T.List[Path] = [] | |
| self._outputs_str: T.List[str] = [] | |
| self.command: T.List[T.List[str]] = [] | |
| self.working_dir: T.Optional[Path] = None | |
| 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: T.Set[Path] = set() | |
| # T.List of targes that were added with add_custom_command to generate files | |
| self.custom_targets: T.List[CMakeGeneratorTarget] = [] | |
| self.env = env | |
| self.permissive = permissive | |
| self.cmake_version = cmake_version | |
| 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: T.List[str] = [] | |
| self.stored_commands: T.List[CMakeTraceLine] = [] | |
| # All supported functions | |
| self.functions: T.Dict[str, T.Callable[[CMakeTraceLine], None]] = { | |
| '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, | |
| } | |
| 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 varieties. | |
| 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', 'failed 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 reconstitute 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 | |
| # synchronization 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: T.List[T.Tuple[str, T.List[str]]] = [] | |
| if self.trace_format == 'human': | |
| name = args.pop(0) | |
| values: 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: 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: T.List[str] = [] | |
| curr_str: T.Optional[str] = None | |
| path_found = False | |
| 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 |