| # SPDX-License-Identifier: Apache-2.0 |
| # Copyright 2019 The Meson development team |
| |
| 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 |
| from ..interpreterbase import TYPE_var |
| |
| 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.optstore: |
| is_debug = env.coredata.get_option(OptionKey('buildtype')) == 'debug' |
| if env.coredata.optstore.get_value('b_vscrt') 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.List[T.Dict[str, TYPE_var]], permissive: bool = False) -> T.List[str]: |
| res: T.List[str] = [] |
| |
| for i in raw: |
| for key, val in i.items(): |
| 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 function will become obsolete once the `cmake_args` kwarg is dropped |
| def check_cmake_args(args: T.List[str]) -> T.List[str]: |
| res: 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: str = data.get('defines', '') |
| self.flags = _flags_to_list(data.get('compileFlags', '')) |
| self.is_generated: bool = data.get('isGenerated', False) |
| self.language: str = data.get('language', 'C') |
| self.sources = [Path(x) for x in data.get('sources', [])] |
| |
| # Fix the include directories |
| self.includes: 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', [])] |
| self.src_dir = Path(data.get('sourceDirectory', '')) |
| self.build_dir = Path(data.get('buildDirectory', '')) |
| self.name: str = data.get('name', '') |
| self.full_name: str = data.get('fullName', '') |
| self.install: bool = data.get('hasInstallRule', False) |
| self.install_paths = [Path(x) for x in set(data.get('installPaths', []))] |
| self.link_lang: str = data.get('linkerLanguage', '') |
| self.link_libraries = _flags_to_list(data.get('linkLibraries', '')) |
| self.link_flags = _flags_to_list(data.get('linkFlags', '')) |
| self.link_lang_flags = _flags_to_list(data.get('linkLanguageFlags', '')) |
| # self.link_path = Path(data.get('linkPath', '')) |
| self.type: str = data.get('type', 'EXECUTABLE') |
| # self.is_generator_provided: bool = data.get('isGeneratorProvided', False) |
| self.files: 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', '')) |
| self.build_dir = Path(data.get('buildDirectory', '')) |
| self.name: str = data.get('name', '') |
| self.targets: 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: str = data.get('name', '') |
| self.projects: 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: T.Dict[str, str] = {} |
| self.lang_args: T.Dict[str, T.List[str]] = {} |
| self.link_args: 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: 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: 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 |