diff options
Diffstat (limited to 'mesonbuild/interpreter/interpreterobjects.py')
| -rw-r--r-- | mesonbuild/interpreter/interpreterobjects.py | 999 |
1 files changed, 999 insertions, 0 deletions
diff --git a/mesonbuild/interpreter/interpreterobjects.py b/mesonbuild/interpreter/interpreterobjects.py new file mode 100644 index 0000000..7d43752 --- /dev/null +++ b/mesonbuild/interpreter/interpreterobjects.py @@ -0,0 +1,999 @@ +import os +import shlex +import subprocess +import re + +from pathlib import Path, PurePath + +from .. import mesonlib +from .. import coredata +from .. import build +from .. import mlog + +from ..modules import ModuleReturnValue, ModuleObject, ModuleState +from ..backend.backends import TestProtocol +from ..interpreterbase import (InterpreterObject, ObjectHolder, MutableInterpreterObject, + FeatureNewKwargs, FeatureNew, FeatureDeprecated, + typed_pos_args, stringArgs, permittedKwargs, + noArgsFlattening, noPosargs, TYPE_var, TYPE_nkwargs, + flatten, InterpreterException, InvalidArguments, InvalidCode) +from ..dependencies import Dependency, ExternalLibrary, InternalDependency +from ..programs import ExternalProgram +from ..mesonlib import FileMode, OptionKey, listify, Popen_safe + +import typing as T + +def extract_required_kwarg(kwargs, subproject, feature_check=None, default=True): + val = kwargs.get('required', default) + disabled = False + required = False + feature = None + if isinstance(val, FeatureOptionHolder): + if not feature_check: + feature_check = FeatureNew('User option "feature"', '0.47.0') + feature_check.use(subproject) + option = val.held_object + feature = val.name + if option.is_disabled(): + disabled = True + elif option.is_enabled(): + required = True + elif isinstance(val, bool): + required = val + else: + raise InterpreterException('required keyword argument must be boolean or a feature option') + + # Keep boolean value in kwargs to simplify other places where this kwarg is + # checked. + kwargs['required'] = required + + return disabled, required, feature + +def extract_search_dirs(kwargs): + search_dirs = mesonlib.stringlistify(kwargs.get('dirs', [])) + search_dirs = [Path(d).expanduser() for d in search_dirs] + for d in search_dirs: + if mesonlib.is_windows() and d.root.startswith('\\'): + # a Unix-path starting with `/` that is not absolute on Windows. + # discard without failing for end-user ease of cross-platform directory arrays + continue + if not d.is_absolute(): + raise InvalidCode(f'Search directory {d} is not an absolute path.') + return list(map(str, search_dirs)) + +class FeatureOptionHolder(InterpreterObject, ObjectHolder[coredata.UserFeatureOption]): + def __init__(self, env: 'Environment', name: str, option: coredata.UserFeatureOption): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, option) + if option.is_auto(): + # TODO: we need to case here because options is not a TypedDict + self.held_object = T.cast(coredata.UserFeatureOption, env.coredata.options[OptionKey('auto_features')]) + self.name = name + self.methods.update({'enabled': self.enabled_method, + 'disabled': self.disabled_method, + 'auto': self.auto_method, + }) + + @noPosargs + @permittedKwargs({}) + def enabled_method(self, args, kwargs): + return self.held_object.is_enabled() + + @noPosargs + @permittedKwargs({}) + def disabled_method(self, args, kwargs): + return self.held_object.is_disabled() + + @noPosargs + @permittedKwargs({}) + def auto_method(self, args, kwargs): + return self.held_object.is_auto() + +class RunProcess(InterpreterObject): + + def __init__(self, cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir=False, check=False, capture=True): + super().__init__() + if not isinstance(cmd, ExternalProgram): + raise AssertionError('BUG: RunProcess must be passed an ExternalProgram') + self.capture = capture + pc, self.stdout, self.stderr = self.run_command(cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check) + self.returncode = pc.returncode + self.methods.update({'returncode': self.returncode_method, + 'stdout': self.stdout_method, + 'stderr': self.stderr_method, + }) + + def run_command(self, cmd, args, env, source_dir, build_dir, subdir, mesonintrospect, in_builddir, check=False): + command_array = cmd.get_command() + args + menv = {'MESON_SOURCE_ROOT': source_dir, + 'MESON_BUILD_ROOT': build_dir, + 'MESON_SUBDIR': subdir, + 'MESONINTROSPECT': ' '.join([shlex.quote(x) for x in mesonintrospect]), + } + if in_builddir: + cwd = os.path.join(build_dir, subdir) + else: + cwd = os.path.join(source_dir, subdir) + child_env = os.environ.copy() + child_env.update(menv) + child_env = env.get_env(child_env) + stdout = subprocess.PIPE if self.capture else subprocess.DEVNULL + mlog.debug('Running command:', ' '.join(command_array)) + try: + p, o, e = Popen_safe(command_array, stdout=stdout, env=child_env, cwd=cwd) + if self.capture: + mlog.debug('--- stdout ---') + mlog.debug(o) + else: + o = '' + mlog.debug('--- stdout disabled ---') + mlog.debug('--- stderr ---') + mlog.debug(e) + mlog.debug('') + + if check and p.returncode != 0: + raise InterpreterException('Command "{}" failed with status {}.'.format(' '.join(command_array), p.returncode)) + + return p, o, e + except FileNotFoundError: + raise InterpreterException('Could not execute command "%s".' % ' '.join(command_array)) + + @noPosargs + @permittedKwargs({}) + def returncode_method(self, args, kwargs): + return self.returncode + + @noPosargs + @permittedKwargs({}) + def stdout_method(self, args, kwargs): + return self.stdout + + @noPosargs + @permittedKwargs({}) + def stderr_method(self, args, kwargs): + return self.stderr + +class EnvironmentVariablesHolder(MutableInterpreterObject, ObjectHolder[build.EnvironmentVariables]): + def __init__(self, initial_values=None, subproject: str = ''): + MutableInterpreterObject.__init__(self) + ObjectHolder.__init__(self, build.EnvironmentVariables(), subproject) + self.methods.update({'set': self.set_method, + 'append': self.append_method, + 'prepend': self.prepend_method, + }) + if isinstance(initial_values, dict): + for k, v in initial_values.items(): + self.set_method([k, v], {}) + elif initial_values is not None: + for e in mesonlib.stringlistify(initial_values): + if '=' not in e: + raise InterpreterException('Env var definition must be of type key=val.') + (k, val) = e.split('=', 1) + k = k.strip() + val = val.strip() + if ' ' in k: + raise InterpreterException('Env var key must not have spaces in it.') + self.set_method([k, val], {}) + + def __repr__(self) -> str: + repr_str = "<{0}: {1}>" + return repr_str.format(self.__class__.__name__, self.held_object.envvars) + + def unpack_separator(self, kwargs: T.Dict[str, T.Any]) -> str: + separator = kwargs.get('separator', os.pathsep) + if not isinstance(separator, str): + raise InterpreterException("EnvironmentVariablesHolder methods 'separator'" + " argument needs to be a string.") + return separator + + def warn_if_has_name(self, name: str) -> None: + # Multiple append/prepend operations was not supported until 0.58.0. + if self.held_object.has_name(name): + m = f'Overriding previous value of environment variable {name!r} with a new one' + FeatureNew('0.58.0', m).use(self.subproject) + + @stringArgs + @permittedKwargs({'separator'}) + @typed_pos_args('environment.set', str, varargs=str, min_varargs=1) + def set_method(self, args: T.Tuple[str, T.List[str]], kwargs: T.Dict[str, T.Any]) -> None: + name, values = args + separator = self.unpack_separator(kwargs) + self.held_object.set(name, values, separator) + + @stringArgs + @permittedKwargs({'separator'}) + @typed_pos_args('environment.append', str, varargs=str, min_varargs=1) + def append_method(self, args: T.Tuple[str, T.List[str]], kwargs: T.Dict[str, T.Any]) -> None: + name, values = args + separator = self.unpack_separator(kwargs) + self.warn_if_has_name(name) + self.held_object.append(name, values, separator) + + @stringArgs + @permittedKwargs({'separator'}) + @typed_pos_args('environment.prepend', str, varargs=str, min_varargs=1) + def prepend_method(self, args: T.Tuple[str, T.List[str]], kwargs: T.Dict[str, T.Any]) -> None: + name, values = args + separator = self.unpack_separator(kwargs) + self.warn_if_has_name(name) + self.held_object.prepend(name, values, separator) + + +class ConfigurationDataHolder(MutableInterpreterObject, ObjectHolder[build.ConfigurationData]): + def __init__(self, pv, initial_values=None): + MutableInterpreterObject.__init__(self) + self.used = False # These objects become immutable after use in configure_file. + ObjectHolder.__init__(self, build.ConfigurationData(), pv) + self.methods.update({'set': self.set_method, + 'set10': self.set10_method, + 'set_quoted': self.set_quoted_method, + 'has': self.has_method, + 'get': self.get_method, + 'keys': self.keys_method, + 'get_unquoted': self.get_unquoted_method, + 'merge_from': self.merge_from_method, + }) + if isinstance(initial_values, dict): + for k, v in initial_values.items(): + self.set_method([k, v], {}) + elif initial_values: + raise AssertionError('Unsupported ConfigurationDataHolder initial_values') + + def is_used(self): + return self.used + + def mark_used(self): + self.used = True + + def validate_args(self, args, kwargs): + if len(args) == 1 and isinstance(args[0], list) and len(args[0]) == 2: + mlog.deprecation('Passing a list as the single argument to ' + 'configuration_data.set is deprecated. This will ' + 'become a hard error in the future.', + location=self.current_node) + args = args[0] + + if len(args) != 2: + raise InterpreterException("Configuration set requires 2 arguments.") + if self.used: + raise InterpreterException("Can not set values on configuration object that has been used.") + name, val = args + if not isinstance(val, (int, str)): + msg = 'Setting a configuration data value to {!r} is invalid, ' \ + 'and will fail at configure_file(). If you are using it ' \ + 'just to store some values, please use a dict instead.' + mlog.deprecation(msg.format(val), location=self.current_node) + desc = kwargs.get('description', None) + if not isinstance(name, str): + raise InterpreterException("First argument to set must be a string.") + if desc is not None and not isinstance(desc, str): + raise InterpreterException('Description must be a string.') + + return name, val, desc + + @noArgsFlattening + def set_method(self, args, kwargs): + (name, val, desc) = self.validate_args(args, kwargs) + self.held_object.values[name] = (val, desc) + + def set_quoted_method(self, args, kwargs): + (name, val, desc) = self.validate_args(args, kwargs) + if not isinstance(val, str): + raise InterpreterException("Second argument to set_quoted must be a string.") + escaped_val = '\\"'.join(val.split('"')) + self.held_object.values[name] = ('"' + escaped_val + '"', desc) + + def set10_method(self, args, kwargs): + (name, val, desc) = self.validate_args(args, kwargs) + if val: + self.held_object.values[name] = (1, desc) + else: + self.held_object.values[name] = (0, desc) + + def has_method(self, args, kwargs): + return args[0] in self.held_object.values + + @FeatureNew('configuration_data.get()', '0.38.0') + @noArgsFlattening + def get_method(self, args, kwargs): + if len(args) < 1 or len(args) > 2: + raise InterpreterException('Get method takes one or two arguments.') + name = args[0] + if name in self.held_object: + return self.held_object.get(name)[0] + if len(args) > 1: + return args[1] + raise InterpreterException('Entry %s not in configuration data.' % name) + + @FeatureNew('configuration_data.get_unquoted()', '0.44.0') + def get_unquoted_method(self, args, kwargs): + if len(args) < 1 or len(args) > 2: + raise InterpreterException('Get method takes one or two arguments.') + name = args[0] + if name in self.held_object: + val = self.held_object.get(name)[0] + elif len(args) > 1: + val = args[1] + else: + raise InterpreterException('Entry %s not in configuration data.' % name) + if val[0] == '"' and val[-1] == '"': + return val[1:-1] + return val + + def get(self, name): + return self.held_object.values[name] # (val, desc) + + @FeatureNew('configuration_data.keys()', '0.57.0') + @noPosargs + def keys_method(self, args, kwargs): + return sorted(self.keys()) + + def keys(self): + return self.held_object.values.keys() + + def merge_from_method(self, args, kwargs): + if len(args) != 1: + raise InterpreterException('Merge_from takes one positional argument.') + from_object = args[0] + if not isinstance(from_object, ConfigurationDataHolder): + raise InterpreterException('Merge_from argument must be a configuration data object.') + from_object = from_object.held_object + for k, v in from_object.values.items(): + self.held_object.values[k] = v + +permitted_partial_dependency_kwargs = { + 'compile_args', 'link_args', 'links', 'includes', 'sources' +} + +class DependencyHolder(InterpreterObject, ObjectHolder[Dependency]): + def __init__(self, dep: Dependency, pv: str): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, dep, pv) + self.methods.update({'found': self.found_method, + 'type_name': self.type_name_method, + 'version': self.version_method, + 'name': self.name_method, + 'get_pkgconfig_variable': self.pkgconfig_method, + 'get_configtool_variable': self.configtool_method, + 'get_variable': self.variable_method, + 'partial_dependency': self.partial_dependency_method, + 'include_type': self.include_type_method, + 'as_system': self.as_system_method, + 'as_link_whole': self.as_link_whole_method, + }) + + def found(self): + return self.found_method([], {}) + + @noPosargs + @permittedKwargs({}) + def type_name_method(self, args, kwargs): + return self.held_object.type_name + + @noPosargs + @permittedKwargs({}) + def found_method(self, args, kwargs): + if self.held_object.type_name == 'internal': + return True + return self.held_object.found() + + @noPosargs + @permittedKwargs({}) + def version_method(self, args, kwargs): + return self.held_object.get_version() + + @noPosargs + @permittedKwargs({}) + def name_method(self, args, kwargs): + return self.held_object.get_name() + + @FeatureDeprecated('Dependency.get_pkgconfig_variable', '0.56.0', + 'use Dependency.get_variable(pkgconfig : ...) instead') + @permittedKwargs({'define_variable', 'default'}) + def pkgconfig_method(self, args, kwargs): + args = listify(args) + if len(args) != 1: + raise InterpreterException('get_pkgconfig_variable takes exactly one argument.') + varname = args[0] + if not isinstance(varname, str): + raise InterpreterException('Variable name must be a string.') + return self.held_object.get_pkgconfig_variable(varname, kwargs) + + @FeatureNew('dep.get_configtool_variable', '0.44.0') + @FeatureDeprecated('Dependency.get_configtool_variable', '0.56.0', + 'use Dependency.get_variable(configtool : ...) instead') + @permittedKwargs({}) + def configtool_method(self, args, kwargs): + args = listify(args) + if len(args) != 1: + raise InterpreterException('get_configtool_variable takes exactly one argument.') + varname = args[0] + if not isinstance(varname, str): + raise InterpreterException('Variable name must be a string.') + return self.held_object.get_configtool_variable(varname) + + @FeatureNew('dep.partial_dependency', '0.46.0') + @noPosargs + @permittedKwargs(permitted_partial_dependency_kwargs) + def partial_dependency_method(self, args, kwargs): + pdep = self.held_object.get_partial_dependency(**kwargs) + return DependencyHolder(pdep, self.subproject) + + @FeatureNew('dep.get_variable', '0.51.0') + @typed_pos_args('dep.get_variable', optargs=[str]) + @permittedKwargs({'cmake', 'pkgconfig', 'configtool', 'internal', 'default_value', 'pkgconfig_define'}) + @FeatureNewKwargs('dep.get_variable', '0.54.0', ['internal']) + def variable_method(self, args: T.Tuple[T.Optional[str]], kwargs: T.Dict[str, T.Any]) -> str: + default_varname = args[0] + if default_varname is not None: + FeatureNew('0.58.0', 'Positional argument to dep.get_variable()').use(self.subproject) + for k in ['cmake', 'pkgconfig', 'configtool', 'internal']: + kwargs.setdefault(k, default_varname) + return self.held_object.get_variable(**kwargs) + + @FeatureNew('dep.include_type', '0.52.0') + @noPosargs + @permittedKwargs({}) + def include_type_method(self, args, kwargs): + return self.held_object.get_include_type() + + @FeatureNew('dep.as_system', '0.52.0') + @permittedKwargs({}) + def as_system_method(self, args, kwargs): + args = listify(args) + new_is_system = 'system' + if len(args) > 1: + raise InterpreterException('as_system takes only one optional value') + if len(args) == 1: + new_is_system = args[0] + new_dep = self.held_object.generate_system_dependency(new_is_system) + return DependencyHolder(new_dep, self.subproject) + + @FeatureNew('dep.as_link_whole', '0.56.0') + @permittedKwargs({}) + @noPosargs + def as_link_whole_method(self, args, kwargs): + if not isinstance(self.held_object, InternalDependency): + raise InterpreterException('as_link_whole method is only supported on declare_dependency() objects') + new_dep = self.held_object.generate_link_whole_dependency() + return DependencyHolder(new_dep, self.subproject) + +class ExternalProgramHolder(InterpreterObject, ObjectHolder[ExternalProgram]): + def __init__(self, ep: ExternalProgram, subproject: str, backend=None): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, ep) + self.subproject = subproject + self.backend = backend + self.methods.update({'found': self.found_method, + 'path': self.path_method, + 'full_path': self.full_path_method}) + self.cached_version = None + + @noPosargs + @permittedKwargs({}) + def found_method(self, args, kwargs): + return self.found() + + @noPosargs + @permittedKwargs({}) + @FeatureDeprecated('ExternalProgram.path', '0.55.0', + 'use ExternalProgram.full_path() instead') + def path_method(self, args, kwargs): + return self._full_path() + + @noPosargs + @permittedKwargs({}) + @FeatureNew('ExternalProgram.full_path', '0.55.0') + def full_path_method(self, args, kwargs): + return self._full_path() + + def _full_path(self): + exe = self.held_object + if isinstance(exe, build.Executable): + return self.backend.get_target_filename_abs(exe) + return exe.get_path() + + def found(self): + return isinstance(self.held_object, build.Executable) or self.held_object.found() + + def get_command(self): + return self.held_object.get_command() + + def get_name(self): + exe = self.held_object + if isinstance(exe, build.Executable): + return exe.name + return exe.get_name() + + def get_version(self, interpreter): + if isinstance(self.held_object, build.Executable): + return self.held_object.project_version + if not self.cached_version: + raw_cmd = self.get_command() + ['--version'] + cmd = [self, '--version'] + res = interpreter.run_command_impl(interpreter.current_node, cmd, {}, True) + if res.returncode != 0: + m = 'Running {!r} failed' + raise InterpreterException(m.format(raw_cmd)) + output = res.stdout.strip() + if not output: + output = res.stderr.strip() + match = re.search(r'([0-9][0-9\.]+)', output) + if not match: + m = 'Could not find a version number in output of {!r}' + raise InterpreterException(m.format(raw_cmd)) + self.cached_version = match.group(1) + return self.cached_version + +class ExternalLibraryHolder(InterpreterObject, ObjectHolder[ExternalLibrary]): + def __init__(self, el: ExternalLibrary, pv: str): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, el, pv) + self.methods.update({'found': self.found_method, + 'type_name': self.type_name_method, + 'partial_dependency': self.partial_dependency_method, + }) + + def found(self): + return self.held_object.found() + + @noPosargs + @permittedKwargs({}) + def type_name_method(self, args, kwargs): + return self.held_object.type_name + + @noPosargs + @permittedKwargs({}) + def found_method(self, args, kwargs): + return self.found() + + def get_name(self): + return self.held_object.name + + def get_compile_args(self): + return self.held_object.get_compile_args() + + def get_link_args(self): + return self.held_object.get_link_args() + + def get_exe_args(self): + return self.held_object.get_exe_args() + + @FeatureNew('dep.partial_dependency', '0.46.0') + @noPosargs + @permittedKwargs(permitted_partial_dependency_kwargs) + def partial_dependency_method(self, args, kwargs): + pdep = self.held_object.get_partial_dependency(**kwargs) + return DependencyHolder(pdep, self.subproject) + +class GeneratorHolder(InterpreterObject, ObjectHolder[build.Generator]): + @FeatureNewKwargs('generator', '0.43.0', ['capture']) + def __init__(self, interp, args, kwargs): + self.interpreter = interp + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, build.Generator(args, kwargs), interp.subproject) + self.methods.update({'process': self.process_method}) + + @FeatureNewKwargs('generator.process', '0.45.0', ['preserve_path_from']) + @permittedKwargs({'extra_args', 'preserve_path_from'}) + def process_method(self, args, kwargs): + extras = mesonlib.stringlistify(kwargs.get('extra_args', [])) + if 'preserve_path_from' in kwargs: + preserve_path_from = kwargs['preserve_path_from'] + if not isinstance(preserve_path_from, str): + raise InvalidArguments('Preserve_path_from must be a string.') + preserve_path_from = os.path.normpath(preserve_path_from) + if not os.path.isabs(preserve_path_from): + # This is a bit of a hack. Fix properly before merging. + raise InvalidArguments('Preserve_path_from must be an absolute path for now. Sorry.') + else: + preserve_path_from = None + gl = self.held_object.process_files('Generator', args, self.interpreter, + preserve_path_from, extra_args=extras) + return GeneratedListHolder(gl) + + +class GeneratedListHolder(InterpreterObject, ObjectHolder[build.GeneratedList]): + def __init__(self, arg1, extra_args=None): + InterpreterObject.__init__(self) + if isinstance(arg1, GeneratorHolder): + ObjectHolder.__init__(self, build.GeneratedList(arg1.held_object, extra_args if extra_args is not None else [])) + else: + ObjectHolder.__init__(self, arg1) + + def __repr__(self): + r = '<{}: {!r}>' + return r.format(self.__class__.__name__, self.held_object.get_outputs()) + + def add_file(self, a): + self.held_object.add_file(a) + +# A machine that's statically known from the cross file +class MachineHolder(InterpreterObject, ObjectHolder['MachineInfo']): + def __init__(self, machine_info: 'MachineInfo'): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, machine_info) + self.methods.update({'system': self.system_method, + 'cpu': self.cpu_method, + 'cpu_family': self.cpu_family_method, + 'endian': self.endian_method, + }) + + @noPosargs + @permittedKwargs({}) + def cpu_family_method(self, args: T.List[TYPE_var], kwargs: TYPE_nkwargs) -> str: + return self.held_object.cpu_family + + @noPosargs + @permittedKwargs({}) + def cpu_method(self, args: T.List[TYPE_var], kwargs: TYPE_nkwargs) -> str: + return self.held_object.cpu + + @noPosargs + @permittedKwargs({}) + def system_method(self, args: T.List[TYPE_var], kwargs: TYPE_nkwargs) -> str: + return self.held_object.system + + @noPosargs + @permittedKwargs({}) + def endian_method(self, args: T.List[TYPE_var], kwargs: TYPE_nkwargs) -> str: + return self.held_object.endian + +class IncludeDirsHolder(InterpreterObject, ObjectHolder[build.IncludeDirs]): + def __init__(self, idobj: build.IncludeDirs): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, idobj) + +class HeadersHolder(InterpreterObject, ObjectHolder[build.Headers]): + + def __init__(self, obj: build.Headers): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, obj) + + def set_install_subdir(self, subdir): + self.held_object.install_subdir = subdir + + def get_install_subdir(self): + return self.held_object.install_subdir + + def get_sources(self): + return self.held_object.sources + + def get_custom_install_dir(self): + return self.held_object.custom_install_dir + + def get_custom_install_mode(self): + return self.held_object.custom_install_mode + +class DataHolder(InterpreterObject, ObjectHolder[build.Data]): + def __init__(self, data: build.Data): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, data) + + def get_source_subdir(self): + return self.held_object.source_subdir + + def get_sources(self): + return self.held_object.sources + + def get_install_dir(self): + return self.held_object.install_dir + +class InstallDirHolder(InterpreterObject, ObjectHolder[build.IncludeDirs]): + + def __init__(self, obj: build.InstallDir): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, obj) + +class ManHolder(InterpreterObject, ObjectHolder[build.Man]): + + def __init__(self, obj: build.Man): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, obj) + + def get_custom_install_dir(self) -> T.Optional[str]: + return self.held_object.custom_install_dir + + def get_custom_install_mode(self) -> T.Optional[FileMode]: + return self.held_object.custom_install_mode + + def locale(self) -> T.Optional[str]: + return self.held_object.locale + + def get_sources(self) -> T.List[mesonlib.File]: + return self.held_object.sources + +class GeneratedObjectsHolder(InterpreterObject, ObjectHolder[build.ExtractedObjects]): + def __init__(self, held_object: build.ExtractedObjects): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, held_object) + +class Test(InterpreterObject): + def __init__(self, name: str, project: str, suite: T.List[str], exe: build.Executable, + depends: T.List[T.Union[build.CustomTarget, build.BuildTarget]], + is_parallel: bool, cmd_args: T.List[str], env: build.EnvironmentVariables, + should_fail: bool, timeout: int, workdir: T.Optional[str], protocol: str, + priority: int): + InterpreterObject.__init__(self) + self.name = name + self.suite = suite + self.project_name = project + self.exe = exe + self.depends = depends + self.is_parallel = is_parallel + self.cmd_args = cmd_args + self.env = env + self.should_fail = should_fail + self.timeout = timeout + self.workdir = workdir + self.protocol = TestProtocol.from_str(protocol) + self.priority = priority + + def get_exe(self): + return self.exe + + def get_name(self): + return self.name + +class SubprojectHolder(InterpreterObject, ObjectHolder[T.Optional['Interpreter']]): + + def __init__(self, subinterpreter: T.Optional['Interpreter'], subdir: str, warnings=0, disabled_feature=None, + exception=None): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, subinterpreter) + self.warnings = warnings + self.disabled_feature = disabled_feature + self.exception = exception + self.subdir = PurePath(subdir).as_posix() + self.methods.update({'get_variable': self.get_variable_method, + 'found': self.found_method, + }) + + @noPosargs + @permittedKwargs({}) + def found_method(self, args, kwargs): + return self.found() + + def found(self): + return self.held_object is not None + + @permittedKwargs({}) + @noArgsFlattening + def get_variable_method(self, args, kwargs): + if len(args) < 1 or len(args) > 2: + raise InterpreterException('Get_variable takes one or two arguments.') + if not self.found(): + raise InterpreterException('Subproject "%s" disabled can\'t get_variable on it.' % (self.subdir)) + varname = args[0] + if not isinstance(varname, str): + raise InterpreterException('Get_variable first argument must be a string.') + try: + return self.held_object.variables[varname] + except KeyError: + pass + + if len(args) == 2: + return args[1] + + raise InvalidArguments(f'Requested variable "{varname}" not found.') + +class ModuleObjectHolder(InterpreterObject, ObjectHolder['ModuleObject']): + def __init__(self, modobj: 'ModuleObject', interpreter: 'Interpreter'): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, modobj) + self.interpreter = interpreter + + def method_call(self, method_name, args, kwargs): + modobj = self.held_object + method = modobj.methods.get(method_name) + if not method and not modobj.methods: + # FIXME: Port all modules to use the methods dict. + method = getattr(modobj, method_name, None) + if method_name.startswith('_'): + raise InvalidArguments(f'Method {method_name!r} is private.') + if not method: + raise InvalidCode('Unknown method "%s" in object.' % method_name) + if not getattr(method, 'no-args-flattening', False): + args = flatten(args) + state = ModuleState(self.interpreter) + # Many modules do for example self.interpreter.find_program_impl(), + # so we have to ensure they use the current interpreter and not the one + # that first imported that module, otherwise it will use outdated + # overrides. + modobj.interpreter = self.interpreter + if method_name in modobj.snippets: + ret = method(self.interpreter, state, args, kwargs) + else: + # This is not 100% reliable but we can't use hash() + # because the Build object contains dicts and lists. + num_targets = len(self.interpreter.build.targets) + ret = method(state, args, kwargs) + if num_targets != len(self.interpreter.build.targets): + raise InterpreterException('Extension module altered internal state illegally.') + if isinstance(ret, ModuleReturnValue): + self.interpreter.process_new_values(ret.new_objects) + ret = ret.return_value + return self.interpreter.holderify(ret) + +_Target = T.TypeVar('_Target', bound=build.Target) + + +class TargetHolder(InterpreterObject, ObjectHolder[_Target]): + def __init__(self, target: _Target, interp: 'Interpreter'): + InterpreterObject.__init__(self) + ObjectHolder.__init__(self, target, interp.subproject) + self.interpreter = interp + + +_BuildTarget = T.TypeVar('_BuildTarget', bound=build.BuildTarget) + +class BuildTargetHolder(TargetHolder[_BuildTarget]): + def __init__(self, target: _BuildTarget, interp: 'Interpreter'): + super().__init__(target, interp) + self.methods.update({'extract_objects': self.extract_objects_method, + 'extract_all_objects': self.extract_all_objects_method, + 'name': self.name_method, + 'get_id': self.get_id_method, + 'outdir': self.outdir_method, + 'full_path': self.full_path_method, + 'private_dir_include': self.private_dir_include_method, + }) + + def __repr__(self): + r = '<{} {}: {}>' + h = self.held_object + return r.format(self.__class__.__name__, h.get_id(), h.filename) + + def is_cross(self): + return not self.held_object.environment.machines.matches_build_machine(self.held_object.for_machine) + + @noPosargs + @permittedKwargs({}) + def private_dir_include_method(self, args, kwargs): + return IncludeDirsHolder(build.IncludeDirs('', [], False, + [self.interpreter.backend.get_target_private_dir(self.held_object)])) + + @noPosargs + @permittedKwargs({}) + def full_path_method(self, args, kwargs): + return self.interpreter.backend.get_target_filename_abs(self.held_object) + + @noPosargs + @permittedKwargs({}) + def outdir_method(self, args, kwargs): + return self.interpreter.backend.get_target_dir(self.held_object) + + @permittedKwargs({}) + def extract_objects_method(self, args, kwargs): + gobjs = self.held_object.extract_objects(args) + return GeneratedObjectsHolder(gobjs) + + @FeatureNewKwargs('extract_all_objects', '0.46.0', ['recursive']) + @noPosargs + @permittedKwargs({'recursive'}) + def extract_all_objects_method(self, args, kwargs): + recursive = kwargs.get('recursive', False) + gobjs = self.held_object.extract_all_objects(recursive) + if gobjs.objlist and 'recursive' not in kwargs: + mlog.warning('extract_all_objects called without setting recursive ' + 'keyword argument. Meson currently defaults to ' + 'non-recursive to maintain backward compatibility but ' + 'the default will be changed in the future.', + location=self.current_node) + return GeneratedObjectsHolder(gobjs) + + @noPosargs + @permittedKwargs({}) + def get_id_method(self, args, kwargs): + return self.held_object.get_id() + + @FeatureNew('name', '0.54.0') + @noPosargs + @permittedKwargs({}) + def name_method(self, args, kwargs): + return self.held_object.name + +class ExecutableHolder(BuildTargetHolder[build.Executable]): + pass + +class StaticLibraryHolder(BuildTargetHolder[build.StaticLibrary]): + pass + +class SharedLibraryHolder(BuildTargetHolder[build.SharedLibrary]): + def __init__(self, target: build.SharedLibrary, interp: 'Interpreter'): + super().__init__(target, interp) + # Set to True only when called from self.func_shared_lib(). + target.shared_library_only = False + +class BothLibrariesHolder(BuildTargetHolder): + def __init__(self, shared_holder, static_holder, interp): + # FIXME: This build target always represents the shared library, but + # that should be configurable. + super().__init__(shared_holder.held_object, interp) + self.shared_holder = shared_holder + self.static_holder = static_holder + self.methods.update({'get_shared_lib': self.get_shared_lib_method, + 'get_static_lib': self.get_static_lib_method, + }) + + def __repr__(self): + r = '<{} {}: {}, {}: {}>' + h1 = self.shared_holder.held_object + h2 = self.static_holder.held_object + return r.format(self.__class__.__name__, h1.get_id(), h1.filename, h2.get_id(), h2.filename) + + @noPosargs + @permittedKwargs({}) + def get_shared_lib_method(self, args, kwargs): + return self.shared_holder + + @noPosargs + @permittedKwargs({}) + def get_static_lib_method(self, args, kwargs): + return self.static_holder + +class SharedModuleHolder(BuildTargetHolder[build.SharedModule]): + pass + +class JarHolder(BuildTargetHolder[build.Jar]): + pass + +class CustomTargetIndexHolder(TargetHolder[build.CustomTargetIndex]): + def __init__(self, target: build.CustomTargetIndex, interp: 'Interpreter'): + super().__init__(target, interp) + self.methods.update({'full_path': self.full_path_method, + }) + + @FeatureNew('custom_target[i].full_path', '0.54.0') + @noPosargs + @permittedKwargs({}) + def full_path_method(self, args, kwargs): + return self.interpreter.backend.get_target_filename_abs(self.held_object) + +class CustomTargetHolder(TargetHolder): + def __init__(self, target: 'build.CustomTarget', interp: 'Interpreter'): + super().__init__(target, interp) + self.methods.update({'full_path': self.full_path_method, + 'to_list': self.to_list_method, + }) + + def __repr__(self): + r = '<{} {}: {}>' + h = self.held_object + return r.format(self.__class__.__name__, h.get_id(), h.command) + + @noPosargs + @permittedKwargs({}) + def full_path_method(self, args, kwargs): + return self.interpreter.backend.get_target_filename_abs(self.held_object) + + @FeatureNew('custom_target.to_list', '0.54.0') + @noPosargs + @permittedKwargs({}) + def to_list_method(self, args, kwargs): + result = [] + for i in self.held_object: + result.append(CustomTargetIndexHolder(i, self.interpreter)) + return result + + def __getitem__(self, index): + return CustomTargetIndexHolder(self.held_object[index], self.interpreter) + + def __setitem__(self, index, value): # lgtm[py/unexpected-raise-in-special-method] + raise InterpreterException('Cannot set a member of a CustomTarget') + + def __delitem__(self, index): # lgtm[py/unexpected-raise-in-special-method] + raise InterpreterException('Cannot delete a member of a CustomTarget') + + def outdir_include(self): + return IncludeDirsHolder(build.IncludeDirs('', [], False, + [os.path.join('@BUILD_ROOT@', self.interpreter.backend.get_target_dir(self.held_object))])) + +class RunTargetHolder(TargetHolder): + def __init__(self, target, interp): + super().__init__(target, interp) + + def __repr__(self): + r = '<{} {}: {}>' + h = self.held_object + return r.format(self.__class__.__name__, h.get_id(), h.command) |