The Meson Build System http://mesonbuild.com/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

449 lines
18 KiB

# Copyright 2018 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
import re
import os, os.path, pathlib
import shutil
import typing as T
from . import ExtensionModule, ModuleReturnValue, ModuleObject, ModuleInfo
from .. import build, mesonlib, mlog, dependencies
from ..cmake import TargetOptions, cmake_defines_to_args
from ..interpreter import SubprojectHolder
from ..interpreter.type_checking import REQUIRED_KW, INSTALL_DIR_KW, NoneType, in_set_validator
from ..interpreterbase import (
FeatureNew,
FeatureNewKwargs,
stringArgs,
permittedKwargs,
noPosargs,
noKwargs,
InvalidArguments,
InterpreterException,
typed_pos_args,
typed_kwargs,
KwargInfo,
ContainerTypeInfo,
)
if T.TYPE_CHECKING:
from typing_extensions import TypedDict
from . import ModuleState
from ..cmake import SingleTargetOptions
from ..environment import Environment
from ..interpreter import Interpreter, kwargs
from ..interpreterbase import TYPE_kwargs, TYPE_var
class WriteBasicPackageVersionFile(TypedDict):
arch_independent: bool
compatibility: str
install_dir: T.Optional[str]
name: str
version: str
class ConfigurePackageConfigFile(TypedDict):
configuration: T.Union[build.ConfigurationData, dict]
input: T.Union[str, mesonlib.File]
install_dir: T.Optional[str]
name: str
class Subproject(kwargs.ExtractRequired):
options: T.Optional[CMakeSubprojectOptions]
cmake_options: T.List[str]
COMPATIBILITIES = ['AnyNewerVersion', 'SameMajorVersion', 'SameMinorVersion', 'ExactVersion']
# Taken from https://github.com/Kitware/CMake/blob/master/Modules/CMakePackageConfigHelpers.cmake
PACKAGE_INIT_BASE = '''
####### Expanded from \\@PACKAGE_INIT\\@ by configure_package_config_file() #######
####### Any changes to this file will be overwritten by the next CMake run ####
####### The input file was @inputFileName@ ########
get_filename_component(PACKAGE_PREFIX_DIR "${CMAKE_CURRENT_LIST_DIR}/@PACKAGE_RELATIVE_PATH@" ABSOLUTE)
'''
PACKAGE_INIT_EXT = '''
# Use original install prefix when loaded through a "/usr move"
# cross-prefix symbolic link such as /lib -> /usr/lib.
get_filename_component(_realCurr "${CMAKE_CURRENT_LIST_DIR}" REALPATH)
get_filename_component(_realOrig "@absInstallDir@" REALPATH)
if(_realCurr STREQUAL _realOrig)
set(PACKAGE_PREFIX_DIR "@installPrefix@")
endif()
unset(_realOrig)
unset(_realCurr)
'''
PACKAGE_INIT_SET_AND_CHECK = '''
macro(set_and_check _var _file)
set(${_var} "${_file}")
if(NOT EXISTS "${_file}")
message(FATAL_ERROR "File or directory ${_file} referenced by variable ${_var} does not exist !")
endif()
endmacro()
####################################################################################
'''
class CMakeSubproject(ModuleObject):
def __init__(self, subp: SubprojectHolder):
assert isinstance(subp, SubprojectHolder)
assert subp.cm_interpreter is not None
super().__init__()
self.subp = subp
self.cm_interpreter = subp.cm_interpreter
self.methods.update({'get_variable': self.get_variable,
'dependency': self.dependency,
'include_directories': self.include_directories,
'target': self.target,
'target_type': self.target_type,
'target_list': self.target_list,
'found': self.found_method,
})
def _args_to_info(self, args: T.List[str]) -> T.Dict[str, str]:
if len(args) != 1:
raise InterpreterException('Exactly one argument is required.')
tgt = args[0]
res = self.cm_interpreter.target_info(tgt)
if res is None:
raise InterpreterException(f'The CMake target {tgt} does not exist\n' +
' Use the following command in your meson.build to list all available targets:\n\n' +
' message(\'CMake targets:\\n - \' + \'\\n - \'.join(<cmake_subproject>.target_list()))')
# Make sure that all keys are present (if not this is a bug)
assert all(x in res for x in ['inc', 'src', 'dep', 'tgt', 'func'])
return res
@noKwargs
@stringArgs
def get_variable(self, state: ModuleState, args: T.List[str], kwargs: TYPE_kwargs) -> TYPE_var:
return self.subp.get_variable_method(args, kwargs)
@FeatureNewKwargs('dependency', '0.56.0', ['include_type'])
@permittedKwargs({'include_type'})
@stringArgs
def dependency(self, state: ModuleState, args: T.List[str], kwargs: T.Dict[str, str]) -> dependencies.Dependency:
info = self._args_to_info(args)
if info['func'] == 'executable':
raise InvalidArguments(f'{args[0]} is an executable and does not support the dependency() method. Use target() instead.')
orig = self.get_variable(state, [info['dep']], {})
assert isinstance(orig, dependencies.Dependency)
actual = orig.include_type
if 'include_type' in kwargs and kwargs['include_type'] != actual:
mlog.debug('Current include type is {}. Converting to requested {}'.format(actual, kwargs['include_type']))
return orig.generate_system_dependency(kwargs['include_type'])
return orig
@noKwargs
@stringArgs
def include_directories(self, state: ModuleState, args: T.List[str], kwargs: TYPE_kwargs) -> build.IncludeDirs:
info = self._args_to_info(args)
return self.get_variable(state, [info['inc']], kwargs)
@noKwargs
@stringArgs
def target(self, state: ModuleState, args: T.List[str], kwargs: TYPE_kwargs) -> build.Target:
info = self._args_to_info(args)
return self.get_variable(state, [info['tgt']], kwargs)
@noKwargs
@stringArgs
def target_type(self, state: ModuleState, args: T.List[str], kwargs: TYPE_kwargs) -> str:
info = self._args_to_info(args)
return info['func']
@noPosargs
@noKwargs
def target_list(self, state: ModuleState, args: TYPE_var, kwargs: TYPE_kwargs) -> T.List[str]:
return self.cm_interpreter.target_list()
@noPosargs
@noKwargs
@FeatureNew('CMakeSubproject.found()', '0.53.2')
def found_method(self, state: ModuleState, args: TYPE_var, kwargs: TYPE_kwargs) -> bool:
return self.subp is not None
class CMakeSubprojectOptions(ModuleObject):
def __init__(self) -> None:
super().__init__()
self.cmake_options = [] # type: T.List[str]
self.target_options = TargetOptions()
self.methods.update(
{
'add_cmake_defines': self.add_cmake_defines,
'set_override_option': self.set_override_option,
'set_install': self.set_install,
'append_compile_args': self.append_compile_args,
'append_link_args': self.append_link_args,
'clear': self.clear,
}
)
def _get_opts(self, kwargs: dict) -> SingleTargetOptions:
if 'target' in kwargs:
return self.target_options[kwargs['target']]
return self.target_options.global_options
@typed_pos_args('subproject_options.add_cmake_defines', varargs=dict)
@noKwargs
def add_cmake_defines(self, state: ModuleState, args: T.Tuple[T.List[T.Dict[str, TYPE_var]]], kwargs: TYPE_kwargs) -> None:
self.cmake_options += cmake_defines_to_args(args[0])
@typed_pos_args('subproject_options.set_override_option', str, str)
@permittedKwargs({'target'})
def set_override_option(self, state: ModuleState, args: T.Tuple[str, str], kwargs: TYPE_kwargs) -> None:
self._get_opts(kwargs).set_opt(args[0], args[1])
@typed_pos_args('subproject_options.set_install', bool)
@permittedKwargs({'target'})
def set_install(self, state: ModuleState, args: T.Tuple[bool], kwargs: TYPE_kwargs) -> None:
self._get_opts(kwargs).set_install(args[0])
@typed_pos_args('subproject_options.append_compile_args', str, varargs=str, min_varargs=1)
@permittedKwargs({'target'})
def append_compile_args(self, state: ModuleState, args: T.Tuple[str, T.List[str]], kwargs: TYPE_kwargs) -> None:
self._get_opts(kwargs).append_args(args[0], args[1])
@typed_pos_args('subproject_options.append_compile_args', varargs=str, min_varargs=1)
@permittedKwargs({'target'})
def append_link_args(self, state: ModuleState, args: T.Tuple[T.List[str]], kwargs: TYPE_kwargs) -> None:
self._get_opts(kwargs).append_link_args(args[0])
@noPosargs
@noKwargs
def clear(self, state: ModuleState, args: TYPE_var, kwargs: TYPE_kwargs) -> None:
self.cmake_options.clear()
self.target_options = TargetOptions()
class CmakeModule(ExtensionModule):
cmake_detected = False
cmake_root = None
INFO = ModuleInfo('cmake', '0.50.0')
def __init__(self, interpreter: Interpreter) -> None:
super().__init__(interpreter)
self.methods.update({
'write_basic_package_version_file': self.write_basic_package_version_file,
'configure_package_config_file': self.configure_package_config_file,
'subproject': self.subproject,
'subproject_options': self.subproject_options,
})
def detect_voidp_size(self, env: Environment) -> int:
compilers = env.coredata.compilers.host
compiler = compilers.get('c', None)
if not compiler:
compiler = compilers.get('cpp', None)
if not compiler:
raise mesonlib.MesonException('Requires a C or C++ compiler to compute sizeof(void *).')
return compiler.sizeof('void *', '', env)[0]
def detect_cmake(self, state: ModuleState) -> bool:
if self.cmake_detected:
return True
cmakebin = state.find_program('cmake', silent=False)
if not cmakebin.found():
return False
p, stdout, stderr = mesonlib.Popen_safe(cmakebin.get_command() + ['--system-information', '-G', 'Ninja'])[0:3]
if p.returncode != 0:
mlog.log(f'error retrieving cmake information: returnCode={p.returncode} stdout={stdout} stderr={stderr}')
return False
match = re.search('\nCMAKE_ROOT \\"([^"]+)"\n', stdout.strip())
if not match:
mlog.log('unable to determine cmake root')
return False
cmakePath = pathlib.PurePath(match.group(1))
self.cmake_root = os.path.join(*cmakePath.parts)
self.cmake_detected = True
return True
@noPosargs
@typed_kwargs(
'cmake.write_basic_package_version_file',
KwargInfo('arch_independent', bool, default=False, since='0.62.0'),
KwargInfo('compatibility', str, default='AnyNewerVersion', validator=in_set_validator(set(COMPATIBILITIES))),
KwargInfo('name', str, required=True),
KwargInfo('version', str, required=True),
INSTALL_DIR_KW,
)
def write_basic_package_version_file(self, state: ModuleState, args: TYPE_var, kwargs: 'WriteBasicPackageVersionFile') -> ModuleReturnValue:
arch_independent = kwargs['arch_independent']
compatibility = kwargs['compatibility']
name = kwargs['name']
version = kwargs['version']
if not self.detect_cmake(state):
raise mesonlib.MesonException('Unable to find cmake')
pkgroot = pkgroot_name = kwargs['install_dir']
if pkgroot is None:
pkgroot = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name)
pkgroot_name = os.path.join('{libdir}', 'cmake', name)
template_file = os.path.join(self.cmake_root, 'Modules', f'BasicConfigVersion-{compatibility}.cmake.in')
if not os.path.exists(template_file):
raise mesonlib.MesonException(f'your cmake installation doesn\'t support the {compatibility} compatibility')
version_file = os.path.join(state.environment.scratch_dir, f'{name}ConfigVersion.cmake')
conf: T.Dict[str, T.Union[str, bool, int]] = {
'CVF_VERSION': version,
'CMAKE_SIZEOF_VOID_P': str(self.detect_voidp_size(state.environment)),
'CVF_ARCH_INDEPENDENT': arch_independent,
}
mesonlib.do_conf_file(template_file, version_file, build.ConfigurationData(conf), 'meson')
res = build.Data([mesonlib.File(True, state.environment.get_scratch_dir(), version_file)], pkgroot, pkgroot_name, None, state.subproject)
return ModuleReturnValue(res, [res])
def create_package_file(self, infile: str, outfile: str, PACKAGE_RELATIVE_PATH: str, extra: str, confdata: build.ConfigurationData) -> None:
package_init = PACKAGE_INIT_BASE.replace('@PACKAGE_RELATIVE_PATH@', PACKAGE_RELATIVE_PATH)
package_init = package_init.replace('@inputFileName@', os.path.basename(infile))
package_init += extra
package_init += PACKAGE_INIT_SET_AND_CHECK
try:
with open(infile, encoding='utf-8') as fin:
data = fin.readlines()
except Exception as e:
raise mesonlib.MesonException(f'Could not read input file {infile}: {e!s}')
result = []
regex = mesonlib.get_variable_regex('cmake@')
for line in data:
line = line.replace('@PACKAGE_INIT@', package_init)
line, _missing = mesonlib.do_replacement(regex, line, 'cmake@', confdata)
result.append(line)
outfile_tmp = outfile + "~"
with open(outfile_tmp, "w", encoding='utf-8') as fout:
fout.writelines(result)
shutil.copymode(infile, outfile_tmp)
mesonlib.replace_if_different(outfile, outfile_tmp)
@noPosargs
@typed_kwargs(
'cmake.configure_package_config_file',
KwargInfo('configuration', (build.ConfigurationData, dict), required=True),
KwargInfo('input',
(str, mesonlib.File, ContainerTypeInfo(list, mesonlib.File)), required=True,
validator=lambda x: 'requires exactly one file' if isinstance(x, list) and len(x) != 1 else None,
convertor=lambda x: x[0] if isinstance(x, list) else x),
KwargInfo('name', str, required=True),
INSTALL_DIR_KW,
)
def configure_package_config_file(self, state: ModuleState, args: TYPE_var, kwargs: 'ConfigurePackageConfigFile') -> build.Data:
inputfile = kwargs['input']
if isinstance(inputfile, str):
inputfile = mesonlib.File.from_source_file(state.environment.source_dir, state.subdir, inputfile)
ifile_abs = inputfile.absolute_path(state.environment.source_dir, state.environment.build_dir)
name = kwargs['name']
(ofile_path, ofile_fname) = os.path.split(os.path.join(state.subdir, f'{name}Config.cmake'))
ofile_abs = os.path.join(state.environment.build_dir, ofile_path, ofile_fname)
install_dir = kwargs['install_dir']
if install_dir is None:
install_dir = os.path.join(state.environment.coredata.get_option(mesonlib.OptionKey('libdir')), 'cmake', name)
conf = kwargs['configuration']
if isinstance(conf, dict):
FeatureNew.single_use('cmake.configure_package_config_file dict as configuration', '0.62.0', state.subproject, location=state.current_node)
conf = build.ConfigurationData(conf)
prefix = state.environment.coredata.get_option(mesonlib.OptionKey('prefix'))
abs_install_dir = install_dir
if not os.path.isabs(abs_install_dir):
abs_install_dir = os.path.join(prefix, install_dir)
PACKAGE_RELATIVE_PATH = os.path.relpath(prefix, abs_install_dir)
extra = ''
if re.match('^(/usr)?/lib(64)?/.+', abs_install_dir):
extra = PACKAGE_INIT_EXT.replace('@absInstallDir@', abs_install_dir)
extra = extra.replace('@installPrefix@', prefix)
self.create_package_file(ifile_abs, ofile_abs, PACKAGE_RELATIVE_PATH, extra, conf)
conf.used = True
conffile = os.path.normpath(inputfile.relative_name())
self.interpreter.build_def_files.add(conffile)
res = build.Data([mesonlib.File(True, ofile_path, ofile_fname)], install_dir, install_dir, None, state.subproject)
self.interpreter.build.data.append(res)
return res
@FeatureNew('subproject', '0.51.0')
@typed_pos_args('cmake.subproject', str)
@typed_kwargs(
'cmake.subproject',
REQUIRED_KW,
KwargInfo('options', (CMakeSubprojectOptions, NoneType), since='0.55.0'),
KwargInfo(
'cmake_options',
ContainerTypeInfo(list, str),
default=[],
listify=True,
deprecated='0.55.0',
deprecated_message='Use options instead',
),
)
def subproject(self, state: ModuleState, args: T.Tuple[str], kwargs_: Subproject) -> T.Union[SubprojectHolder, CMakeSubproject]:
if kwargs_['cmake_options'] and kwargs_['options'] is not None:
raise InterpreterException('"options" cannot be used together with "cmake_options"')
dirname = args[0]
kw: kwargs.DoSubproject = {
'required': kwargs_['required'],
'options': kwargs_['options'],
'cmake_options': kwargs_['cmake_options'],
'default_options': [],
'version': [],
}
subp = self.interpreter.do_subproject(dirname, 'cmake', kw)
if not subp.found():
return subp
return CMakeSubproject(subp)
@FeatureNew('subproject_options', '0.55.0')
@noKwargs
@noPosargs
def subproject_options(self, state: ModuleState, args: TYPE_var, kwargs: TYPE_kwargs) -> CMakeSubprojectOptions:
return CMakeSubprojectOptions()
def initialize(*args: T.Any, **kwargs: T.Any) -> CmakeModule:
return CmakeModule(*args, **kwargs)