# Copyright 2012-2021 The Meson development team # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # http://www.apache.org/licenses/LICENSE-2.0 # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. from __future__ import annotations from .. import mparser from .. import environment from .. import coredata from .. import dependencies from .. import mlog from .. import build from .. import optinterpreter from .. import compilers from .. import envconfig from ..wrap import wrap, WrapMode from .. import mesonlib from ..mesonlib import (MesonBugException, MesonException, HoldableObject, FileMode, MachineChoice, OptionKey, listify, extract_as_list, has_path_sep, PerMachine) from ..programs import ExternalProgram, NonExistingExternalProgram from ..dependencies import Dependency from ..depfile import DepFile from ..interpreterbase import ContainerTypeInfo, InterpreterBase, KwargInfo, typed_kwargs, typed_pos_args from ..interpreterbase import noPosargs, noKwargs, permittedKwargs, noArgsFlattening, noSecondLevelHolderResolving, unholder_return from ..interpreterbase import InterpreterException, InvalidArguments, InvalidCode, SubdirDoneRequest from ..interpreterbase import Disabler, disablerIfNotFound from ..interpreterbase import FeatureNew, FeatureDeprecated, FeatureBroken, FeatureNewKwargs, FeatureDeprecatedKwargs from ..interpreterbase import ObjectHolder, ContextManagerObject from ..modules import ExtensionModule, ModuleObject, MutableModuleObject, NewExtensionModule, NotFoundExtensionModule from ..cmake import CMakeInterpreter from ..backend.backends import ExecutableSerialisation from . import interpreterobjects as OBJ from . import compiler as compilerOBJ from .mesonmain import MesonMain from .dependencyfallbacks import DependencyFallbacksHolder from .interpreterobjects import ( SubprojectHolder, Test, RunProcess, extract_required_kwarg, extract_search_dirs, NullSubprojectInterpreter, ) from .type_checking import ( COMMAND_KW, CT_BUILD_ALWAYS, CT_BUILD_ALWAYS_STALE, CT_BUILD_BY_DEFAULT, CT_INPUT_KW, CT_INSTALL_DIR_KW, MULTI_OUTPUT_KW, OUTPUT_KW, DEFAULT_OPTIONS, DEPENDENCIES_KW, DEPENDS_KW, DEPEND_FILES_KW, DEPFILE_KW, DISABLER_KW, D_MODULE_VERSIONS_KW, ENV_KW, ENV_METHOD_KW, ENV_SEPARATOR_KW, INCLUDE_DIRECTORIES, INSTALL_KW, INSTALL_DIR_KW, INSTALL_MODE_KW, LINK_WITH_KW, LINK_WHOLE_KW, CT_INSTALL_TAG_KW, INSTALL_TAG_KW, LANGUAGE_KW, NATIVE_KW, PRESERVE_PATH_KW, REQUIRED_KW, SOURCES_KW, VARIABLES_KW, TEST_KWS, NoneType, in_set_validator, env_convertor_with_method ) from . import primitives as P_OBJ from pathlib import Path from enum import Enum import os import shutil import uuid import re import stat import collections import typing as T import textwrap import importlib import copy if T.TYPE_CHECKING: import argparse from typing_extensions import Literal from . import kwargs as kwtypes from ..backend.backends import Backend from ..interpreterbase.baseobjects import InterpreterObject, TYPE_var, TYPE_kwargs from ..programs import OverrideProgram # Input source types passed to Targets SourceInputs = T.Union[mesonlib.File, build.GeneratedList, build.BuildTarget, build.BothLibraries, build.CustomTargetIndex, build.CustomTarget, build.GeneratedList, build.ExtractedObjects, str] # Input source types passed to the build.Target classes SourceOutputs = T.Union[mesonlib.File, build.GeneratedList, build.BuildTarget, build.CustomTargetIndex, build.CustomTarget, build.ExtractedObjects, build.GeneratedList, build.StructuredSources] BuildTargetSource = T.Union[mesonlib.FileOrString, build.GeneratedTypes, build.StructuredSources] def _project_version_validator(value: T.Union[T.List, str, mesonlib.File, None]) -> T.Optional[str]: if isinstance(value, list): if len(value) != 1: return 'when passed as array must have a length of 1' elif not isinstance(value[0], mesonlib.File): return 'when passed as array must contain a File' return None def stringifyUserArguments(args: T.List[T.Any], quote: bool = False) -> str: if isinstance(args, list): return '[%s]' % ', '.join([stringifyUserArguments(x, True) for x in args]) elif isinstance(args, dict): return '{%s}' % ', '.join(['{} : {}'.format(stringifyUserArguments(k, True), stringifyUserArguments(v, True)) for k, v in args.items()]) elif isinstance(args, bool): return 'true' if args else 'false' elif isinstance(args, int): return str(args) elif isinstance(args, str): return f"'{args}'" if quote else args raise InvalidArguments('Function accepts only strings, integers, bools, lists, dictionaries and lists thereof.') class Summary: def __init__(self, project_name: str, project_version: str): self.project_name = project_name self.project_version = project_version self.sections = collections.defaultdict(dict) self.max_key_len = 0 def add_section(self, section: str, values: T.Dict[str, T.Any], bool_yn: bool, list_sep: T.Optional[str], subproject: str) -> None: for k, v in values.items(): if k in self.sections[section]: raise InterpreterException(f'Summary section {section!r} already have key {k!r}') formatted_values = [] for i in listify(v): if isinstance(i, bool) and bool_yn: formatted_values.append(mlog.green('YES') if i else mlog.red('NO')) elif isinstance(i, (str, int, bool)): formatted_values.append(str(i)) elif isinstance(i, (ExternalProgram, Dependency)): FeatureNew.single_use('dependency or external program in summary', '0.57.0', subproject) formatted_values.append(i.summary_value()) elif isinstance(i, Disabler): FeatureNew.single_use('disabler in summary', '0.64.0', subproject) formatted_values.append(mlog.red('NO')) elif isinstance(i, coredata.UserOption): FeatureNew.single_use('feature option in summary', '0.58.0', subproject) formatted_values.append(i.printable_value()) else: m = 'Summary value in section {!r}, key {!r}, must be string, integer, boolean, dependency, disabler, or external program' raise InterpreterException(m.format(section, k)) self.sections[section][k] = (formatted_values, list_sep) self.max_key_len = max(self.max_key_len, len(k)) def dump(self): mlog.log(self.project_name, mlog.normal_cyan(self.project_version)) for section, values in self.sections.items(): mlog.log('') # newline if section: mlog.log(' ', mlog.bold(section)) for k, v in values.items(): v, list_sep = v padding = self.max_key_len - len(k) end = ' ' if v else '' mlog.log(' ' * 3, k + ' ' * padding + ':', end=end) indent = self.max_key_len + 6 self.dump_value(v, list_sep, indent) mlog.log('') # newline def dump_value(self, arr, list_sep, indent): lines_sep = '\n' + ' ' * indent if list_sep is None: mlog.log(*arr, sep=lines_sep) return max_len = shutil.get_terminal_size().columns line = [] line_len = indent lines_sep = list_sep.rstrip() + lines_sep for v in arr: v_len = len(v) + len(list_sep) if line and line_len + v_len > max_len: mlog.log(*line, sep=list_sep, end=lines_sep) line_len = indent line = [] line.append(v) line_len += v_len mlog.log(*line, sep=list_sep) known_library_kwargs = ( build.known_shlib_kwargs | build.known_stlib_kwargs ) known_build_target_kwargs = ( known_library_kwargs | build.known_exe_kwargs | build.known_jar_kwargs | {'target_type'} ) class InterpreterRuleRelaxation(Enum): ''' Defines specific relaxations of the Meson rules. This is intended to be used for automatically converted projects (CMake subprojects, build system mixing) that generate a Meson AST via introspection, etc. ''' ALLOW_BUILD_DIR_FILE_REFERENCES = 1 permitted_dependency_kwargs = { 'allow_fallback', 'cmake_args', 'cmake_module_path', 'cmake_package_version', 'components', 'default_options', 'fallback', 'include_type', 'language', 'main', 'method', 'modules', 'native', 'not_found_message', 'optional_modules', 'private_headers', 'required', 'static', 'version', } implicit_check_false_warning = """You should add the boolean check kwarg to the run_command call. It currently defaults to false, but it will default to true in future releases of meson. See also: https://github.com/mesonbuild/meson/issues/9300""" class Interpreter(InterpreterBase, HoldableObject): def __init__( self, _build: build.Build, backend: T.Optional[Backend] = None, subproject: str = '', subdir: str = '', subproject_dir: str = 'subprojects', default_project_options: T.Optional[T.Dict[OptionKey, str]] = None, mock: bool = False, ast: T.Optional[mparser.CodeBlockNode] = None, is_translated: bool = False, relaxations: T.Optional[T.Set[InterpreterRuleRelaxation]] = None, user_defined_options: T.Optional['argparse.Namespace'] = None, ) -> None: super().__init__(_build.environment.get_source_dir(), subdir, subproject) self.active_projectname = '' self.build = _build self.environment = self.build.environment self.coredata = self.environment.get_coredata() self.backend = backend self.summary: T.Dict[str, 'Summary'] = {} self.modules: T.Dict[str, NewExtensionModule] = {} # Subproject directory is usually the name of the subproject, but can # be different for dependencies provided by wrap files. self.subproject_directory_name = subdir.split(os.path.sep)[-1] self.subproject_dir = subproject_dir self.relaxations = relaxations or set() if not mock and ast is None: self.load_root_meson_file() self.sanity_check_ast() elif ast is not None: self.ast = ast self.sanity_check_ast() self.builtin.update({'meson': MesonMain(self.build, self)}) self.generators: T.List[build.Generator] = [] self.processed_buildfiles = set() # type: T.Set[str] self.project_args_frozen = False self.global_args_frozen = False # implies self.project_args_frozen self.subprojects: T.Dict[str, SubprojectHolder] = {} self.subproject_stack: T.List[str] = [] self.configure_file_outputs: T.Dict[str, int] = {} # Passed from the outside, only used in subprojects. if default_project_options: self.default_project_options = default_project_options.copy() else: self.default_project_options = {} self.project_default_options: T.Dict[OptionKey, str] = {} self.build_func_dict() self.build_holder_map() self.user_defined_options = user_defined_options self.compilers: PerMachine[T.Dict[str, 'compilers.Compiler']] = PerMachine({}, {}) # build_def_files needs to be defined before parse_project is called # # For non-meson subprojects, we'll be using the ast. Even if it does # exist we don't want to add a dependency on it, it's autogenerated # from the actual build files, and is just for reference. self.build_def_files: mesonlib.OrderedSet[str] = mesonlib.OrderedSet() build_filename = os.path.join(self.subdir, environment.build_filename) if not is_translated: self.build_def_files.add(build_filename) if not mock: self.parse_project() self._redetect_machines() def __getnewargs_ex__(self) -> T.Tuple[T.Tuple[object], T.Dict[str, object]]: raise MesonBugException('This class is unpicklable') def _redetect_machines(self) -> None: # Re-initialize machine descriptions. We can do a better job now because we # have the compilers needed to gain more knowledge, so wipe out old # inference and start over. machines = self.build.environment.machines.miss_defaulting() machines.build = environment.detect_machine_info(self.coredata.compilers.build) self.build.environment.machines = machines.default_missing() assert self.build.environment.machines.build.cpu is not None assert self.build.environment.machines.host.cpu is not None assert self.build.environment.machines.target.cpu is not None self.builtin['build_machine'] = \ OBJ.MachineHolder(self.build.environment.machines.build, self) self.builtin['host_machine'] = \ OBJ.MachineHolder(self.build.environment.machines.host, self) self.builtin['target_machine'] = \ OBJ.MachineHolder(self.build.environment.machines.target, self) def build_func_dict(self) -> None: self.funcs.update({'add_global_arguments': self.func_add_global_arguments, 'add_global_link_arguments': self.func_add_global_link_arguments, 'add_languages': self.func_add_languages, 'add_project_arguments': self.func_add_project_arguments, 'add_project_dependencies': self.func_add_project_dependencies, 'add_project_link_arguments': self.func_add_project_link_arguments, 'add_test_setup': self.func_add_test_setup, 'alias_target': self.func_alias_target, 'assert': self.func_assert, 'benchmark': self.func_benchmark, 'both_libraries': self.func_both_lib, 'build_target': self.func_build_target, 'configuration_data': self.func_configuration_data, 'configure_file': self.func_configure_file, 'custom_target': self.func_custom_target, 'debug': self.func_debug, 'declare_dependency': self.func_declare_dependency, 'dependency': self.func_dependency, 'disabler': self.func_disabler, 'environment': self.func_environment, 'error': self.func_error, 'executable': self.func_executable, 'files': self.func_files, 'find_library': self.func_find_library, 'find_program': self.func_find_program, 'generator': self.func_generator, 'get_option': self.func_get_option, 'get_variable': self.func_get_variable, 'gettext': self.func_gettext, 'import': self.func_import, 'include_directories': self.func_include_directories, 'install_data': self.func_install_data, 'install_emptydir': self.func_install_emptydir, 'install_headers': self.func_install_headers, 'install_man': self.func_install_man, 'install_subdir': self.func_install_subdir, 'install_symlink': self.func_install_symlink, 'is_disabler': self.func_is_disabler, 'is_variable': self.func_is_variable, 'jar': self.func_jar, 'join_paths': self.func_join_paths, 'library': self.func_library, 'message': self.func_message, 'option': self.func_option, 'project': self.func_project, 'range': self.func_range, 'run_command': self.func_run_command, 'run_target': self.func_run_target, 'set_variable': self.func_set_variable, 'structured_sources': self.func_structured_sources, 'subdir': self.func_subdir, 'shared_library': self.func_shared_lib, 'shared_module': self.func_shared_module, 'static_library': self.func_static_lib, 'subdir_done': self.func_subdir_done, 'subproject': self.func_subproject, 'summary': self.func_summary, 'test': self.func_test, 'unset_variable': self.func_unset_variable, 'vcs_tag': self.func_vcs_tag, 'warning': self.func_warning, }) if 'MESON_UNIT_TEST' in os.environ: self.funcs.update({'exception': self.func_exception}) if 'MESON_RUNNING_IN_PROJECT_TESTS' in os.environ: self.funcs.update({'expect_error': self.func_expect_error}) def build_holder_map(self) -> None: ''' Build a mapping of `HoldableObject` types to their corresponding `ObjectHolder`s. This mapping is used in `InterpreterBase` to automatically holderify all returned values from methods and functions. ''' self.holder_map.update({ # Primitives list: P_OBJ.ArrayHolder, dict: P_OBJ.DictHolder, int: P_OBJ.IntegerHolder, bool: P_OBJ.BooleanHolder, str: P_OBJ.StringHolder, P_OBJ.MesonVersionString: P_OBJ.MesonVersionStringHolder, P_OBJ.DependencyVariableString: P_OBJ.DependencyVariableStringHolder, P_OBJ.OptionString: P_OBJ.OptionStringHolder, # Meson types mesonlib.File: OBJ.FileHolder, build.SharedLibrary: OBJ.SharedLibraryHolder, build.StaticLibrary: OBJ.StaticLibraryHolder, build.BothLibraries: OBJ.BothLibrariesHolder, build.SharedModule: OBJ.SharedModuleHolder, build.Executable: OBJ.ExecutableHolder, build.Jar: OBJ.JarHolder, build.CustomTarget: OBJ.CustomTargetHolder, build.CustomTargetIndex: OBJ.CustomTargetIndexHolder, build.Generator: OBJ.GeneratorHolder, build.GeneratedList: OBJ.GeneratedListHolder, build.ExtractedObjects: OBJ.GeneratedObjectsHolder, build.RunTarget: OBJ.RunTargetHolder, build.AliasTarget: OBJ.AliasTargetHolder, build.Headers: OBJ.HeadersHolder, build.Man: OBJ.ManHolder, build.EmptyDir: OBJ.EmptyDirHolder, build.Data: OBJ.DataHolder, build.SymlinkData: OBJ.SymlinkDataHolder, build.InstallDir: OBJ.InstallDirHolder, build.IncludeDirs: OBJ.IncludeDirsHolder, build.EnvironmentVariables: OBJ.EnvironmentVariablesHolder, build.StructuredSources: OBJ.StructuredSourcesHolder, compilers.RunResult: compilerOBJ.TryRunResultHolder, dependencies.ExternalLibrary: OBJ.ExternalLibraryHolder, coredata.UserFeatureOption: OBJ.FeatureOptionHolder, envconfig.MachineInfo: OBJ.MachineHolder, build.ConfigurationData: OBJ.ConfigurationDataHolder, }) ''' Build a mapping of `HoldableObject` base classes to their corresponding `ObjectHolder`s. The difference to `self.holder_map` is that the keys here define an upper bound instead of requiring an exact match. The mappings defined here are only used when there was no direct hit found in `self.holder_map`. ''' self.bound_holder_map.update({ dependencies.Dependency: OBJ.DependencyHolder, ExternalProgram: OBJ.ExternalProgramHolder, compilers.Compiler: compilerOBJ.CompilerHolder, ModuleObject: OBJ.ModuleObjectHolder, MutableModuleObject: OBJ.MutableModuleObjectHolder, }) def append_holder_map(self, held_type: T.Type[mesonlib.HoldableObject], holder_type: T.Type[ObjectHolder]) -> None: ''' Adds one additional mapping to the `holder_map`. The intended use for this function is in the `initialize` method of modules to register custom object holders. ''' self.holder_map.update({ held_type: holder_type }) def process_new_values(self, invalues: T.List[T.Union[TYPE_var, ExecutableSerialisation]]) -> None: invalues = listify(invalues) for v in invalues: if isinstance(v, ObjectHolder): raise InterpreterException('Modules must not return ObjectHolders') if isinstance(v, (build.BuildTarget, build.CustomTarget, build.RunTarget)): self.add_target(v.name, v) elif isinstance(v, list): self.process_new_values(v) elif isinstance(v, ExecutableSerialisation): v.subproject = self.subproject self.build.install_scripts.append(v) elif isinstance(v, build.Data): self.build.data.append(v) elif isinstance(v, build.SymlinkData): self.build.symlinks.append(v) elif isinstance(v, dependencies.InternalDependency): # FIXME: This is special cased and not ideal: # The first source is our new VapiTarget, the rest are deps self.process_new_values(v.sources[0]) elif isinstance(v, build.InstallDir): self.build.install_dirs.append(v) elif isinstance(v, Test): self.build.tests.append(v) elif isinstance(v, (int, str, bool, Disabler, ObjectHolder, build.GeneratedList, ExternalProgram, build.ConfigurationData)): pass else: raise InterpreterException(f'Module returned a value of unknown type {v!r}.') def handle_meson_version(self, pv: str, location: mparser.BaseNode) -> None: if not mesonlib.version_compare(coredata.stable_version, pv): raise InterpreterException.from_node(f'Meson version is {coredata.version} but project requires {pv}', node=location) mesonlib.project_meson_versions[self.subproject] = pv def handle_meson_version_from_ast(self) -> None: if not self.ast.lines: return project = self.ast.lines[0] # first line is always project() if not isinstance(project, mparser.FunctionNode): return for kw, val in project.args.kwargs.items(): assert isinstance(kw, mparser.IdNode), 'for mypy' if kw.value == 'meson_version': # mypy does not understand "and isinstance" if isinstance(val, mparser.StringNode): self.handle_meson_version(val.value, val) def get_build_def_files(self) -> mesonlib.OrderedSet[str]: return self.build_def_files def add_build_def_file(self, f: mesonlib.FileOrString) -> None: # Use relative path for files within source directory, and absolute path # for system files. Skip files within build directory. Also skip not regular # files (e.g. /dev/stdout) Normalize the path to avoid duplicates, this # is especially important to convert '/' to '\' on Windows. if isinstance(f, mesonlib.File): if f.is_built: return f = os.path.normpath(f.relative_name()) elif os.path.isfile(f) and not f.startswith('/dev'): srcdir = Path(self.environment.get_source_dir()) builddir = Path(self.environment.get_build_dir()) try: f_ = Path(f).resolve() except OSError: f_ = Path(f) s = f_.stat() if (hasattr(s, 'st_file_attributes') and s.st_file_attributes & stat.FILE_ATTRIBUTE_REPARSE_POINT != 0 and s.st_reparse_tag == stat.IO_REPARSE_TAG_APPEXECLINK): # This is a Windows Store link which we can't # resolve, so just do our best otherwise. f_ = f_.parent.resolve() / f_.name else: raise if builddir in f_.parents: return if srcdir in f_.parents: f_ = f_.relative_to(srcdir) f = str(f_) else: return if f not in self.build_def_files: self.build_def_files.add(f) def get_variables(self) -> T.Dict[str, InterpreterObject]: return self.variables def check_stdlibs(self) -> None: machine_choices = [MachineChoice.HOST] if self.coredata.is_cross_build(): machine_choices.append(MachineChoice.BUILD) for for_machine in machine_choices: props = self.build.environment.properties[for_machine] for l in self.coredata.compilers[for_machine].keys(): try: di = mesonlib.stringlistify(props.get_stdlib(l)) except KeyError: continue if len(di) == 1: FeatureNew.single_use('stdlib without variable name', '0.56.0', self.subproject, location=self.current_node) kwargs = {'native': for_machine is MachineChoice.BUILD, } name = l + '_stdlib' df = DependencyFallbacksHolder(self, [name]) df.set_fallback(di) dep = df.lookup(kwargs, force_fallback=True) self.build.stdlibs[for_machine][l] = dep @typed_pos_args('import', str) @typed_kwargs( 'import', REQUIRED_KW.evolve(since='0.59.0'), DISABLER_KW.evolve(since='0.59.0'), ) @disablerIfNotFound def func_import(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'kwtypes.FuncImportModule') -> T.Union[ExtensionModule, NewExtensionModule, NotFoundExtensionModule]: modname = args[0] disabled, required, _ = extract_required_kwarg(kwargs, self.subproject) if disabled: return NotFoundExtensionModule(modname) expect_unstable = False # Some tests use "unstable_" instead of "unstable-", and that happens to work because # of implementation details if modname.startswith(('unstable-', 'unstable_')): if modname.startswith('unstable_'): mlog.deprecation(f'Importing unstable modules as "{modname}" instead of "{modname.replace("_", "-", 1)}"', location=node) real_modname = modname[len('unstable') + 1:] # + 1 to handle the - or _ expect_unstable = True else: real_modname = modname if real_modname in self.modules: return self.modules[real_modname] try: module = importlib.import_module(f'mesonbuild.modules.{real_modname}') except ImportError: if required: raise InvalidArguments(f'Module "{modname}" does not exist') ext_module = NotFoundExtensionModule(real_modname) else: ext_module = module.initialize(self) assert isinstance(ext_module, (ExtensionModule, NewExtensionModule)) self.build.modules.append(real_modname) if ext_module.INFO.added: FeatureNew.single_use(f'module {ext_module.INFO.name}', ext_module.INFO.added, self.subproject, location=node) if ext_module.INFO.deprecated: FeatureDeprecated.single_use(f'module {ext_module.INFO.name}', ext_module.INFO.deprecated, self.subproject, location=node) if expect_unstable and not ext_module.INFO.unstable and ext_module.INFO.stabilized is None: raise InvalidArguments(f'Module {ext_module.INFO.name} has never been unstable, remove "unstable-" prefix.') if ext_module.INFO.stabilized is not None: if expect_unstable: FeatureDeprecated.single_use( f'module {ext_module.INFO.name} has been stabilized', ext_module.INFO.stabilized, self.subproject, 'drop "unstable-" prefix from the module name', location=node) else: FeatureNew.single_use( f'module {ext_module.INFO.name} as stable module', ext_module.INFO.stabilized, self.subproject, f'Consider either adding "unstable-" to the module name, or updating the meson required version to ">= {ext_module.INFO.stabilized}"', location=node) elif ext_module.INFO.unstable: if not expect_unstable: if required: raise InvalidArguments(f'Module "{ext_module.INFO.name}" has not been stabilized, and must be imported as unstable-{ext_module.INFO.name}') ext_module = NotFoundExtensionModule(real_modname) else: mlog.warning(f'Module {ext_module.INFO.name} has no backwards or forwards compatibility and might not exist in future releases.', location=node, fatal=False) self.modules[real_modname] = ext_module return ext_module @typed_pos_args('files', varargs=str) @noKwargs def func_files(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> T.List[mesonlib.File]: return self.source_strings_to_files(args[0]) @noPosargs @typed_kwargs( 'declare_dependency', KwargInfo('compile_args', ContainerTypeInfo(list, str), listify=True, default=[]), INCLUDE_DIRECTORIES.evolve(name='d_import_dirs', since='0.62.0'), D_MODULE_VERSIONS_KW.evolve(since='0.62.0'), KwargInfo('link_args', ContainerTypeInfo(list, str), listify=True, default=[]), DEPENDENCIES_KW, INCLUDE_DIRECTORIES, LINK_WITH_KW, LINK_WHOLE_KW.evolve(since='0.46.0'), SOURCES_KW, KwargInfo('extra_files', ContainerTypeInfo(list, (mesonlib.File, str)), listify=True, default=[], since='1.2.0'), VARIABLES_KW.evolve(since='0.54.0', since_values={list: '0.56.0'}), KwargInfo('version', (str, NoneType)), KwargInfo('objects', ContainerTypeInfo(list, build.ExtractedObjects), listify=True, default=[], since='1.1.0'), ) def func_declare_dependency(self, node, args, kwargs): deps = kwargs['dependencies'] incs = self.extract_incdirs(kwargs) libs = kwargs['link_with'] libs_whole = kwargs['link_whole'] objects = kwargs['objects'] sources = self.source_strings_to_files(kwargs['sources']) extra_files = self.source_strings_to_files(kwargs['extra_files']) compile_args = kwargs['compile_args'] link_args = kwargs['link_args'] variables = kwargs['variables'] version = kwargs['version'] if version is None: version = self.project_version d_module_versions = kwargs['d_module_versions'] d_import_dirs = self.extract_incdirs(kwargs, 'd_import_dirs') srcdir = Path(self.environment.source_dir) # convert variables which refer to an -uninstalled.pc style datadir for k, v in variables.items(): try: p = Path(v) except ValueError: continue else: if not self.is_subproject() and srcdir / self.subproject_dir in p.parents: continue if p.is_absolute() and p.is_dir() and srcdir / self.root_subdir in [p] + list(Path(os.path.abspath(p)).parents): variables[k] = P_OBJ.DependencyVariableString(v) for d in deps: if not isinstance(d, dependencies.Dependency): raise InterpreterException('Invalid dependency') dep = dependencies.InternalDependency(version, incs, compile_args, link_args, libs, libs_whole, sources, extra_files, deps, variables, d_module_versions, d_import_dirs, objects) return dep @typed_pos_args('assert', bool, optargs=[str]) @noKwargs def func_assert(self, node: mparser.FunctionNode, args: T.Tuple[bool, T.Optional[str]], kwargs: 'TYPE_kwargs') -> None: value, message = args if message is None: FeatureNew.single_use('assert function without message argument', '0.53.0', self.subproject, location=node) if not value: if message is None: from ..ast import AstPrinter printer = AstPrinter() node.args.arguments[0].accept(printer) message = printer.result raise InterpreterException('Assert failed: ' + message) def validate_arguments(self, args, argcount, arg_types): if argcount is not None: if argcount != len(args): raise InvalidArguments(f'Expected {argcount} arguments, got {len(args)}.') for actual, wanted in zip(args, arg_types): if wanted is not None: if not isinstance(actual, wanted): raise InvalidArguments('Incorrect argument type.') # Executables aren't actually accepted, but we allow them here to allow for # better error messages when overridden @typed_pos_args( 'run_command', (build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str), varargs=(build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str)) @typed_kwargs( 'run_command', KwargInfo('check', (bool, NoneType), since='0.47.0'), KwargInfo('capture', bool, default=True, since='0.47.0'), ENV_KW.evolve(since='0.50.0'), ) def func_run_command(self, node: mparser.BaseNode, args: T.Tuple[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str], T.List[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str]]], kwargs: 'kwtypes.RunCommand') -> RunProcess: return self.run_command_impl(node, args, kwargs) def run_command_impl(self, node: mparser.BaseNode, args: T.Tuple[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str], T.List[T.Union[build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str]]], kwargs: 'kwtypes.RunCommand', in_builddir: bool = False) -> RunProcess: cmd, cargs = args capture = kwargs['capture'] env = kwargs['env'] srcdir = self.environment.get_source_dir() builddir = self.environment.get_build_dir() check = kwargs['check'] if check is None: mlog.warning(implicit_check_false_warning, once=True) check = False overridden_msg = ('Program {!r} was overridden with the compiled ' 'executable {!r} and therefore cannot be used during ' 'configuration') expanded_args: T.List[str] = [] if isinstance(cmd, build.Executable): for name, exe in self.build.find_overrides.items(): if cmd == exe: progname = name break else: raise MesonBugException('cmd was a built executable but not found in overrides table') raise InterpreterException(overridden_msg.format(progname, cmd.description())) if isinstance(cmd, ExternalProgram): if not cmd.found(): raise InterpreterException(f'command {cmd.get_name()!r} not found or not executable') elif isinstance(cmd, compilers.Compiler): exelist = cmd.get_exelist() cmd = exelist[0] prog = ExternalProgram(cmd, silent=True) if not prog.found(): raise InterpreterException(f'Program {cmd!r} not found or not executable') cmd = prog expanded_args = exelist[1:] else: if isinstance(cmd, mesonlib.File): cmd = cmd.absolute_path(srcdir, builddir) # Prefer scripts in the current source directory search_dir = os.path.join(srcdir, self.subdir) prog = ExternalProgram(cmd, silent=True, search_dir=search_dir) if not prog.found(): raise InterpreterException(f'Program or command {cmd!r} not found or not executable') cmd = prog for a in cargs: if isinstance(a, str): expanded_args.append(a) elif isinstance(a, mesonlib.File): expanded_args.append(a.absolute_path(srcdir, builddir)) elif isinstance(a, ExternalProgram): expanded_args.append(a.get_path()) elif isinstance(a, compilers.Compiler): FeatureNew.single_use('Compiler object as a variadic argument to `run_command`', '0.61.0', self.subproject, location=node) prog = ExternalProgram(a.exelist[0], silent=True) if not prog.found(): raise InterpreterException(f'Program {cmd!r} not found or not executable') expanded_args.append(prog.get_path()) else: raise InterpreterException(overridden_msg.format(a.name, cmd.description())) # If any file that was used as an argument to the command # changes, we must re-run the configuration step. self.add_build_def_file(cmd.get_path()) for a in expanded_args: if not os.path.isabs(a): a = os.path.join(builddir if in_builddir else srcdir, self.subdir, a) self.add_build_def_file(a) return RunProcess(cmd, expanded_args, env, srcdir, builddir, self.subdir, self.environment.get_build_command() + ['introspect'], in_builddir=in_builddir, check=check, capture=capture) def func_gettext(self, nodes, args, kwargs): raise InterpreterException('Gettext() function has been moved to module i18n. Import it and use i18n.gettext() instead') def func_option(self, nodes, args, kwargs): raise InterpreterException('Tried to call option() in build description file. All options must be in the option file.') @typed_pos_args('subproject', str) @typed_kwargs( 'subproject', REQUIRED_KW, DEFAULT_OPTIONS.evolve(since='0.38.0'), KwargInfo('version', ContainerTypeInfo(list, str), default=[], listify=True), ) def func_subproject(self, nodes: mparser.BaseNode, args: T.Tuple[str], kwargs: kwtypes.Subproject) -> SubprojectHolder: kw: kwtypes.DoSubproject = { 'required': kwargs['required'], 'default_options': kwargs['default_options'], 'version': kwargs['version'], 'options': None, 'cmake_options': [], } return self.do_subproject(args[0], 'meson', kw) def disabled_subproject(self, subp_name: str, disabled_feature: T.Optional[str] = None, exception: T.Optional[Exception] = None) -> SubprojectHolder: sub = SubprojectHolder(NullSubprojectInterpreter(), os.path.join(self.subproject_dir, subp_name), disabled_feature=disabled_feature, exception=exception) self.subprojects[subp_name] = sub return sub def do_subproject(self, subp_name: str, method: Literal['meson', 'cmake'], kwargs: kwtypes.DoSubproject) -> SubprojectHolder: disabled, required, feature = extract_required_kwarg(kwargs, self.subproject) if disabled: mlog.log('Subproject', mlog.bold(subp_name), ':', 'skipped: feature', mlog.bold(feature), 'disabled') return self.disabled_subproject(subp_name, disabled_feature=feature) default_options = coredata.create_options_dict(kwargs['default_options'], subp_name) if subp_name == '': raise InterpreterException('Subproject name must not be empty.') if subp_name[0] == '.': raise InterpreterException('Subproject name must not start with a period.') if '..' in subp_name: raise InterpreterException('Subproject name must not contain a ".." path segment.') if os.path.isabs(subp_name): raise InterpreterException('Subproject name must not be an absolute path.') if has_path_sep(subp_name): mlog.warning('Subproject name has a path separator. This may cause unexpected behaviour.', location=self.current_node) if subp_name in self.subproject_stack: fullstack = self.subproject_stack + [subp_name] incpath = ' => '.join(fullstack) raise InvalidCode(f'Recursive include of subprojects: {incpath}.') if subp_name in self.subprojects: subproject = self.subprojects[subp_name] if required and not subproject.found(): raise InterpreterException(f'Subproject "{subproject.subdir}" required but not found.') if kwargs['version']: pv = self.build.subprojects[subp_name] wanted = kwargs['version'] if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]: raise InterpreterException(f'Subproject {subp_name} version is {pv} but {wanted} required.') return subproject r = self.environment.wrap_resolver try: subdir = r.resolve(subp_name, method) except wrap.WrapException as e: if not required: mlog.log(e) mlog.log('Subproject ', mlog.bold(subp_name), 'is buildable:', mlog.red('NO'), '(disabling)') return self.disabled_subproject(subp_name, exception=e) raise e subdir_abs = os.path.join(self.environment.get_source_dir(), subdir) os.makedirs(os.path.join(self.build.environment.get_build_dir(), subdir), exist_ok=True) self.global_args_frozen = True stack = ':'.join(self.subproject_stack + [subp_name]) m = ['\nExecuting subproject', mlog.bold(stack)] if method != 'meson': m += ['method', mlog.bold(method)] mlog.log(*m, '\n', nested=False) try: if method == 'meson': return self._do_subproject_meson(subp_name, subdir, default_options, kwargs) elif method == 'cmake': return self._do_subproject_cmake(subp_name, subdir, subdir_abs, default_options, kwargs) else: raise mesonlib.MesonBugException(f'The method {method} is invalid for the subproject {subp_name}') # Invalid code is always an error except InvalidCode: raise except Exception as e: if not required: with mlog.nested(subp_name): # Suppress the 'ERROR:' prefix because this exception is not # fatal and VS CI treat any logs with "ERROR:" as fatal. mlog.exception(e, prefix=mlog.yellow('Exception:')) mlog.log('\nSubproject', mlog.bold(subdir), 'is buildable:', mlog.red('NO'), '(disabling)') return self.disabled_subproject(subp_name, exception=e) raise e def _do_subproject_meson(self, subp_name: str, subdir: str, default_options: T.Dict[OptionKey, str], kwargs: kwtypes.DoSubproject, ast: T.Optional[mparser.CodeBlockNode] = None, build_def_files: T.Optional[T.List[str]] = None, is_translated: bool = False, relaxations: T.Optional[T.Set[InterpreterRuleRelaxation]] = None) -> SubprojectHolder: with mlog.nested(subp_name): new_build = self.build.copy() subi = Interpreter(new_build, self.backend, subp_name, subdir, self.subproject_dir, default_options, ast=ast, is_translated=is_translated, relaxations=relaxations, user_defined_options=self.user_defined_options) # Those lists are shared by all interpreters. That means that # even if the subproject fails, any modification that the subproject # made to those lists will affect the parent project. subi.subprojects = self.subprojects subi.modules = self.modules subi.holder_map = self.holder_map subi.bound_holder_map = self.bound_holder_map subi.summary = self.summary subi.subproject_stack = self.subproject_stack + [subp_name] current_active = self.active_projectname with mlog.nested_warnings(): subi.run() subi_warnings = mlog.get_warning_count() mlog.log('Subproject', mlog.bold(subp_name), 'finished.') mlog.log() if kwargs['version']: pv = subi.project_version wanted = kwargs['version'] if pv == 'undefined' or not mesonlib.version_compare_many(pv, wanted)[0]: raise InterpreterException(f'Subproject {subp_name} version is {pv} but {wanted} required.') self.active_projectname = current_active self.subprojects.update(subi.subprojects) self.subprojects[subp_name] = SubprojectHolder(subi, subdir, warnings=subi_warnings, callstack=self.subproject_stack) # Duplicates are possible when subproject uses files from project root if build_def_files: self.build_def_files.update(build_def_files) # We always need the subi.build_def_files, to propagate sub-sub-projects self.build_def_files.update(subi.build_def_files) self.build.merge(subi.build) self.build.subprojects[subp_name] = subi.project_version return self.subprojects[subp_name] def _do_subproject_cmake(self, subp_name: str, subdir: str, subdir_abs: str, default_options: T.Dict[OptionKey, str], kwargs: kwtypes.DoSubproject) -> SubprojectHolder: with mlog.nested(subp_name): new_build = self.build.copy() prefix = self.coredata.options[OptionKey('prefix')].value from ..modules.cmake import CMakeSubprojectOptions options = kwargs['options'] or CMakeSubprojectOptions() cmake_options = kwargs['cmake_options'] + options.cmake_options cm_int = CMakeInterpreter(new_build, Path(subdir), Path(subdir_abs), Path(prefix), new_build.environment, self.backend) cm_int.initialise(cmake_options) cm_int.analyse() # Generate a meson ast and execute it with the normal do_subproject_meson ast = cm_int.pretend_to_be_meson(options.target_options) mlog.log() with mlog.nested('cmake-ast'): mlog.log('Processing generated meson AST') # Debug print the generated meson file from ..ast import AstIndentationGenerator, AstPrinter printer = AstPrinter(update_ast_line_nos=True) ast.accept(AstIndentationGenerator()) ast.accept(printer) printer.post_process() meson_filename = os.path.join(self.build.environment.get_build_dir(), subdir, 'meson.build') with open(meson_filename, "w", encoding='utf-8') as f: f.write(printer.result) mlog.log('Build file:', meson_filename) mlog.cmd_ci_include(meson_filename) mlog.log() result = self._do_subproject_meson( subp_name, subdir, default_options, kwargs, ast, [str(f) for f in cm_int.bs_files], is_translated=True, relaxations={ InterpreterRuleRelaxation.ALLOW_BUILD_DIR_FILE_REFERENCES, } ) result.cm_interpreter = cm_int mlog.log() return result def get_option_internal(self, optname: str) -> coredata.UserOption: key = OptionKey.from_string(optname).evolve(subproject=self.subproject) if not key.is_project(): for opts in [self.coredata.options, compilers.base_options]: v = opts.get(key) if v is None or v.yielding: v = opts.get(key.as_root()) if v is not None: assert isinstance(v, coredata.UserOption), 'for mypy' return v try: opt = self.coredata.options[key] if opt.yielding and key.subproject and key.as_root() in self.coredata.options: popt = self.coredata.options[key.as_root()] if type(opt) is type(popt): opt = popt else: # Get class name, then option type as a string opt_type = opt.__class__.__name__[4:][:-6].lower() popt_type = popt.__class__.__name__[4:][:-6].lower() # This is not a hard error to avoid dependency hell, the workaround # when this happens is to simply set the subproject's option directly. mlog.warning('Option {0!r} of type {1!r} in subproject {2!r} cannot yield ' 'to parent option of type {3!r}, ignoring parent value. ' 'Use -D{2}:{0}=value to set the value for this option manually' '.'.format(optname, opt_type, self.subproject, popt_type), location=self.current_node) return opt except KeyError: pass raise InterpreterException(f'Tried to access unknown option {optname!r}.') @typed_pos_args('get_option', str) @noKwargs def func_get_option(self, nodes: mparser.BaseNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> T.Union[coredata.UserOption, 'TYPE_var']: optname = args[0] if ':' in optname: raise InterpreterException('Having a colon in option name is forbidden, ' 'projects are not allowed to directly access ' 'options of other subprojects.') opt = self.get_option_internal(optname) if isinstance(opt, coredata.UserFeatureOption): opt.name = optname return opt elif isinstance(opt, coredata.UserOption): if isinstance(opt.value, str): return P_OBJ.OptionString(opt.value, f'{{{optname}}}') return opt.value return opt @typed_pos_args('configuration_data', optargs=[dict]) @noKwargs def func_configuration_data(self, node: mparser.BaseNode, args: T.Tuple[T.Optional[T.Dict[str, T.Any]]], kwargs: 'TYPE_kwargs') -> build.ConfigurationData: initial_values = args[0] if initial_values is not None: FeatureNew.single_use('configuration_data dictionary', '0.49.0', self.subproject, location=node) for k, v in initial_values.items(): if not isinstance(v, (str, int, bool)): raise InvalidArguments( f'"configuration_data": initial value dictionary key "{k!r}"" must be "str | int | bool", not "{v!r}"') return build.ConfigurationData(initial_values) def set_backend(self) -> None: # The backend is already set when parsing subprojects if self.backend is not None: return backend = self.coredata.get_option(OptionKey('backend')) from ..backend import backends self.backend = backends.get_backend_from_name(backend, self.build, self) if self.backend is None: raise InterpreterException(f'Unknown backend "{backend}".') if backend != self.backend.name: if self.backend.name.startswith('vs'): mlog.log('Auto detected Visual Studio backend:', mlog.bold(self.backend.name)) if not self.environment.first_invocation: raise MesonBugException(f'Backend changed from {backend} to {self.backend.name}') self.coredata.set_option(OptionKey('backend'), self.backend.name, first_invocation=True) # Only init backend options on first invocation otherwise it would # override values previously set from command line. if self.environment.first_invocation: self.coredata.init_backend_options(backend) options = {k: v for k, v in self.environment.options.items() if k.is_backend()} self.coredata.set_options(options) @typed_pos_args('project', str, varargs=str) @typed_kwargs( 'project', DEFAULT_OPTIONS, KwargInfo('meson_version', (str, NoneType)), KwargInfo( 'version', (str, mesonlib.File, NoneType, list), default='undefined', validator=_project_version_validator, convertor=lambda x: x[0] if isinstance(x, list) else x, ), KwargInfo('license', (ContainerTypeInfo(list, str), NoneType), default=None, listify=True), KwargInfo('license_files', ContainerTypeInfo(list, str), default=[], listify=True, since='1.1.0'), KwargInfo('subproject_dir', str, default='subprojects'), ) def func_project(self, node: mparser.FunctionNode, args: T.Tuple[str, T.List[str]], kwargs: 'kwtypes.Project') -> None: proj_name, proj_langs = args if ':' in proj_name: raise InvalidArguments(f"Project name {proj_name!r} must not contain ':'") # This needs to be evaluated as early as possible, as meson uses this # for things like deprecation testing. if kwargs['meson_version']: self.handle_meson_version(kwargs['meson_version'], node) # Load "meson.options" before "meson_options.txt", and produce a warning if # it is being used with an old version. I have added check that if both # exist the warning isn't raised option_file = os.path.join(self.source_root, self.subdir, 'meson.options') old_option_file = os.path.join(self.source_root, self.subdir, 'meson_options.txt') if os.path.exists(option_file): if os.path.exists(old_option_file): if os.path.samefile(option_file, old_option_file): mlog.debug("Not warning about meson.options with version minimum < 1.1 because meson_options.txt also exists") else: raise MesonException("meson.options and meson_options.txt both exist, but are not the same file.") else: FeatureNew.single_use('meson.options file', '1.1', self.subproject, 'Use meson_options.txt instead') else: option_file = old_option_file if os.path.exists(option_file): oi = optinterpreter.OptionInterpreter(self.subproject) oi.process(option_file) self.coredata.update_project_options(oi.options) self.add_build_def_file(option_file) # Do not set default_options on reconfigure otherwise it would override # values previously set from command line. That means that changing # default_options in a project will trigger a reconfigure but won't # have any effect. self.project_default_options = coredata.create_options_dict( kwargs['default_options'], self.subproject) # If this is the first invocation we always need to initialize # builtins, if this is a subproject that is new in a re-invocation we # need to initialize builtins for that if self.environment.first_invocation or (self.subproject != '' and self.subproject not in self.coredata.initialized_subprojects): default_options = self.project_default_options.copy() default_options.update(self.default_project_options) self.coredata.init_builtins(self.subproject) self.coredata.initialized_subprojects.add(self.subproject) else: default_options = {} self.coredata.set_default_options(default_options, self.subproject, self.environment) if not self.is_subproject(): self.build.project_name = proj_name self.active_projectname = proj_name version = kwargs['version'] if isinstance(version, mesonlib.File): FeatureNew.single_use('version from file', '0.57.0', self.subproject, location=node) self.add_build_def_file(version) ifname = version.absolute_path(self.environment.source_dir, self.environment.build_dir) try: ver_data = Path(ifname).read_text(encoding='utf-8').split('\n') except FileNotFoundError: raise InterpreterException('Version file not found.') if len(ver_data) == 2 and ver_data[1] == '': ver_data = ver_data[0:1] if len(ver_data) != 1: raise InterpreterException('Version file must contain exactly one line of text.') self.project_version = ver_data[0] else: self.project_version = version if self.build.project_version is None: self.build.project_version = self.project_version if kwargs['license'] is None: proj_license = ['unknown'] if kwargs['license_files']: raise InvalidArguments('Project `license` name must be specified when `license_files` is set') else: proj_license = kwargs['license'] proj_license_files = [] for i in self.source_strings_to_files(kwargs['license_files']): ifname = i.absolute_path(self.environment.source_dir, self.environment.build_dir) proj_license_files.append((ifname, i)) self.build.dep_manifest[proj_name] = build.DepManifest(self.project_version, proj_license, proj_license_files, self.subproject) if self.subproject in self.build.projects: raise InvalidCode('Second call to project().') # spdirname is the subproject_dir for this project, relative to self.subdir. # self.subproject_dir is the subproject_dir for the main project, relative to top source dir. spdirname = kwargs['subproject_dir'] if not isinstance(spdirname, str): raise InterpreterException('Subproject_dir must be a string') if os.path.isabs(spdirname): raise InterpreterException('Subproject_dir must not be an absolute path.') if spdirname.startswith('.'): raise InterpreterException('Subproject_dir must not begin with a period.') if '..' in spdirname: raise InterpreterException('Subproject_dir must not contain a ".." segment.') if not self.is_subproject(): self.subproject_dir = spdirname self.build.subproject_dir = self.subproject_dir # Load wrap files from this (sub)project. wrap_mode = self.coredata.get_option(OptionKey('wrap_mode')) if not self.is_subproject() or wrap_mode != WrapMode.nopromote: subdir = os.path.join(self.subdir, spdirname) r = wrap.Resolver(self.environment.get_source_dir(), subdir, self.subproject, wrap_mode) if self.is_subproject(): self.environment.wrap_resolver.merge_wraps(r) else: self.environment.wrap_resolver = r self.build.projects[self.subproject] = proj_name mlog.log('Project name:', mlog.bold(proj_name)) mlog.log('Project version:', mlog.bold(self.project_version)) if not self.is_subproject(): # We have to activate VS before adding languages and before calling # self.set_backend() otherwise it wouldn't be able to detect which # vs backend version we need. But after setting default_options in case # the project sets vs backend by default. backend = self.coredata.get_option(OptionKey('backend')) vsenv = self.coredata.get_option(OptionKey('vsenv')) force_vsenv = vsenv or backend.startswith('vs') mesonlib.setup_vsenv(force_vsenv) self.add_languages(proj_langs, True, MachineChoice.HOST) self.add_languages(proj_langs, False, MachineChoice.BUILD) self.set_backend() if not self.is_subproject(): self.check_stdlibs() @typed_kwargs('add_languages', KwargInfo('native', (bool, NoneType), since='0.54.0'), REQUIRED_KW) @typed_pos_args('add_languages', varargs=str) def func_add_languages(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddLanguages') -> bool: langs = args[0] disabled, required, feature = extract_required_kwarg(kwargs, self.subproject) native = kwargs['native'] if disabled: for lang in sorted(langs, key=compilers.sort_clink): mlog.log('Compiler for language', mlog.bold(lang), 'skipped: feature', mlog.bold(feature), 'disabled') return False if native is not None: return self.add_languages(langs, required, self.machine_from_native_kwarg(kwargs)) else: # absent 'native' means 'both' for backwards compatibility tv = FeatureNew.get_target_version(self.subproject) if FeatureNew.check_version(tv, '0.54.0'): mlog.warning('add_languages is missing native:, assuming languages are wanted for both host and build.', location=node) success = self.add_languages(langs, False, MachineChoice.BUILD) success &= self.add_languages(langs, required, MachineChoice.HOST) return success @noArgsFlattening @noKwargs def func_message(self, node: mparser.BaseNode, args, kwargs): if len(args) > 1: FeatureNew.single_use('message with more than one argument', '0.54.0', self.subproject, location=node) args_str = [stringifyUserArguments(i) for i in args] self.message_impl(args_str) def message_impl(self, args): mlog.log(mlog.bold('Message:'), *args) @noArgsFlattening @FeatureNew('summary', '0.53.0') @typed_pos_args('summary', (str, dict), optargs=[object]) @typed_kwargs( 'summary', KwargInfo('section', str, default=''), KwargInfo('bool_yn', bool, default=False), KwargInfo('list_sep', (str, NoneType), since='0.54.0') ) def func_summary(self, node: mparser.BaseNode, args: T.Tuple[T.Union[str, T.Dict[str, T.Any]], T.Optional[T.Any]], kwargs: 'kwtypes.Summary') -> None: if args[1] is None: if not isinstance(args[0], dict): raise InterpreterException('Summary first argument must be dictionary.') values = args[0] else: if not isinstance(args[0], str): raise InterpreterException('Summary first argument must be string.') values = {args[0]: args[1]} self.summary_impl(kwargs['section'], values, kwargs) def summary_impl(self, section: str, values, kwargs: 'kwtypes.Summary') -> None: if self.subproject not in self.summary: self.summary[self.subproject] = Summary(self.active_projectname, self.project_version) self.summary[self.subproject].add_section( section, values, kwargs['bool_yn'], kwargs['list_sep'], self.subproject) def _print_summary(self) -> None: # Add automatic 'Subprojects' section in main project. all_subprojects = collections.OrderedDict() for name, subp in sorted(self.subprojects.items()): value = [subp.found()] if subp.disabled_feature: value += [f'Feature {subp.disabled_feature!r} disabled'] elif subp.exception: value += [str(subp.exception)] elif subp.warnings > 0: value += [f'{subp.warnings} warnings'] if subp.callstack: stack = ' => '.join(subp.callstack) value += [f'(from {stack})'] all_subprojects[name] = value if all_subprojects: self.summary_impl('Subprojects', all_subprojects, {'bool_yn': True, 'list_sep': ' ', }) # Add automatic section with all user defined options if self.user_defined_options: values = collections.OrderedDict() if self.user_defined_options.cross_file: values['Cross files'] = self.user_defined_options.cross_file if self.user_defined_options.native_file: values['Native files'] = self.user_defined_options.native_file sorted_options = sorted(self.user_defined_options.cmd_line_options.items()) values.update({str(k): v for k, v in sorted_options}) if values: self.summary_impl('User defined options', values, {'bool_yn': False, 'list_sep': None}) # Print all summaries, main project last. mlog.log('') # newline main_summary = self.summary.pop('', None) for subp_name, summary in sorted(self.summary.items()): if self.subprojects[subp_name].found(): summary.dump() if main_summary: main_summary.dump() @noArgsFlattening @FeatureNew('warning', '0.44.0') @noKwargs def func_warning(self, node, args, kwargs): if len(args) > 1: FeatureNew.single_use('warning with more than one argument', '0.54.0', self.subproject, location=node) args_str = [stringifyUserArguments(i) for i in args] mlog.warning(*args_str, location=node) @noArgsFlattening @noKwargs def func_error(self, node, args, kwargs): if len(args) > 1: FeatureNew.single_use('error with more than one argument', '0.58.0', self.subproject, location=node) args_str = [stringifyUserArguments(i) for i in args] raise InterpreterException('Problem encountered: ' + ' '.join(args_str)) @noArgsFlattening @FeatureNew('debug', '0.63.0') @noKwargs def func_debug(self, node, args, kwargs): args_str = [stringifyUserArguments(i) for i in args] mlog.debug('Debug:', *args_str) @noKwargs @noPosargs def func_exception(self, node, args, kwargs): raise RuntimeError('unit test traceback :)') @noKwargs @typed_pos_args('expect_error', str) def func_expect_error(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: TYPE_kwargs) -> ContextManagerObject: class ExpectErrorObject(ContextManagerObject): def __init__(self, msg: str, subproject: str) -> None: super().__init__(subproject) self.msg = msg def __exit__(self, exc_type, exc_val, exc_tb): if exc_val is None: raise InterpreterException('Expecting an error but code block succeeded') if isinstance(exc_val, mesonlib.MesonException): msg = str(exc_val) if msg != self.msg: raise InterpreterException(f'Expecting error {self.msg!r} but got {msg!r}') return True return ExpectErrorObject(args[0], self.subproject) def add_languages(self, args: T.List[str], required: bool, for_machine: MachineChoice) -> bool: success = self.add_languages_for(args, required, for_machine) if not self.coredata.is_cross_build(): self.coredata.copy_build_options_from_regular_ones() self._redetect_machines() return success def should_skip_sanity_check(self, for_machine: MachineChoice) -> bool: should = self.environment.properties.host.get('skip_sanity_check', False) if not isinstance(should, bool): raise InterpreterException('Option skip_sanity_check must be a boolean.') if for_machine != MachineChoice.HOST and not should: return False if not self.environment.is_cross_build() and not should: return False return should def add_languages_for(self, args: T.List[str], required: bool, for_machine: MachineChoice) -> bool: args = [a.lower() for a in args] langs = set(self.compilers[for_machine].keys()) langs.update(args) # We'd really like to add cython's default language here, but it can't # actually be done because the cython compiler hasn't been initialized, # so we can't actually get the option yet. Because we can't know what # compiler to add by default, and we don't want to add unnecessary # compilers we don't add anything for cython here, and instead do it # When the first cython target using a particular language is used. if 'vala' in langs and 'c' not in langs: FeatureNew.single_use('Adding Vala language without C', '0.59.0', self.subproject, location=self.current_node) args.append('c') if 'nasm' in langs: FeatureNew.single_use('Adding NASM language', '0.64.0', self.subproject, location=self.current_node) success = True for lang in sorted(args, key=compilers.sort_clink): if lang in self.compilers[for_machine]: continue machine_name = for_machine.get_lower_case_name() comp = self.coredata.compilers[for_machine].get(lang) if not comp: try: skip_sanity_check = self.should_skip_sanity_check(for_machine) if skip_sanity_check: mlog.log('Cross compiler sanity tests disabled via the cross file.', once=True) comp = compilers.detect_compiler_for(self.environment, lang, for_machine, skip_sanity_check) if comp is None: raise InvalidArguments(f'Tried to use unknown language "{lang}".') except mesonlib.MesonException: if not required: mlog.log('Compiler for language', mlog.bold(lang), 'for the', machine_name, 'machine not found.') success = False continue else: raise # Add per-subproject compiler options. They inherit value from main project. if self.subproject: options = {} for k in comp.get_options(): v = copy.copy(self.coredata.options[k]) k = k.evolve(subproject=self.subproject) options[k] = v self.coredata.add_compiler_options(options, lang, for_machine, self.environment) if for_machine == MachineChoice.HOST or self.environment.is_cross_build(): logger_fun = mlog.log else: logger_fun = mlog.debug logger_fun(comp.get_display_language(), 'compiler for the', machine_name, 'machine:', mlog.bold(' '.join(comp.get_exelist())), comp.get_version_string()) if comp.linker is not None: logger_fun(comp.get_display_language(), 'linker for the', machine_name, 'machine:', mlog.bold(' '.join(comp.linker.get_exelist())), comp.linker.id, comp.linker.version) self.build.ensure_static_linker(comp) self.compilers[for_machine][lang] = comp return success def program_from_file_for(self, for_machine: MachineChoice, prognames: T.List[mesonlib.FileOrString] ) -> T.Optional[ExternalProgram]: for p in prognames: if isinstance(p, mesonlib.File): continue # Always points to a local (i.e. self generated) file. if not isinstance(p, str): raise InterpreterException('Executable name must be a string') prog = ExternalProgram.from_bin_list(self.environment, for_machine, p) # if the machine file specified something, it may be a regular # not-found program but we still want to return that if not isinstance(prog, NonExistingExternalProgram): return prog return None def program_from_system(self, args: T.List[mesonlib.FileOrString], search_dirs: T.List[str], extra_info: T.List[mlog.TV_Loggable]) -> T.Optional[ExternalProgram]: # Search for scripts relative to current subdir. # Do not cache found programs because find_program('foobar') # might give different results when run from different source dirs. source_dir = os.path.join(self.environment.get_source_dir(), self.subdir) for exename in args: if isinstance(exename, mesonlib.File): if exename.is_built: search_dir = os.path.join(self.environment.get_build_dir(), exename.subdir) else: search_dir = os.path.join(self.environment.get_source_dir(), exename.subdir) exename = exename.fname extra_search_dirs = [] elif isinstance(exename, str): search_dir = source_dir extra_search_dirs = search_dirs else: raise InvalidArguments(f'find_program only accepts strings and files, not {exename!r}') extprog = ExternalProgram(exename, search_dir=search_dir, extra_search_dirs=extra_search_dirs, silent=True) if extprog.found(): extra_info.append(f"({' '.join(extprog.get_command())})") return extprog return None def program_from_overrides(self, command_names: T.List[mesonlib.FileOrString], extra_info: T.List['mlog.TV_Loggable'] ) -> T.Optional[T.Union[ExternalProgram, OverrideProgram, build.Executable]]: for name in command_names: if not isinstance(name, str): continue if name in self.build.find_overrides: exe = self.build.find_overrides[name] extra_info.append(mlog.blue('(overridden)')) return exe return None def store_name_lookups(self, command_names: T.List[mesonlib.FileOrString]) -> None: for name in command_names: if isinstance(name, str): self.build.searched_programs.add(name) def add_find_program_override(self, name: str, exe: T.Union[build.Executable, ExternalProgram, 'OverrideProgram']) -> None: if name in self.build.searched_programs: raise InterpreterException(f'Tried to override finding of executable "{name}" which has already been found.') if name in self.build.find_overrides: raise InterpreterException(f'Tried to override executable "{name}" which has already been overridden.') self.build.find_overrides[name] = exe def notfound_program(self, args: T.List[mesonlib.FileOrString]) -> ExternalProgram: return NonExistingExternalProgram(' '.join( [a if isinstance(a, str) else a.absolute_path(self.environment.source_dir, self.environment.build_dir) for a in args])) # TODO update modules to always pass `for_machine`. It is bad-form to assume # the host machine. def find_program_impl(self, args: T.List[mesonlib.FileOrString], for_machine: MachineChoice = MachineChoice.HOST, required: bool = True, silent: bool = True, wanted: T.Union[str, T.List[str]] = '', search_dirs: T.Optional[T.List[str]] = None, version_func: T.Optional[T.Callable[[T.Union['ExternalProgram', 'build.Executable', 'OverrideProgram']], str]] = None ) -> T.Union['ExternalProgram', 'build.Executable', 'OverrideProgram']: args = mesonlib.listify(args) extra_info: T.List[mlog.TV_Loggable] = [] progobj = self.program_lookup(args, for_machine, required, search_dirs, extra_info) if progobj is None: progobj = self.notfound_program(args) if isinstance(progobj, ExternalProgram) and not progobj.found(): if not silent: mlog.log('Program', mlog.bold(progobj.get_name()), 'found:', mlog.red('NO')) if required: m = 'Program {!r} not found or not executable' raise InterpreterException(m.format(progobj.get_name())) return progobj if wanted: if version_func: version = version_func(progobj) elif isinstance(progobj, build.Executable): if progobj.subproject: interp = self.subprojects[progobj.subproject].held_object else: interp = self assert isinstance(interp, Interpreter) version = interp.project_version else: version = progobj.get_version(self) is_found, not_found, _ = mesonlib.version_compare_many(version, wanted) if not is_found: mlog.log('Program', mlog.bold(progobj.name), 'found:', mlog.red('NO'), 'found', mlog.normal_cyan(version), 'but need:', mlog.bold(', '.join([f"'{e}'" for e in not_found])), *extra_info) if required: m = 'Invalid version of program, need {!r} {!r} found {!r}.' raise InterpreterException(m.format(progobj.name, not_found, version)) return self.notfound_program(args) extra_info.insert(0, mlog.normal_cyan(version)) # Only store successful lookups self.store_name_lookups(args) if not silent: mlog.log('Program', mlog.bold(progobj.name), 'found:', mlog.green('YES'), *extra_info) if isinstance(progobj, build.Executable): progobj.was_returned_by_find_program = True return progobj def program_lookup(self, args: T.List[mesonlib.FileOrString], for_machine: MachineChoice, required: bool, search_dirs: T.List[str], extra_info: T.List[mlog.TV_Loggable] ) -> T.Optional[T.Union[ExternalProgram, build.Executable, OverrideProgram]]: progobj = self.program_from_overrides(args, extra_info) if progobj: return progobj if args[0] == 'meson': # Override find_program('meson') to return what we were invoked with return ExternalProgram('meson', self.environment.get_build_command(), silent=True) fallback = None wrap_mode = self.coredata.get_option(OptionKey('wrap_mode')) if wrap_mode != WrapMode.nofallback and self.environment.wrap_resolver: fallback = self.environment.wrap_resolver.find_program_provider(args) if fallback and wrap_mode == WrapMode.forcefallback: return self.find_program_fallback(fallback, args, required, extra_info) progobj = self.program_from_file_for(for_machine, args) if progobj is None: progobj = self.program_from_system(args, search_dirs, extra_info) if progobj is None and args[0].endswith('python3'): prog = ExternalProgram('python3', mesonlib.python_command, silent=True) progobj = prog if prog.found() else None if progobj is None and fallback and required: progobj = self.find_program_fallback(fallback, args, required, extra_info) return progobj def find_program_fallback(self, fallback: str, args: T.List[mesonlib.FileOrString], required: bool, extra_info: T.List[mlog.TV_Loggable] ) -> T.Optional[T.Union[ExternalProgram, build.Executable, OverrideProgram]]: mlog.log('Fallback to subproject', mlog.bold(fallback), 'which provides program', mlog.bold(' '.join(args))) sp_kwargs: kwtypes.DoSubproject = { 'required': required, 'default_options': [], 'version': [], 'cmake_options': [], 'options': None, } self.do_subproject(fallback, 'meson', sp_kwargs) return self.program_from_overrides(args, extra_info) @typed_pos_args('find_program', varargs=(str, mesonlib.File), min_varargs=1) @typed_kwargs( 'find_program', DISABLER_KW.evolve(since='0.49.0'), NATIVE_KW, REQUIRED_KW, KwargInfo('dirs', ContainerTypeInfo(list, str), default=[], listify=True, since='0.53.0'), KwargInfo('version', ContainerTypeInfo(list, str), default=[], listify=True, since='0.52.0'), ) @disablerIfNotFound def func_find_program(self, node: mparser.BaseNode, args: T.Tuple[T.List[mesonlib.FileOrString]], kwargs: 'kwtypes.FindProgram', ) -> T.Union['build.Executable', ExternalProgram, 'OverrideProgram']: disabled, required, feature = extract_required_kwarg(kwargs, self.subproject) if disabled: mlog.log('Program', mlog.bold(' '.join(args[0])), 'skipped: feature', mlog.bold(feature), 'disabled') return self.notfound_program(args[0]) search_dirs = extract_search_dirs(kwargs) return self.find_program_impl(args[0], kwargs['native'], required=required, silent=False, wanted=kwargs['version'], search_dirs=search_dirs) def func_find_library(self, node, args, kwargs): raise InvalidCode('find_library() is removed, use meson.get_compiler(\'name\').find_library() instead.\n' 'Look here for documentation: http://mesonbuild.com/Reference-manual.html#compiler-object\n' 'Look here for example: http://mesonbuild.com/howtox.html#add-math-library-lm-portably\n' ) # When adding kwargs, please check if they make sense in dependencies.get_dep_identifier() @FeatureNewKwargs('dependency', '0.57.0', ['cmake_package_version']) @FeatureNewKwargs('dependency', '0.56.0', ['allow_fallback']) @FeatureNewKwargs('dependency', '0.54.0', ['components']) @FeatureNewKwargs('dependency', '0.52.0', ['include_type']) @FeatureNewKwargs('dependency', '0.50.0', ['not_found_message', 'cmake_module_path', 'cmake_args']) @FeatureNewKwargs('dependency', '0.49.0', ['disabler']) @FeatureNewKwargs('dependency', '0.40.0', ['method']) @FeatureNewKwargs('dependency', '0.38.0', ['default_options']) @disablerIfNotFound @permittedKwargs(permitted_dependency_kwargs) @typed_pos_args('dependency', varargs=str, min_varargs=1) def func_dependency(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]], kwargs) -> Dependency: # Replace '' by empty list of names names = [n for n in args[0] if n] if len(names) > 1: FeatureNew('dependency with more than one name', '0.60.0').use(self.subproject) allow_fallback = kwargs.get('allow_fallback') if allow_fallback is not None and not isinstance(allow_fallback, bool): raise InvalidArguments('"allow_fallback" argument must be boolean') fallback = kwargs.get('fallback') default_options = kwargs.get('default_options') df = DependencyFallbacksHolder(self, names, allow_fallback, default_options) df.set_fallback(fallback) not_found_message = kwargs.get('not_found_message', '') if not isinstance(not_found_message, str): raise InvalidArguments('The not_found_message must be a string.') try: d = df.lookup(kwargs) except Exception: if not_found_message: self.message_impl([not_found_message]) raise assert isinstance(d, Dependency) if not d.found() and not_found_message: self.message_impl([not_found_message]) # Ensure the correct include type if 'include_type' in kwargs: wanted = kwargs['include_type'] if not isinstance(wanted, str): raise InvalidArguments('The `include_type` kwarg must be a string') actual = d.get_include_type() if wanted != actual: mlog.debug(f'Current include type of {args[0]} is {actual}. Converting to requested {wanted}') d = d.generate_system_dependency(wanted) if d.feature_since is not None: version, extra_msg = d.feature_since FeatureNew.single_use(f'dep {d.name!r} custom lookup', version, self.subproject, extra_msg, node) for f in d.featurechecks: f.use(self.subproject, node) return d @FeatureNew('disabler', '0.44.0') @noKwargs @noPosargs def func_disabler(self, node, args, kwargs): return Disabler() @FeatureNewKwargs('executable', '0.42.0', ['implib']) @FeatureNewKwargs('executable', '0.56.0', ['win_subsystem']) @FeatureDeprecatedKwargs('executable', '0.56.0', ['gui_app'], extra_message="Use 'win_subsystem' instead.") @permittedKwargs(build.known_exe_kwargs) @typed_pos_args('executable', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_executable(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> build.Executable: return self.build_target(node, args, kwargs, build.Executable) @permittedKwargs(build.known_stlib_kwargs) @typed_pos_args('static_library', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_static_lib(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> build.StaticLibrary: return self.build_target(node, args, kwargs, build.StaticLibrary) @permittedKwargs(build.known_shlib_kwargs) @typed_pos_args('shared_library', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_shared_lib(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> build.SharedLibrary: holder = self.build_target(node, args, kwargs, build.SharedLibrary) holder.shared_library_only = True return holder @permittedKwargs(known_library_kwargs) @typed_pos_args('both_libraries', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_both_lib(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> build.BothLibraries: return self.build_both_libraries(node, args, kwargs) @FeatureNew('shared_module', '0.37.0') @permittedKwargs(build.known_shmod_kwargs) @typed_pos_args('shared_module', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_shared_module(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> build.SharedModule: return self.build_target(node, args, kwargs, build.SharedModule) @permittedKwargs(known_library_kwargs) @typed_pos_args('library', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_library(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> build.Executable: return self.build_library(node, args, kwargs) @permittedKwargs(build.known_jar_kwargs) @typed_pos_args('jar', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.ExtractedObjects, build.BuildTarget)) def func_jar(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[T.Union[str, mesonlib.File, build.GeneratedTypes]]], kwargs) -> build.Jar: return self.build_target(node, args, kwargs, build.Jar) @FeatureNewKwargs('build_target', '0.40.0', ['link_whole', 'override_options']) @permittedKwargs(known_build_target_kwargs) @typed_pos_args('build_target', str, varargs=(str, mesonlib.File, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList, build.StructuredSources, build.ExtractedObjects, build.BuildTarget)) def func_build_target(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[BuildTargetSource]], kwargs) -> T.Union[build.Executable, build.StaticLibrary, build.SharedLibrary, build.SharedModule, build.BothLibraries, build.Jar]: if 'target_type' not in kwargs: raise InterpreterException('Missing target_type keyword argument') target_type = kwargs.pop('target_type') if target_type == 'executable': return self.build_target(node, args, kwargs, build.Executable) elif target_type == 'shared_library': return self.build_target(node, args, kwargs, build.SharedLibrary) elif target_type == 'shared_module': FeatureNew.single_use( 'build_target(target_type: \'shared_module\')', '0.51.0', self.subproject, location=node) return self.build_target(node, args, kwargs, build.SharedModule) elif target_type == 'static_library': return self.build_target(node, args, kwargs, build.StaticLibrary) elif target_type == 'both_libraries': return self.build_both_libraries(node, args, kwargs) elif target_type == 'library': return self.build_library(node, args, kwargs) elif target_type == 'jar': return self.build_target(node, args, kwargs, build.Jar) else: raise InterpreterException('Unknown target_type.') @noPosargs @typed_kwargs( 'vcs_tag', CT_INPUT_KW.evolve(required=True), MULTI_OUTPUT_KW, # Cannot use the COMMAND_KW because command is allowed to be empty KwargInfo( 'command', ContainerTypeInfo(list, (str, build.BuildTarget, build.CustomTarget, build.CustomTargetIndex, ExternalProgram, mesonlib.File)), listify=True, default=[], ), KwargInfo('fallback', (str, NoneType)), KwargInfo('replace_string', str, default='@VCS_TAG@'), ) def func_vcs_tag(self, node: mparser.BaseNode, args: T.List['TYPE_var'], kwargs: 'kwtypes.VcsTag') -> build.CustomTarget: if kwargs['fallback'] is None: FeatureNew.single_use('Optional fallback in vcs_tag', '0.41.0', self.subproject, location=node) fallback = kwargs['fallback'] or self.project_version replace_string = kwargs['replace_string'] regex_selector = '(.*)' # default regex selector for custom command: use complete output vcs_cmd = kwargs['command'] source_dir = os.path.normpath(os.path.join(self.environment.get_source_dir(), self.subdir)) if vcs_cmd: if isinstance(vcs_cmd[0], (str, mesonlib.File)): if isinstance(vcs_cmd[0], mesonlib.File): FeatureNew.single_use('vcs_tag with file as the first argument', '0.62.0', self.subproject, location=node) maincmd = self.find_program_impl(vcs_cmd[0], required=False) if maincmd.found(): vcs_cmd[0] = maincmd else: FeatureNew.single_use('vcs_tag with custom_tgt, external_program, or exe as the first argument', '0.63.0', self.subproject, location=node) else: vcs = mesonlib.detect_vcs(source_dir) if vcs: mlog.log('Found {} repository at {}'.format(vcs['name'], vcs['wc_dir'])) vcs_cmd = vcs['get_rev'].split() regex_selector = vcs['rev_regex'] else: vcs_cmd = [' '] # executing this cmd will fail in vcstagger.py and force to use the fallback string # vcstagger.py parameters: infile, outfile, fallback, source_dir, replace_string, regex_selector, command... self._validate_custom_target_outputs(len(kwargs['input']) > 1, kwargs['output'], "vcs_tag") cmd = self.environment.get_build_command() + \ ['--internal', 'vcstagger', '@INPUT0@', '@OUTPUT0@', fallback, source_dir, replace_string, regex_selector] + vcs_cmd tg = build.CustomTarget( kwargs['output'][0], self.subdir, self.subproject, self.environment, cmd, self.source_strings_to_files(kwargs['input']), kwargs['output'], build_by_default=True, build_always_stale=True, ) self.add_target(tg.name, tg) return tg @FeatureNew('subdir_done', '0.46.0') @noPosargs @noKwargs def func_subdir_done(self, node: mparser.BaseNode, args: TYPE_var, kwargs: TYPE_kwargs) -> T.NoReturn: raise SubdirDoneRequest() @staticmethod def _validate_custom_target_outputs(has_multi_in: bool, outputs: T.Iterable[str], name: str) -> None: """Checks for additional invalid values in a custom_target output. This cannot be done with typed_kwargs because it requires the number of inputs. """ for out in outputs: if has_multi_in and ('@PLAINNAME@' in out or '@BASENAME@' in out): raise InvalidArguments(f'{name}: output cannot contain "@PLAINNAME@" or "@BASENAME@" ' 'when there is more than one input (we can\'t know which to use)') @typed_pos_args('custom_target', optargs=[str]) @typed_kwargs( 'custom_target', COMMAND_KW, CT_BUILD_ALWAYS, CT_BUILD_ALWAYS_STALE, CT_BUILD_BY_DEFAULT, CT_INPUT_KW, CT_INSTALL_DIR_KW, CT_INSTALL_TAG_KW, MULTI_OUTPUT_KW, DEPENDS_KW, DEPEND_FILES_KW, DEPFILE_KW, ENV_KW.evolve(since='0.57.0'), INSTALL_KW, INSTALL_MODE_KW.evolve(since='0.47.0'), KwargInfo('feed', bool, default=False, since='0.59.0'), KwargInfo('capture', bool, default=False), KwargInfo('console', bool, default=False, since='0.48.0'), ) def func_custom_target(self, node: mparser.FunctionNode, args: T.Tuple[str], kwargs: 'kwtypes.CustomTarget') -> build.CustomTarget: if kwargs['depfile'] and ('@BASENAME@' in kwargs['depfile'] or '@PLAINNAME@' in kwargs['depfile']): FeatureNew.single_use('substitutions in custom_target depfile', '0.47.0', self.subproject, location=node) install_mode = self._warn_kwarg_install_mode_sticky(kwargs['install_mode']) # Don't mutate the kwargs build_by_default = kwargs['build_by_default'] build_always_stale = kwargs['build_always_stale'] # Remap build_always to build_by_default and build_always_stale if kwargs['build_always'] is not None and kwargs['build_always_stale'] is not None: raise InterpreterException('CustomTarget: "build_always" and "build_always_stale" are mutually exclusive') if build_by_default is None and kwargs['install']: build_by_default = True elif kwargs['build_always'] is not None: if build_by_default is None: build_by_default = kwargs['build_always'] build_always_stale = kwargs['build_by_default'] # These are nullable so that we can know whether they're explicitly # set or not. If they haven't been overwritten, set them to their true # default if build_by_default is None: build_by_default = False if build_always_stale is None: build_always_stale = False name = args[0] if name is None: # name will default to first output, but we cannot do that yet because # they could need substitutions (e.g. @BASENAME@) first. CustomTarget() # will take care of setting a proper default but name must be an empty # string in the meantime. FeatureNew.single_use('custom_target() with no name argument', '0.60.0', self.subproject, location=node) name = '' inputs = self.source_strings_to_files(kwargs['input'], strict=False) command = kwargs['command'] if command and isinstance(command[0], str): command[0] = self.find_program_impl([command[0]]) if len(inputs) > 1 and kwargs['feed']: raise InvalidArguments('custom_target: "feed" keyword argument can only be used with a single input') if len(kwargs['output']) > 1 and kwargs['capture']: raise InvalidArguments('custom_target: "capture" keyword argument can only be used with a single output') if kwargs['capture'] and kwargs['console']: raise InvalidArguments('custom_target: "capture" and "console" keyword arguments are mutually exclusive') for c in command: if kwargs['capture'] and isinstance(c, str) and '@OUTPUT@' in c: raise InvalidArguments('custom_target: "capture" keyword argument cannot be used with "@OUTPUT@"') if kwargs['feed'] and isinstance(c, str) and '@INPUT@' in c: raise InvalidArguments('custom_target: "feed" keyword argument cannot be used with "@INPUT@"') if kwargs['install'] and not kwargs['install_dir']: raise InvalidArguments('custom_target: "install_dir" keyword argument must be set when "install" is true.') if len(kwargs['install_dir']) > 1: FeatureNew.single_use('multiple install_dir for custom_target', '0.40.0', self.subproject, location=node) if len(kwargs['install_tag']) not in {0, 1, len(kwargs['output'])}: raise InvalidArguments('custom_target: install_tag argument must have 0 or 1 outputs, ' 'or the same number of elements as the output keyword argument. ' f'(there are {len(kwargs["install_tag"])} install_tags, ' f'and {len(kwargs["output"])} outputs)') for t in kwargs['output']: self.validate_forbidden_targets(t) self._validate_custom_target_outputs(len(inputs) > 1, kwargs['output'], "custom_target") tg = build.CustomTarget( name, self.subdir, self.subproject, self.environment, command, inputs, kwargs['output'], build_always_stale=build_always_stale, build_by_default=build_by_default, capture=kwargs['capture'], console=kwargs['console'], depend_files=kwargs['depend_files'], depfile=kwargs['depfile'], extra_depends=kwargs['depends'], env=kwargs['env'], feed=kwargs['feed'], install=kwargs['install'], install_dir=kwargs['install_dir'], install_mode=install_mode, install_tag=kwargs['install_tag'], backend=self.backend) self.add_target(tg.name, tg) return tg @typed_pos_args('run_target', str) @typed_kwargs( 'run_target', COMMAND_KW, DEPENDS_KW, ENV_KW.evolve(since='0.57.0'), ) def func_run_target(self, node: mparser.FunctionNode, args: T.Tuple[str], kwargs: 'kwtypes.RunTarget') -> build.RunTarget: all_args = kwargs['command'].copy() for i in listify(all_args): if isinstance(i, ExternalProgram) and not i.found(): raise InterpreterException(f'Tried to use non-existing executable {i.name!r}') if isinstance(all_args[0], str): all_args[0] = self.find_program_impl([all_args[0]]) name = args[0] tg = build.RunTarget(name, all_args, kwargs['depends'], self.subdir, self.subproject, self.environment, kwargs['env']) self.add_target(name, tg) return tg @FeatureNew('alias_target', '0.52.0') @typed_pos_args('alias_target', str, varargs=build.Target, min_varargs=1) @noKwargs def func_alias_target(self, node: mparser.BaseNode, args: T.Tuple[str, T.List[build.Target]], kwargs: 'TYPE_kwargs') -> build.AliasTarget: name, deps = args tg = build.AliasTarget(name, deps, self.subdir, self.subproject, self.environment) self.add_target(name, tg) return tg @typed_pos_args('generator', (build.Executable, ExternalProgram)) @typed_kwargs( 'generator', KwargInfo('arguments', ContainerTypeInfo(list, str, allow_empty=False), required=True, listify=True), KwargInfo('output', ContainerTypeInfo(list, str, allow_empty=False), required=True, listify=True), DEPFILE_KW, DEPENDS_KW, KwargInfo('capture', bool, default=False, since='0.43.0'), ) def func_generator(self, node: mparser.FunctionNode, args: T.Tuple[T.Union[build.Executable, ExternalProgram]], kwargs: 'kwtypes.FuncGenerator') -> build.Generator: for rule in kwargs['output']: if '@BASENAME@' not in rule and '@PLAINNAME@' not in rule: raise InvalidArguments('Every element of "output" must contain @BASENAME@ or @PLAINNAME@.') if has_path_sep(rule): raise InvalidArguments('"output" must not contain a directory separator.') if len(kwargs['output']) > 1: for o in kwargs['output']: if '@OUTPUT@' in o: raise InvalidArguments('Tried to use @OUTPUT@ in a rule with more than one output.') gen = build.Generator(args[0], **kwargs) self.generators.append(gen) return gen @typed_pos_args('benchmark', str, (build.Executable, build.Jar, ExternalProgram, mesonlib.File)) @typed_kwargs('benchmark', *TEST_KWS) def func_benchmark(self, node: mparser.BaseNode, args: T.Tuple[str, T.Union[build.Executable, build.Jar, ExternalProgram, mesonlib.File]], kwargs: 'kwtypes.FuncBenchmark') -> None: self.add_test(node, args, kwargs, False) @typed_pos_args('test', str, (build.Executable, build.Jar, ExternalProgram, mesonlib.File)) @typed_kwargs('test', *TEST_KWS, KwargInfo('is_parallel', bool, default=True)) def func_test(self, node: mparser.BaseNode, args: T.Tuple[str, T.Union[build.Executable, build.Jar, ExternalProgram, mesonlib.File]], kwargs: 'kwtypes.FuncTest') -> None: self.add_test(node, args, kwargs, True) def unpack_env_kwarg(self, kwargs: T.Union[build.EnvironmentVariables, T.Dict[str, 'TYPE_var'], T.List['TYPE_var'], str]) -> build.EnvironmentVariables: envlist = kwargs.get('env') if envlist is None: return build.EnvironmentVariables() msg = ENV_KW.validator(envlist) if msg: raise InvalidArguments(f'"env": {msg}') return ENV_KW.convertor(envlist) def make_test(self, node: mparser.BaseNode, args: T.Tuple[str, T.Union[build.Executable, build.Jar, ExternalProgram, mesonlib.File]], kwargs: 'kwtypes.BaseTest') -> Test: name = args[0] if ':' in name: mlog.deprecation(f'":" is not allowed in test name "{name}", it has been replaced with "_"', location=node) name = name.replace(':', '_') exe = args[1] if isinstance(exe, ExternalProgram): if not exe.found(): raise InvalidArguments('Tried to use not-found external program as test exe') elif isinstance(exe, mesonlib.File): exe = self.find_program_impl([exe]) env = self.unpack_env_kwarg(kwargs) if kwargs['timeout'] <= 0: FeatureNew.single_use('test() timeout <= 0', '0.57.0', self.subproject, location=node) prj = self.subproject if self.is_subproject() else self.build.project_name suite: T.List[str] = [] for s in kwargs['suite']: if s: s = ':' + s suite.append(prj.replace(' ', '_').replace(':', '_') + s) return Test(name, prj, suite, exe, kwargs['depends'], kwargs.get('is_parallel', False), kwargs['args'], env, kwargs['should_fail'], kwargs['timeout'], kwargs['workdir'], kwargs['protocol'], kwargs['priority'], kwargs['verbose']) def add_test(self, node: mparser.BaseNode, args: T.List, kwargs: T.Dict[str, T.Any], is_base_test: bool): t = self.make_test(node, args, kwargs) if is_base_test: self.build.tests.append(t) mlog.debug('Adding test', mlog.bold(t.name, True)) else: self.build.benchmarks.append(t) mlog.debug('Adding benchmark', mlog.bold(t.name, True)) @typed_pos_args('install_headers', varargs=(str, mesonlib.File)) @typed_kwargs( 'install_headers', PRESERVE_PATH_KW, KwargInfo('subdir', (str, NoneType)), INSTALL_MODE_KW.evolve(since='0.47.0'), INSTALL_DIR_KW, ) def func_install_headers(self, node: mparser.BaseNode, args: T.Tuple[T.List['mesonlib.FileOrString']], kwargs: 'kwtypes.FuncInstallHeaders') -> build.Headers: install_mode = self._warn_kwarg_install_mode_sticky(kwargs['install_mode']) source_files = self.source_strings_to_files(args[0]) install_subdir = kwargs['subdir'] if install_subdir is not None: if kwargs['install_dir'] is not None: raise InterpreterException('install_headers: cannot specify both "install_dir" and "subdir". Use only "install_dir".') if os.path.isabs(install_subdir): mlog.deprecation('Subdir keyword must not be an absolute path. This will be a hard error in the next release.') else: install_subdir = '' dirs = collections.defaultdict(list) ret_headers = [] if kwargs['preserve_path']: for file in source_files: dirname = os.path.dirname(file.fname) dirs[dirname].append(file) else: dirs[''].extend(source_files) for childdir in dirs: h = build.Headers(dirs[childdir], os.path.join(install_subdir, childdir), kwargs['install_dir'], install_mode, self.subproject) ret_headers.append(h) self.build.headers.append(h) return ret_headers @typed_pos_args('install_man', varargs=(str, mesonlib.File)) @typed_kwargs( 'install_man', KwargInfo('locale', (str, NoneType), since='0.58.0'), INSTALL_MODE_KW.evolve(since='0.47.0'), INSTALL_DIR_KW, ) def func_install_man(self, node: mparser.BaseNode, args: T.Tuple[T.List['mesonlib.FileOrString']], kwargs: 'kwtypes.FuncInstallMan') -> build.Man: install_mode = self._warn_kwarg_install_mode_sticky(kwargs['install_mode']) # We just need to narrow this, because the input is limited to files and # Strings as inputs, so only Files will be returned sources = self.source_strings_to_files(args[0]) for s in sources: try: num = int(s.rsplit('.', 1)[-1]) except (IndexError, ValueError): num = 0 if not 1 <= num <= 9: raise InvalidArguments('Man file must have a file extension of a number between 1 and 9') m = build.Man(sources, kwargs['install_dir'], install_mode, self.subproject, kwargs['locale']) self.build.man.append(m) return m @FeatureNew('install_emptydir', '0.60.0') @typed_kwargs( 'install_emptydir', INSTALL_MODE_KW, KwargInfo('install_tag', (str, NoneType), since='0.62.0') ) def func_install_emptydir(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs) -> None: d = build.EmptyDir(args[0], kwargs['install_mode'], self.subproject, kwargs['install_tag']) self.build.emptydir.append(d) return d @FeatureNew('install_symlink', '0.61.0') @typed_pos_args('symlink_name', str) @typed_kwargs( 'install_symlink', KwargInfo('pointing_to', str, required=True), KwargInfo('install_dir', str, required=True), INSTALL_TAG_KW, ) def func_install_symlink(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]], kwargs) -> build.SymlinkData: name = args[0] # Validation while creating the SymlinkData object target = kwargs['pointing_to'] l = build.SymlinkData(target, name, kwargs['install_dir'], self.subproject, kwargs['install_tag']) self.build.symlinks.append(l) return l @FeatureNew('structured_sources', '0.62.0') @typed_pos_args('structured_sources', object, optargs=[dict]) @noKwargs @noArgsFlattening def func_structured_sources( self, node: mparser.BaseNode, args: T.Tuple[object, T.Optional[T.Dict[str, object]]], kwargs: 'TYPE_kwargs') -> build.StructuredSources: valid_types = (str, mesonlib.File, build.GeneratedList, build.CustomTarget, build.CustomTargetIndex, build.GeneratedList) sources: T.Dict[str, T.List[T.Union[mesonlib.File, 'build.GeneratedTypes']]] = collections.defaultdict(list) for arg in mesonlib.listify(args[0]): if not isinstance(arg, valid_types): raise InvalidArguments(f'structured_sources: type "{type(arg)}" is not valid') if isinstance(arg, str): arg = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, arg) sources[''].append(arg) if args[1]: if '' in args[1]: raise InvalidArguments('structured_sources: keys to dictionary argument may not be an empty string.') for k, v in args[1].items(): for arg in mesonlib.listify(v): if not isinstance(arg, valid_types): raise InvalidArguments(f'structured_sources: type "{type(arg)}" is not valid') if isinstance(arg, str): arg = mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, arg) sources[k].append(arg) return build.StructuredSources(sources) @typed_pos_args('subdir', str) @typed_kwargs( 'subdir', KwargInfo( 'if_found', ContainerTypeInfo(list, object), validator=lambda a: 'Objects must have a found() method' if not all(hasattr(x, 'found') for x in a) else None, since='0.44.0', default=[], listify=True, ), ) def func_subdir(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'kwtypes.Subdir') -> None: mesonlib.check_direntry_issues(args) if '..' in args[0]: raise InvalidArguments('Subdir contains ..') if self.subdir == '' and args[0] == self.subproject_dir: raise InvalidArguments('Must not go into subprojects dir with subdir(), use subproject() instead.') if self.subdir == '' and args[0].startswith('meson-'): raise InvalidArguments('The "meson-" prefix is reserved and cannot be used for top-level subdir().') if args[0] == '': raise InvalidArguments("The argument given to subdir() is the empty string ''. This is prohibited.") for i in kwargs['if_found']: if not i.found(): return prev_subdir = self.subdir subdir = os.path.join(prev_subdir, args[0]) if os.path.isabs(subdir): raise InvalidArguments('Subdir argument must be a relative path.') absdir = os.path.join(self.environment.get_source_dir(), subdir) symlinkless_dir = os.path.realpath(absdir) build_file = os.path.join(symlinkless_dir, 'meson.build') if build_file in self.processed_buildfiles: raise InvalidArguments(f'Tried to enter directory "{subdir}", which has already been visited.') self.processed_buildfiles.add(build_file) self.subdir = subdir os.makedirs(os.path.join(self.environment.build_dir, subdir), exist_ok=True) buildfilename = os.path.join(self.subdir, environment.build_filename) self.build_def_files.add(buildfilename) absname = os.path.join(self.environment.get_source_dir(), buildfilename) if not os.path.isfile(absname): self.subdir = prev_subdir raise InterpreterException(f"Nonexistent build file '{buildfilename!s}'") with open(absname, encoding='utf-8') as f: code = f.read() assert isinstance(code, str) try: codeblock = mparser.Parser(code, absname).parse() except mesonlib.MesonException as me: me.file = absname raise me try: self.evaluate_codeblock(codeblock) except SubdirDoneRequest: pass self.subdir = prev_subdir def _get_kwarg_install_mode(self, kwargs: T.Dict[str, T.Any]) -> T.Optional[FileMode]: if kwargs.get('install_mode', None) is None: return None if isinstance(kwargs['install_mode'], FileMode): return kwargs['install_mode'] install_mode: T.List[str] = [] mode = mesonlib.typeslistify(kwargs.get('install_mode', []), (str, int)) for m in mode: # We skip any arguments that are set to `false` if m is False: m = None install_mode.append(m) if len(install_mode) > 3: raise InvalidArguments('Keyword argument install_mode takes at ' 'most 3 arguments.') if len(install_mode) > 0 and install_mode[0] is not None and \ not isinstance(install_mode[0], str): raise InvalidArguments('Keyword argument install_mode requires the ' 'permissions arg to be a string or false') return FileMode(*install_mode) # This is either ignored on basically any OS nowadays, or silently gets # ignored (Solaris) or triggers an "illegal operation" error (FreeBSD). # It was likely added "because it exists", but should never be used. In # theory it is useful for directories, but we never apply modes to # directories other than in install_emptydir. def _warn_kwarg_install_mode_sticky(self, mode: FileMode) -> None: if mode.perms > 0 and mode.perms & stat.S_ISVTX: mlog.deprecation('install_mode with the sticky bit on a file does not do anything and will ' 'be ignored since Meson 0.64.0', location=self.current_node) perms = stat.filemode(mode.perms - stat.S_ISVTX)[1:] return FileMode(perms, mode.owner, mode.group) else: return mode @typed_pos_args('install_data', varargs=(str, mesonlib.File)) @typed_kwargs( 'install_data', KwargInfo('sources', ContainerTypeInfo(list, (str, mesonlib.File)), listify=True, default=[]), KwargInfo('rename', ContainerTypeInfo(list, str), default=[], listify=True, since='0.46.0'), INSTALL_MODE_KW.evolve(since='0.38.0'), INSTALL_TAG_KW.evolve(since='0.60.0'), INSTALL_DIR_KW, PRESERVE_PATH_KW.evolve(since='0.64.0'), ) def func_install_data(self, node: mparser.BaseNode, args: T.Tuple[T.List['mesonlib.FileOrString']], kwargs: 'kwtypes.FuncInstallData') -> build.Data: sources = self.source_strings_to_files(args[0] + kwargs['sources']) rename = kwargs['rename'] or None if rename: if len(rename) != len(sources): raise InvalidArguments( '"rename" and "sources" argument lists must be the same length if "rename" is given. ' f'Rename has {len(rename)} elements and sources has {len(sources)}.') install_mode = self._warn_kwarg_install_mode_sticky(kwargs['install_mode']) return self.install_data_impl(sources, kwargs['install_dir'], install_mode, rename, kwargs['install_tag'], preserve_path=kwargs['preserve_path']) def install_data_impl(self, sources: T.List[mesonlib.File], install_dir: T.Optional[str], install_mode: FileMode, rename: T.Optional[str], tag: T.Optional[str], install_dir_name: T.Optional[str] = None, install_data_type: T.Optional[str] = None, preserve_path: bool = False) -> build.Data: """Just the implementation with no validation.""" idir = install_dir or '' idir_name = install_dir_name or idir or '{datadir}' if isinstance(idir_name, P_OBJ.OptionString): idir_name = idir_name.optname dirs = collections.defaultdict(list) ret_data = [] if preserve_path: for file in sources: dirname = os.path.dirname(file.fname) dirs[dirname].append(file) else: dirs[''].extend(sources) for childdir, files in dirs.items(): d = build.Data(files, os.path.join(idir, childdir), os.path.join(idir_name, childdir), install_mode, self.subproject, rename, tag, install_data_type) ret_data.append(d) self.build.data.extend(ret_data) return ret_data @typed_pos_args('install_subdir', str) @typed_kwargs( 'install_subdir', KwargInfo('install_dir', str, required=True), KwargInfo('strip_directory', bool, default=False), KwargInfo('exclude_files', ContainerTypeInfo(list, str), default=[], listify=True, since='0.42.0', validator=lambda x: 'cannot be absolute' if any(os.path.isabs(d) for d in x) else None), KwargInfo('exclude_directories', ContainerTypeInfo(list, str), default=[], listify=True, since='0.42.0', validator=lambda x: 'cannot be absolute' if any(os.path.isabs(d) for d in x) else None), INSTALL_MODE_KW.evolve(since='0.38.0'), INSTALL_TAG_KW.evolve(since='0.60.0'), ) def func_install_subdir(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'kwtypes.FuncInstallSubdir') -> build.InstallDir: exclude = (set(kwargs['exclude_files']), set(kwargs['exclude_directories'])) srcdir = os.path.join(self.environment.source_dir, self.subdir, args[0]) if not os.path.isdir(srcdir) or not any(os.scandir(srcdir)): FeatureNew.single_use('install_subdir with empty directory', '0.47.0', self.subproject, location=node) FeatureDeprecated.single_use('install_subdir with empty directory', '0.60.0', self.subproject, 'It worked by accident and is buggy. Use install_emptydir instead.', node) install_mode = self._warn_kwarg_install_mode_sticky(kwargs['install_mode']) idir_name = kwargs['install_dir'] if isinstance(idir_name, P_OBJ.OptionString): idir_name = idir_name.optname idir = build.InstallDir( self.subdir, args[0], kwargs['install_dir'], idir_name, install_mode, exclude, kwargs['strip_directory'], self.subproject, install_tag=kwargs['install_tag']) self.build.install_dirs.append(idir) return idir @noPosargs @typed_kwargs( 'configure_file', DEPFILE_KW.evolve(since='0.52.0'), INSTALL_MODE_KW.evolve(since='0.47.0,'), INSTALL_TAG_KW.evolve(since='0.60.0'), KwargInfo('capture', bool, default=False, since='0.41.0'), KwargInfo( 'command', (ContainerTypeInfo(list, (build.Executable, ExternalProgram, compilers.Compiler, mesonlib.File, str), allow_empty=False), NoneType), listify=True, ), KwargInfo( 'configuration', (ContainerTypeInfo(dict, (str, int, bool)), build.ConfigurationData, NoneType), ), KwargInfo( 'copy', bool, default=False, since='0.47.0', deprecated='0.64.0', deprecated_message='Use fs.copyfile instead', ), KwargInfo('encoding', str, default='utf-8', since='0.47.0'), KwargInfo('format', str, default='meson', since='0.46.0', validator=in_set_validator({'meson', 'cmake', 'cmake@'})), KwargInfo( 'input', ContainerTypeInfo(list, (mesonlib.File, str)), listify=True, default=[], ), # Cannot use shared implementation until None backwards compat is dropped KwargInfo('install', (bool, NoneType), since='0.50.0'), KwargInfo('install_dir', (str, bool), default='', validator=lambda x: 'must be `false` if boolean' if x is True else None), OUTPUT_KW, KwargInfo('output_format', str, default='c', since='0.47.0', validator=in_set_validator({'c', 'nasm'})), ) def func_configure_file(self, node: mparser.BaseNode, args: T.List[TYPE_var], kwargs: kwtypes.ConfigureFile): actions = sorted(x for x in ['configuration', 'command', 'copy'] if kwargs[x] not in [None, False]) num_actions = len(actions) if num_actions == 0: raise InterpreterException('Must specify an action with one of these ' 'keyword arguments: \'configuration\', ' '\'command\', or \'copy\'.') elif num_actions == 2: raise InterpreterException('Must not specify both {!r} and {!r} ' 'keyword arguments since they are ' 'mutually exclusive.'.format(*actions)) elif num_actions == 3: raise InterpreterException('Must specify one of {!r}, {!r}, and ' '{!r} keyword arguments since they are ' 'mutually exclusive.'.format(*actions)) if kwargs['capture'] and not kwargs['command']: raise InvalidArguments('configure_file: "capture" keyword requires "command" keyword.') install_mode = self._warn_kwarg_install_mode_sticky(kwargs['install_mode']) fmt = kwargs['format'] output_format = kwargs['output_format'] depfile = kwargs['depfile'] # Validate input inputs = self.source_strings_to_files(kwargs['input']) inputs_abs = [] for f in inputs: if isinstance(f, mesonlib.File): inputs_abs.append(f.absolute_path(self.environment.source_dir, self.environment.build_dir)) self.add_build_def_file(f) else: raise InterpreterException('Inputs can only be strings or file objects') # Validate output output = kwargs['output'] if inputs_abs: values = mesonlib.get_filenames_templates_dict(inputs_abs, None) outputs = mesonlib.substitute_values([output], values) output = outputs[0] if depfile: depfile = mesonlib.substitute_values([depfile], values)[0] ofile_rpath = os.path.join(self.subdir, output) if ofile_rpath in self.configure_file_outputs: mesonbuildfile = os.path.join(self.subdir, 'meson.build') current_call = f"{mesonbuildfile}:{self.current_lineno}" first_call = "{}:{}".format(mesonbuildfile, self.configure_file_outputs[ofile_rpath]) mlog.warning('Output file', mlog.bold(ofile_rpath, True), 'for configure_file() at', current_call, 'overwrites configure_file() output at', first_call) else: self.configure_file_outputs[ofile_rpath] = self.current_lineno (ofile_path, ofile_fname) = os.path.split(os.path.join(self.subdir, output)) ofile_abs = os.path.join(self.environment.build_dir, ofile_path, ofile_fname) # Perform the appropriate action if kwargs['configuration'] is not None: conf = kwargs['configuration'] if isinstance(conf, dict): FeatureNew.single_use('configure_file.configuration dictionary', '0.49.0', self.subproject, location=node) for k, v in conf.items(): if not isinstance(v, (str, int, bool)): raise InvalidArguments( f'"configuration_data": initial value dictionary key "{k!r}"" must be "str | int | bool", not "{v!r}"') conf = build.ConfigurationData(conf) mlog.log('Configuring', mlog.bold(output), 'using configuration') if len(inputs) > 1: raise InterpreterException('At most one input file can given in configuration mode') if inputs: os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True) file_encoding = kwargs['encoding'] missing_variables, confdata_useless = \ mesonlib.do_conf_file(inputs_abs[0], ofile_abs, conf, fmt, file_encoding, self.subproject) if missing_variables: var_list = ", ".join(repr(m) for m in sorted(missing_variables)) mlog.warning( f"The variable(s) {var_list} in the input file '{inputs[0]}' are not " "present in the given configuration data.", location=node) if confdata_useless: ifbase = os.path.basename(inputs_abs[0]) tv = FeatureNew.get_target_version(self.subproject) if FeatureNew.check_version(tv, '0.47.0'): mlog.warning('Got an empty configuration_data() object and found no ' f'substitutions in the input file {ifbase!r}. If you want to ' 'copy a file to the build dir, use the \'copy:\' keyword ' 'argument added in 0.47.0', location=node) else: mesonlib.dump_conf_header(ofile_abs, conf, output_format) conf.used = True elif kwargs['command'] is not None: if len(inputs) > 1: FeatureNew.single_use('multiple inputs in configure_file()', '0.52.0', self.subproject, location=node) # We use absolute paths for input and output here because the cwd # that the command is run from is 'unspecified', so it could change. # Currently it's builddir/subdir for in_builddir else srcdir/subdir. values = mesonlib.get_filenames_templates_dict(inputs_abs, [ofile_abs]) if depfile: depfile = os.path.join(self.environment.get_scratch_dir(), depfile) values['@DEPFILE@'] = depfile # Substitute @INPUT@, @OUTPUT@, etc here. _cmd = mesonlib.substitute_values(kwargs['command'], values) mlog.log('Configuring', mlog.bold(output), 'with command') cmd, *args = _cmd res = self.run_command_impl(node, (cmd, args), {'capture': True, 'check': True, 'env': build.EnvironmentVariables()}, True) if kwargs['capture']: dst_tmp = ofile_abs + '~' file_encoding = kwargs['encoding'] with open(dst_tmp, 'w', encoding=file_encoding) as f: f.writelines(res.stdout) if inputs_abs: shutil.copymode(inputs_abs[0], dst_tmp) mesonlib.replace_if_different(ofile_abs, dst_tmp) if depfile: mlog.log('Reading depfile:', mlog.bold(depfile)) with open(depfile, encoding='utf-8') as f: df = DepFile(f.readlines()) deps = df.get_all_dependencies(ofile_fname) for dep in deps: self.add_build_def_file(dep) elif kwargs['copy']: if len(inputs_abs) != 1: raise InterpreterException('Exactly one input file must be given in copy mode') os.makedirs(os.path.join(self.environment.build_dir, self.subdir), exist_ok=True) shutil.copy2(inputs_abs[0], ofile_abs) # Install file if requested, we check for the empty string # for backwards compatibility. That was the behaviour before # 0.45.0 so preserve it. idir = kwargs['install_dir'] if idir is False: idir = '' FeatureDeprecated.single_use('configure_file install_dir: false', '0.50.0', self.subproject, 'Use the `install:` kwarg instead', location=node) install = kwargs['install'] if kwargs['install'] is not None else idir != '' if install: if not idir: raise InterpreterException( '"install_dir" must be specified when "install" in a configure_file is true') idir_name = idir if isinstance(idir_name, P_OBJ.OptionString): idir_name = idir_name.optname cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname) install_tag = kwargs['install_tag'] self.build.data.append(build.Data([cfile], idir, idir_name, install_mode, self.subproject, install_tag=install_tag, data_type='configure')) return mesonlib.File.from_built_file(self.subdir, output) def extract_incdirs(self, kwargs, key: str = 'include_directories'): prospectives = extract_as_list(kwargs, key) if key == 'include_directories': for i in prospectives: if isinstance(i, str): FeatureNew.single_use('include_directories kwarg of type string', '0.50.0', self.subproject, f'Use include_directories({i!r}) instead', location=self.current_node) break result = [] for p in prospectives: if isinstance(p, build.IncludeDirs): result.append(p) elif isinstance(p, str): result.append(self.build_incdir_object([p])) else: raise InterpreterException('Include directory objects can only be created from strings or include directories.') return result @typed_pos_args('include_directories', varargs=str) @typed_kwargs('include_directories', KwargInfo('is_system', bool, default=False)) def func_include_directories(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncIncludeDirectories') -> build.IncludeDirs: return self.build_incdir_object(args[0], kwargs['is_system']) def build_incdir_object(self, incdir_strings: T.List[str], is_system: bool = False) -> build.IncludeDirs: if not isinstance(is_system, bool): raise InvalidArguments('Is_system must be boolean.') src_root = self.environment.get_source_dir() build_root = self.environment.get_build_dir() absbase_src = os.path.join(src_root, self.subdir) absbase_build = os.path.join(build_root, self.subdir) for a in incdir_strings: if a.startswith(src_root): raise InvalidArguments(textwrap.dedent('''\ Tried to form an absolute path to a dir in the source tree. You should not do that but use relative paths instead, for directories that are part of your project. To get include path to any directory relative to the current dir do incdir = include_directories(dirname) After this incdir will contain both the current source dir as well as the corresponding build dir. It can then be used in any subdirectory and Meson will take care of all the busywork to make paths work. Dirname can even be '.' to mark the current directory. Though you should remember that the current source and build directories are always put in the include directories by default so you only need to do include_directories('.') if you intend to use the result in a different subdirectory. Note that this error message can also be triggered by external dependencies being installed within your source tree - it's not recommended to do this. ''')) else: try: self.validate_within_subproject(self.subdir, a) except InterpreterException: mlog.warning('include_directories sandbox violation!', location=self.current_node) print(textwrap.dedent(f'''\ The project is trying to access the directory {a!r} which belongs to a different subproject. This is a problem as it hardcodes the relative paths of these two projects. This makes it impossible to compile the project in any other directory layout and also prevents the subproject from changing its own directory layout. Instead of poking directly at the internals the subproject should be executed and it should set a variable that the caller can then use. Something like: # In subproject some_dep = declare_dependency(include_directories: include_directories('include')) # In subproject wrap file [provide] some = some_dep # In parent project some_dep = dependency('some') executable(..., dependencies: [some_dep]) This warning will become a hard error in a future Meson release. ''')) absdir_src = os.path.join(absbase_src, a) absdir_build = os.path.join(absbase_build, a) if not os.path.isdir(absdir_src) and not os.path.isdir(absdir_build): raise InvalidArguments(f'Include dir {a} does not exist.') i = build.IncludeDirs(self.subdir, incdir_strings, is_system) return i @typed_pos_args('add_test_setup', str) @typed_kwargs( 'add_test_setup', KwargInfo('exe_wrapper', ContainerTypeInfo(list, (str, ExternalProgram)), listify=True, default=[]), KwargInfo('gdb', bool, default=False), KwargInfo('timeout_multiplier', int, default=1), KwargInfo('exclude_suites', ContainerTypeInfo(list, str), listify=True, default=[], since='0.57.0'), KwargInfo('is_default', bool, default=False, since='0.49.0'), ENV_KW, ) def func_add_test_setup(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'kwtypes.AddTestSetup') -> None: setup_name = args[0] if re.fullmatch('([_a-zA-Z][_0-9a-zA-Z]*:)?[_a-zA-Z][_0-9a-zA-Z]*', setup_name) is None: raise InterpreterException('Setup name may only contain alphanumeric characters.') if ":" not in setup_name: setup_name = f'{(self.subproject if self.subproject else self.build.project_name)}:{setup_name}' exe_wrapper: T.List[str] = [] for i in kwargs['exe_wrapper']: if isinstance(i, str): exe_wrapper.append(i) else: if not i.found(): raise InterpreterException('Tried to use non-found executable.') exe_wrapper += i.get_command() timeout_multiplier = kwargs['timeout_multiplier'] if timeout_multiplier <= 0: FeatureNew('add_test_setup() timeout_multiplier <= 0', '0.57.0').use(self.subproject) if kwargs['is_default']: if self.build.test_setup_default_name is not None: raise InterpreterException(f'{self.build.test_setup_default_name!r} is already set as default. ' 'is_default can be set to true only once') self.build.test_setup_default_name = setup_name self.build.test_setups[setup_name] = build.TestSetup(exe_wrapper, kwargs['gdb'], timeout_multiplier, kwargs['env'], kwargs['exclude_suites']) @typed_pos_args('add_global_arguments', varargs=str) @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW) def func_add_global_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: self._add_global_arguments(node, self.build.global_args[kwargs['native']], args[0], kwargs) @typed_pos_args('add_global_link_arguments', varargs=str) @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW) def func_add_global_link_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: self._add_global_arguments(node, self.build.global_link_args[kwargs['native']], args[0], kwargs) @typed_pos_args('add_project_arguments', varargs=str) @typed_kwargs('add_project_arguments', NATIVE_KW, LANGUAGE_KW) def func_add_project_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: self._add_project_arguments(node, self.build.projects_args[kwargs['native']], args[0], kwargs) @typed_pos_args('add_project_link_arguments', varargs=str) @typed_kwargs('add_global_arguments', NATIVE_KW, LANGUAGE_KW) def func_add_project_link_arguments(self, node: mparser.FunctionNode, args: T.Tuple[T.List[str]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: self._add_project_arguments(node, self.build.projects_link_args[kwargs['native']], args[0], kwargs) @FeatureNew('add_project_dependencies', '0.63.0') @typed_pos_args('add_project_dependencies', varargs=dependencies.Dependency) @typed_kwargs('add_project_dependencies', NATIVE_KW, LANGUAGE_KW) def func_add_project_dependencies(self, node: mparser.FunctionNode, args: T.Tuple[T.List[dependencies.Dependency]], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: for_machine = kwargs['native'] for lang in kwargs['language']: if lang not in self.compilers[for_machine]: raise InvalidCode(f'add_project_dependencies() called before add_language() for language "{lang}"') for d in dependencies.get_leaf_external_dependencies(args[0]): compile_args = list(d.get_compile_args()) system_incdir = d.get_include_type() == 'system' for i in d.get_include_dirs(): for lang in kwargs['language']: comp = self.coredata.compilers[for_machine][lang] for idir in i.to_string_list(self.environment.get_source_dir(), self.environment.get_build_dir()): compile_args.extend(comp.get_include_args(idir, system_incdir)) self._add_project_arguments(node, self.build.projects_args[for_machine], compile_args, kwargs) self._add_project_arguments(node, self.build.projects_link_args[for_machine], d.get_link_args(), kwargs) def _warn_about_builtin_args(self, args: T.List[str]) -> None: # -Wpedantic is deliberately not included, since some people want to use it but not use -Wextra # see e.g. # https://github.com/mesonbuild/meson/issues/3275#issuecomment-641354956 # https://github.com/mesonbuild/meson/issues/3742 warnargs = ('/W1', '/W2', '/W3', '/W4', '/Wall', '-Wall', '-Wextra') optargs = ('-O0', '-O2', '-O3', '-Os', '-Oz', '/O1', '/O2', '/Os') for arg in args: if arg in warnargs: mlog.warning(f'Consider using the built-in warning_level option instead of using "{arg}".', location=self.current_node) elif arg in optargs: mlog.warning(f'Consider using the built-in optimization level instead of using "{arg}".', location=self.current_node) elif arg == '-Werror': mlog.warning(f'Consider using the built-in werror option instead of using "{arg}".', location=self.current_node) elif arg == '-g': mlog.warning(f'Consider using the built-in debug option instead of using "{arg}".', location=self.current_node) elif arg.startswith('-fsanitize'): mlog.warning(f'Consider using the built-in option for sanitizers instead of using "{arg}".', location=self.current_node) elif arg.startswith('-std=') or arg.startswith('/std:'): mlog.warning(f'Consider using the built-in option for language standard version instead of using "{arg}".', location=self.current_node) def _add_global_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.List[str]], args: T.List[str], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: if self.is_subproject(): msg = f'Function \'{node.func_name}\' cannot be used in subprojects because ' \ 'there is no way to make that reliable.\nPlease only call ' \ 'this if is_subproject() returns false. Alternatively, ' \ 'define a variable that\ncontains your language-specific ' \ 'arguments and add it to the appropriate *_args kwarg ' \ 'in each target.' raise InvalidCode(msg) frozen = self.project_args_frozen or self.global_args_frozen self._add_arguments(node, argsdict, frozen, args, kwargs) def _add_project_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.Dict[str, T.List[str]]], args: T.List[str], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: if self.subproject not in argsdict: argsdict[self.subproject] = {} self._add_arguments(node, argsdict[self.subproject], self.project_args_frozen, args, kwargs) def _add_arguments(self, node: mparser.FunctionNode, argsdict: T.Dict[str, T.List[str]], args_frozen: bool, args: T.List[str], kwargs: 'kwtypes.FuncAddProjectArgs') -> None: if args_frozen: msg = f'Tried to use \'{node.func_name}\' after a build target has been declared.\n' \ 'This is not permitted. Please declare all arguments before your targets.' raise InvalidCode(msg) self._warn_about_builtin_args(args) for lang in kwargs['language']: argsdict[lang] = argsdict.get(lang, []) + args @noArgsFlattening @typed_pos_args('environment', optargs=[(str, list, dict)]) @typed_kwargs('environment', ENV_METHOD_KW, ENV_SEPARATOR_KW.evolve(since='0.62.0')) def func_environment(self, node: mparser.FunctionNode, args: T.Tuple[T.Union[None, str, T.List['TYPE_var'], T.Dict[str, 'TYPE_var']]], kwargs: 'TYPE_kwargs') -> build.EnvironmentVariables: init = args[0] if init is not None: FeatureNew.single_use('environment positional arguments', '0.52.0', self.subproject, location=node) msg = ENV_KW.validator(init) if msg: raise InvalidArguments(f'"environment": {msg}') if isinstance(init, dict) and any(i for i in init.values() if isinstance(i, list)): FeatureNew.single_use('List of string in dictionary value', '0.62.0', self.subproject, location=node) return env_convertor_with_method(init, kwargs['method'], kwargs['separator']) return build.EnvironmentVariables() @typed_pos_args('join_paths', varargs=str, min_varargs=1) @noKwargs def func_join_paths(self, node: mparser.BaseNode, args: T.Tuple[T.List[str]], kwargs: 'TYPE_kwargs') -> str: parts = args[0] other = os.path.join('', *parts[1:]).replace('\\', '/') ret = os.path.join(*parts).replace('\\', '/') if isinstance(parts[0], P_OBJ.DependencyVariableString) and '..' not in other: return P_OBJ.DependencyVariableString(ret) elif isinstance(parts[0], P_OBJ.OptionString): name = os.path.join(parts[0].optname, other) return P_OBJ.OptionString(ret, name) else: return ret def run(self) -> None: super().run() mlog.log('Build targets in project:', mlog.bold(str(len(self.build.targets)))) FeatureNew.report(self.subproject) FeatureDeprecated.report(self.subproject) FeatureBroken.report(self.subproject) if not self.is_subproject(): self.print_extra_warnings() self._print_summary() def print_extra_warnings(self) -> None: # TODO cross compilation for c in self.coredata.compilers.host.values(): if c.get_id() == 'clang': self.check_clang_asan_lundef() break def check_clang_asan_lundef(self) -> None: if OptionKey('b_lundef') not in self.coredata.options: return if OptionKey('b_sanitize') not in self.coredata.options: return if (self.coredata.options[OptionKey('b_lundef')].value and self.coredata.options[OptionKey('b_sanitize')].value != 'none'): value = self.coredata.options[OptionKey('b_sanitize')].value mlog.warning(textwrap.dedent(f'''\ Trying to use {value} sanitizer on Clang with b_lundef. This will probably not work. Try setting b_lundef to false instead.'''), location=self.current_node) # noqa: E128 # Check that the indicated file is within the same subproject # as we currently are. This is to stop people doing # nasty things like: # # f = files('../../master_src/file.c') # # Note that this is validated only when the file # object is generated. The result can be used in a different # subproject than it is defined in (due to e.g. a # declare_dependency). def validate_within_subproject(self, subdir, fname): srcdir = Path(self.environment.source_dir) builddir = Path(self.environment.build_dir) if isinstance(fname, P_OBJ.DependencyVariableString): def validate_installable_file(fpath: Path) -> bool: installablefiles: T.Set[Path] = set() for d in self.build.data: for s in d.sources: installablefiles.add(Path(s.absolute_path(srcdir, builddir))) installabledirs = [str(Path(srcdir, s.source_subdir)) for s in self.build.install_dirs] if fpath in installablefiles: return True for d in installabledirs: if str(fpath).startswith(d): return True return False norm = Path(fname) # variables built from a dep.get_variable are allowed to refer to # subproject files, as long as they are scheduled to be installed. if validate_installable_file(norm): return norm = Path(os.path.abspath(Path(srcdir, subdir, fname))) if os.path.isdir(norm): inputtype = 'directory' else: inputtype = 'file' if InterpreterRuleRelaxation.ALLOW_BUILD_DIR_FILE_REFERENCES in self.relaxations and builddir in norm.parents: return if srcdir not in norm.parents: # Grabbing files outside the source tree is ok. # This is for vendor stuff like: # # /opt/vendorsdk/src/file_with_license_restrictions.c return project_root = Path(srcdir, self.root_subdir) subproject_dir = project_root / self.subproject_dir if norm == project_root: return if project_root not in norm.parents: raise InterpreterException(f'Sandbox violation: Tried to grab {inputtype} {norm.name} outside current (sub)project.') if subproject_dir == norm or subproject_dir in norm.parents: raise InterpreterException(f'Sandbox violation: Tried to grab {inputtype} {norm.name} from a nested subproject.') @T.overload def source_strings_to_files(self, sources: T.List['mesonlib.FileOrString'], strict: bool = True) -> T.List['mesonlib.File']: ... @T.overload def source_strings_to_files(self, sources: T.List['mesonlib.FileOrString'], strict: bool = False) -> T.List['mesonlib.FileOrString']: ... # noqa: F811 @T.overload def source_strings_to_files(self, sources: T.List[T.Union[mesonlib.FileOrString, build.GeneratedTypes]]) -> T.List[T.Union[mesonlib.File, build.GeneratedTypes]]: ... # noqa: F811 @T.overload def source_strings_to_files(self, sources: T.List['SourceInputs'], strict: bool = True) -> T.List['SourceOutputs']: ... # noqa: F811 def source_strings_to_files(self, sources: T.List['SourceInputs'], strict: bool = True) -> T.List['SourceOutputs']: # noqa: F811 """Lower inputs to a list of Targets and Files, replacing any strings. :param sources: A raw (Meson DSL) list of inputs (targets, files, and strings) :raises InterpreterException: if any of the inputs are of an invalid type :return: A list of Targets and Files """ mesonlib.check_direntry_issues(sources) if not isinstance(sources, list): sources = [sources] results: T.List['SourceOutputs'] = [] for s in sources: if isinstance(s, str): if not strict and s.startswith(self.environment.get_build_dir()): results.append(s) mlog.warning(f'Source item {s!r} cannot be converted to File object, because it is a generated file. ' 'This will become a hard error in the future.', location=self.current_node) else: self.validate_within_subproject(self.subdir, s) results.append(mesonlib.File.from_source_file(self.environment.source_dir, self.subdir, s)) elif isinstance(s, mesonlib.File): results.append(s) elif isinstance(s, (build.GeneratedList, build.BuildTarget, build.CustomTargetIndex, build.CustomTarget, build.ExtractedObjects, build.StructuredSources)): results.append(s) else: raise InterpreterException(f'Source item is {s!r} instead of ' 'string or File-type object') return results @staticmethod def validate_forbidden_targets(name: str) -> None: if name.startswith('meson-internal__'): raise InvalidArguments("Target names starting with 'meson-internal__' are reserved " "for Meson's internal use. Please rename.") if name.startswith('meson-') and '.' not in name: raise InvalidArguments("Target names starting with 'meson-' and without a file extension " "are reserved for Meson's internal use. Please rename.") if name in coredata.FORBIDDEN_TARGET_NAMES: raise InvalidArguments(f"Target name '{name}' is reserved for Meson's " "internal use. Please rename.") def add_target(self, name: str, tobj: build.Target) -> None: if self.backend.name == 'none': raise InterpreterException('Install-only backend cannot generate target rules, try using `--backend=ninja`.') if name == '': raise InterpreterException('Target name must not be empty.') if name.strip() == '': raise InterpreterException('Target name must not consist only of whitespace.') if has_path_sep(name): pathseg = os.path.join(self.subdir, os.path.split(name)[0]) if os.path.exists(os.path.join(self.source_root, pathseg)): raise InvalidArguments(textwrap.dedent(f'''\ Target "{name}" has a path segment pointing to directory "{pathseg}". This is an error. To define a target that builds in that directory you must define it in the meson.build file in that directory. ''')) self.validate_forbidden_targets(name) # To permit an executable and a shared library to have the # same name, such as "foo.exe" and "libfoo.a". idname = tobj.get_id() if idname in self.build.targets: raise InvalidCode(f'Tried to create target "{name}", but a target of that name already exists.') if isinstance(tobj, build.BuildTarget): missing_languages = tobj.process_compilers() self.add_languages(missing_languages, True, tobj.for_machine) tobj.process_compilers_late(missing_languages) self.add_stdlib_info(tobj) self.build.targets[idname] = tobj if idname not in self.coredata.target_guids: self.coredata.target_guids[idname] = str(uuid.uuid4()).upper() @FeatureNew('both_libraries', '0.46.0') def build_both_libraries(self, node, args, kwargs): shared_lib = self.build_target(node, args, kwargs, build.SharedLibrary) static_lib = self.build_target(node, args, kwargs, build.StaticLibrary) if self.backend.name == 'xcode': # Xcode is a bit special in that you can't (at least for the moment) # form a library only from object file inputs. The simple but inefficient # solution is to use the sources directly. This will lead to them being # built twice. This is unfortunate and slow, but at least it works. # Feel free to submit patches to get this fixed if it is an # issue for you. reuse_object_files = False else: reuse_object_files = static_lib.pic if reuse_object_files: # Replace sources with objects from the shared library to avoid # building them twice. We post-process the static library instead of # removing sources from args because sources could also come from # any InternalDependency, see BuildTarget.add_deps(). static_lib.objects.append(build.ExtractedObjects(shared_lib, shared_lib.sources, shared_lib.generated, [])) static_lib.sources = [] static_lib.generated = [] # Compilers with no corresponding sources confuses the backend. # Keep only compilers used for linking static_lib.compilers = {k: v for k, v in static_lib.compilers.items() if k in compilers.clink_langs} return build.BothLibraries(shared_lib, static_lib) def build_library(self, node, args, kwargs): default_library = self.coredata.get_option(OptionKey('default_library', subproject=self.subproject)) if default_library == 'shared': return self.build_target(node, args, kwargs, build.SharedLibrary) elif default_library == 'static': return self.build_target(node, args, kwargs, build.StaticLibrary) elif default_library == 'both': return self.build_both_libraries(node, args, kwargs) else: raise InterpreterException(f'Unknown default_library value: {default_library}.') def build_target(self, node: mparser.BaseNode, args, kwargs, targetclass): @FeatureNewKwargs('build target', '1.2.0', ['rust_dependency_map']) @FeatureNewKwargs('build target', '0.42.0', ['rust_crate_type', 'build_rpath', 'implicit_include_directories']) @FeatureNewKwargs('build target', '0.41.0', ['rust_args']) @FeatureNewKwargs('build target', '0.38.0', ['build_by_default']) @FeatureNewKwargs('build target', '0.48.0', ['gnu_symbol_visibility']) def build_target_decorator_caller(self, node, args, kwargs): return True build_target_decorator_caller(self, node, args, kwargs) name, sources = args for_machine = self.machine_from_native_kwarg(kwargs) if 'sources' in kwargs: sources += listify(kwargs['sources']) if any(isinstance(s, build.BuildTarget) for s in sources): FeatureBroken.single_use('passing references to built targets as a source file', '1.1.0', self.subproject, 'Consider using `link_with` or `link_whole` if you meant to link, or dropping them as otherwise they are ignored.', node) if any(isinstance(s, build.ExtractedObjects) for s in sources): FeatureBroken.single_use('passing object files as sources', '1.1.0', self.subproject, 'Pass these to the `objects` keyword instead, they are ignored when passed as sources.', node) # Go ahead and drop these here, since they're only allowed through for # backwards compatibility anyway sources = [s for s in sources if not isinstance(s, (build.BuildTarget, build.ExtractedObjects))] sources = self.source_strings_to_files(sources) objs = extract_as_list(kwargs, 'objects') kwargs['dependencies'] = extract_as_list(kwargs, 'dependencies') kwargs['install_mode'] = self._get_kwarg_install_mode(kwargs) if 'extra_files' in kwargs: ef = extract_as_list(kwargs, 'extra_files') kwargs['extra_files'] = self.source_strings_to_files(ef) self.check_sources_exist(os.path.join(self.source_root, self.subdir), sources) if targetclass not in {build.Executable, build.SharedLibrary, build.SharedModule, build.StaticLibrary, build.Jar}: mlog.debug('Unknown target type:', str(targetclass)) raise RuntimeError('Unreachable code') self.kwarg_strings_to_includedirs(kwargs) # Filter out kwargs from other target types. For example 'soversion' # passed to library() when default_library == 'static'. kwargs = {k: v for k, v in kwargs.items() if k in targetclass.known_kwargs} srcs: T.List['SourceInputs'] = [] struct: T.Optional[build.StructuredSources] = build.StructuredSources() for s in sources: if isinstance(s, build.StructuredSources): struct = struct + s else: srcs.append(s) if not struct: struct = None else: # Validate that we won't end up with two outputs with the same name. # i.e, don't allow: # [structured_sources('foo/bar.rs'), structured_sources('bar/bar.rs')] for v in struct.sources.values(): outputs: T.Set[str] = set() for f in v: o: T.List[str] if isinstance(f, str): o = [os.path.basename(f)] elif isinstance(f, mesonlib.File): o = [f.fname] else: o = f.get_outputs() conflicts = outputs.intersection(o) if conflicts: raise InvalidArguments.from_node( f"Conflicting sources in structured sources: {', '.join(sorted(conflicts))}", node=node) outputs.update(o) kwargs['include_directories'] = self.extract_incdirs(kwargs) target = targetclass(name, self.subdir, self.subproject, for_machine, srcs, struct, objs, self.environment, self.compilers[for_machine], kwargs) target.project_version = self.project_version self.add_target(name, target) self.project_args_frozen = True return target def kwarg_strings_to_includedirs(self, kwargs): if 'd_import_dirs' in kwargs: items = mesonlib.extract_as_list(kwargs, 'd_import_dirs') cleaned_items = [] for i in items: if isinstance(i, str): # BW compatibility. This was permitted so we must support it # for a few releases so people can transition to "correct" # path declarations. if os.path.normpath(i).startswith(self.environment.get_source_dir()): mlog.warning('''Building a path to the source dir is not supported. Use a relative path instead. This will become a hard error in the future.''', location=self.current_node) i = os.path.relpath(i, os.path.join(self.environment.get_source_dir(), self.subdir)) i = self.build_incdir_object([i]) cleaned_items.append(i) kwargs['d_import_dirs'] = cleaned_items def add_stdlib_info(self, target): for l in target.compilers.keys(): dep = self.build.stdlibs[target.for_machine].get(l, None) if dep: target.add_deps(dep) def check_sources_exist(self, subdir, sources): for s in sources: if not isinstance(s, str): continue # This means a generated source and they always exist. fname = os.path.join(subdir, s) if not os.path.isfile(fname): raise InterpreterException(f'Tried to add non-existing source file {s}.') # Only permit object extraction from the same subproject def validate_extraction(self, buildtarget: mesonlib.HoldableObject) -> None: if self.subproject != buildtarget.subproject: raise InterpreterException('Tried to extract objects from a different subproject.') def is_subproject(self) -> bool: return self.subproject != '' @typed_pos_args('set_variable', str, object) @noKwargs @noArgsFlattening @noSecondLevelHolderResolving def func_set_variable(self, node: mparser.BaseNode, args: T.Tuple[str, object], kwargs: 'TYPE_kwargs') -> None: varname, value = args self.set_variable(varname, value, holderify=True) @typed_pos_args('get_variable', (str, Disabler), optargs=[object]) @noKwargs @noArgsFlattening @unholder_return def func_get_variable(self, node: mparser.BaseNode, args: T.Tuple[T.Union[str, Disabler], T.Optional[object]], kwargs: 'TYPE_kwargs') -> 'TYPE_var': varname, fallback = args if isinstance(varname, Disabler): return varname try: return self.variables[varname] except KeyError: if fallback is not None: return self._holderify(fallback) raise InterpreterException(f'Tried to get unknown variable "{varname}".') @typed_pos_args('is_variable', str) @noKwargs def func_is_variable(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> bool: return args[0] in self.variables @FeatureNew('unset_variable', '0.60.0') @typed_pos_args('unset_variable', str) @noKwargs def func_unset_variable(self, node: mparser.BaseNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> None: varname = args[0] try: del self.variables[varname] except KeyError: raise InterpreterException(f'Tried to unset unknown variable "{varname}".') @staticmethod def machine_from_native_kwarg(kwargs: T.Dict[str, T.Any]) -> MachineChoice: native = kwargs.get('native', False) if not isinstance(native, bool): raise InvalidArguments('Argument to "native" must be a boolean.') return MachineChoice.BUILD if native else MachineChoice.HOST @FeatureNew('is_disabler', '0.52.0') @typed_pos_args('is_disabler', object) @noKwargs def func_is_disabler(self, node: mparser.BaseNode, args: T.Tuple[object], kwargs: 'TYPE_kwargs') -> bool: return isinstance(args[0], Disabler) @noKwargs @FeatureNew('range', '0.58.0') @typed_pos_args('range', int, optargs=[int, int]) def func_range(self, node, args: T.Tuple[int, T.Optional[int], T.Optional[int]], kwargs: T.Dict[str, T.Any]) -> P_OBJ.RangeHolder: start, stop, step = args # Just like Python's range, we allow range(stop), range(start, stop), or # range(start, stop, step) if stop is None: stop = start start = 0 if step is None: step = 1 # This is more strict than Python's range() if start < 0: raise InterpreterException('start cannot be negative') if stop < start: raise InterpreterException('stop cannot be less than start') if step < 1: raise InterpreterException('step must be >=1') return P_OBJ.RangeHolder(start, stop, step, subproject=self.subproject)