class TargetInstallData:

def __init__(self, fname: str, outdir: str, aliases: T.Dict[str, str], strip: bool,

install_name_mappings: T.Dict, rpath_dirs_to_remove: T.Set[bytes],

self.fname = fname

self.outdir = outdir

self.aliases = aliases

self.install_mode = install_mode

self.subproject = subproject

self.optional = optional

class InstallDataBase:

self.path = path

self.install_path = install_path

self.install_mode = install_mode

self.subproject = subproject

class SubdirInstallData(InstallDataBase):

self.exclude = exclude

class ExecutableSerialisation:

def __init__(self, cmd_args, env: T.Optional[build.EnvironmentVariables] = None, exe_wrapper=None,

self.cmd_args = cmd_args

self.env = env

if exe_wrapper is not None:

self.skip_if_destdir = False

self.verbose = False

self.subproject = ''

class TestSerialisation:

def __init__(self, name: str, project: str, suite: T.List[str], fname: T.List[str],

def get_executable_serialisation(self, cmd, workdir=None,

extra_bdeps=None, capture=None, feed=None,

exe = cmd[0]

cmd_args = cmd[1:]

if isinstance(exe, programs.ExternalProgram):

workdir = workdir or self.environment.get_build_dir()

return ExecutableSerialisation(exe_cmd + cmd_args, env,

exe_wrapper, workdir,

def as_meson_exe_cmdline(self, tname, exe, cmd_args, workdir=None,

extra_bdeps=None, capture=None, feed=None,

with open(ifilename, 'w', encoding='utf-8') as f:

f.write(json.dumps(mfobj))

# Copy file from, to, and with mode unchanged

def get_regen_filelist(self):

'''List of all files whose alteration means that the build

with open(install_data_file, 'wb') as ofile:

pickle.dump(self.create_install_data(), ofile)

def generate_target_install(self, d: InstallData) -> None:

for t in self.build.get_targets().values():

if not t.should_install():

"Pass 'false' for outputs that should not be installed and 'true' for\n" \

'using the default installation directory for an output.'

raise MesonException(m.format(t.name, num_out, t.get_outputs(), num_outdirs))

install_mode = t.get_custom_install_mode()

# Install the target output(s)

if isinstance(t, build.BuildTarget):

# Install primary build output (library/executable/jar, etc)

# Done separately because of strip/aliases/rpath

if outdirs[0] is not False:

mappings = t.get_link_deps_mapping(d.prefix, self.environment)

i = TargetInstallData(self.get_target_filename(t), outdirs[0],

t.get_aliases(), should_strip, mappings,

t.rpath_dirs_to_remove,

d.targets.append(i)

if isinstance(t, (build.SharedLibrary, build.SharedModule, build.Executable)):

# Install the import library; may not exist for shared modules

i = TargetInstallData(self.get_target_filename_for_linking(t),

implib_install_dir, {}, False, {}, set(), '', install_mode,

d.targets.append(i)

if not should_strip and t.get_debug_filename():

i = TargetInstallData(debug_file, outdirs[0],

{}, False, {}, set(), '',

install_mode, t.subproject,

d.targets.append(i)

# Install secondary outputs. Only used for Vala right now.

if num_outdirs > 1:

# User requested that we not install this output

if outdir is False:

continue

f = os.path.join(self.get_target_dir(t), output)

i = TargetInstallData(f, outdir, {}, False, {}, set(), None,

d.targets.append(i)

elif isinstance(t, build.CustomTarget):

# If only one install_dir is specified, assume that all

# To selectively install only some outputs, pass `false` as

# the install_dir for the corresponding output by index

if num_outdirs == 1 and num_out > 1:

f = os.path.join(self.get_target_dir(t), output)

i = TargetInstallData(f, outdirs[0], {}, False, {}, set(), None, install_mode,

d.targets.append(i)

else:

# User requested that we not install this output

if outdir is False:

continue

f = os.path.join(self.get_target_dir(t), output)

i = TargetInstallData(f, outdir, {}, False, {}, set(), None, install_mode,

d.targets.append(i)

def generate_custom_install_script(self, d: InstallData) -> None:

if not isinstance(f, File):

raise MesonException(f'Invalid header type {f!r} can\'t be installed')

abspath = f.absolute_path(srcdir, builddir)

d.headers.append(i)

def generate_man_install(self, d: InstallData) -> None:

fname = fname.replace(f'.{m.locale}', '')

srcabs = f.absolute_path(self.environment.get_source_dir(), self.environment.get_build_dir())

dstabs = os.path.join(subdir, os.path.basename(fname))

d.man.append(i)

def generate_data_install(self, d: InstallData):

for src_file, dst_name in zip(de.sources, de.rename):

assert(isinstance(src_file, mesonlib.File))

dst_abs = os.path.join(subdir, dst_name)

d.data.append(i)

def generate_subdir_install(self, d: InstallData) -> None:

args += ['--vapi', os.path.join('..', target.vala_vapi)]

valac_outputs.append(vapiname)

target.outputs += [target.vala_header, target.vala_vapi]

# Install header and vapi to default locations if user requests this

if len(target.install_dir) > 1 and target.install_dir[1] is True:

target.install_dir[1] = self.environment.get_includedir()

args += ['--gir', os.path.join('..', target.vala_gir)]

valac_outputs.append(girname)

target.outputs.append(target.vala_gir)

# Install GIR to default location if requested by user

if len(target.install_dir) > 3 and target.install_dir[3] is True:

target.install_dir[3] = os.path.join(self.environment.get_datadir(), 'gir-1.0')

'install_rpath',

'install_dir',

'install_mode',

'name_prefix',

'name_suffix',

'native',

install_mode: 'FileMode',

exclude: T.Tuple[T.Set[str], T.Set[str]],

strip_directory: bool, subproject: str,

self.source_subdir = src_subdir

self.installable_subdir = inst_subdir

self.install_dir = install_dir

self.strip_directory = strip_directory

self.from_source_dir = from_source_dir

self.subproject = subproject

class Build:

self.install_dir = typeslistify(kwargs.get('install_dir', [None]),

(str, bool))

self.install_mode = kwargs.get('install_mode', None)

main_class = kwargs.get('main_class', '')

if not isinstance(main_class, str):

raise InvalidArguments('Main class must be a string')

'install',

'install_dir',

'install_mode',

'build_always',

'build_always_stale',

'depends',

# the list index of that item will not be installed

self.install_dir = typeslistify(kwargs['install_dir'], (str, bool))

self.install_mode = kwargs.get('install_mode', None)

else:

self.install = False

self.install_dir = [None]

self.install_mode = None

if 'build_always' in kwargs and 'build_always_stale' in kwargs:

raise InvalidArguments('build_always and build_always_stale are mutually exclusive. Combine build_by_default and build_always_stale.')

elif 'build_always' in kwargs:

class Data(HoldableObject):

def __init__(self, sources: T.List[File], install_dir: str,

install_mode: 'FileMode', subproject: str,

self.sources = sources

self.install_dir = install_dir

self.install_mode = install_mode

if rename is None:

self.rename = [os.path.basename(f.fname) for f in self.sources]

else:

def func_subdir_done(self, node, args, kwargs):

raise SubdirDoneRequest()

@FeatureNewKwargs('custom_target', '0.57.0', ['env'])

@FeatureNewKwargs('custom_target', '0.48.0', ['console'])

@FeatureNewKwargs('custom_target', '0.47.0', ['install_mode', 'build_always_stale'])

@permittedKwargs({'input', 'output', 'command', 'install', 'install_dir', 'install_mode',

'build_always', 'capture', 'depends', 'depend_files', 'depfile',

'build_by_default', 'build_always_stale', 'console', 'env',

@typed_pos_args('custom_target', str)

def func_custom_target(self, node: mparser.FunctionNode, args: T.Tuple[str], kwargs: 'TYPE_kwargs') -> build.CustomTarget:

if 'depfile' in kwargs and ('@BASENAME@' in kwargs['depfile'] or '@PLAINNAME@' in kwargs['depfile']):

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'),

)

def func_install_data(self, node: mparser.BaseNode,

args: T.Tuple[T.List['mesonlib.FileOrString']],

'"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)}.')

def install_data_impl(self, sources: T.List[mesonlib.File], install_dir: str,

"""Just the implementation with no validation."""

self.build.data.append(data)

return data

@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',

kwargs['install_mode'],

exclude,

kwargs['strip_directory'],

self.build.install_dirs.append(idir)

return idir

@FeatureNewKwargs('configure_file', '0.41.0', ['capture'])

@FeatureNewKwargs('configure_file', '0.50.0', ['install'])

@FeatureNewKwargs('configure_file', '0.52.0', ['depfile'])

@permittedKwargs({'input', 'output', 'configuration', 'command', 'copy', 'depfile',

'install_dir', 'install_mode', 'capture', 'install', 'format',

@noPosargs

def func_configure_file(self, node, args, kwargs):

if 'output' not in kwargs:

'is true')

cfile = mesonlib.File.from_built_file(ofile_path, ofile_fname)

install_mode = self._get_kwarg_install_mode(kwargs)

return mesonlib.File.from_built_file(self.subdir, output)

def extract_incdirs(self, kwargs):

from ..mesonlib import MachineChoice, OptionKey

from ..programs import OverrideProgram, ExternalProgram

typed_pos_args, permittedKwargs, noArgsFlattening, noPosargs, noKwargs,

from .interpreterobjects import (ExecutableHolder, ExternalProgramHolder,

CustomTargetHolder, CustomTargetIndexHolder,

'0.55.0', self.interpreter.subproject)

return script_args

def add_install_script_method(self, args: 'T.Tuple[T.Union[str, mesonlib.File, ExecutableHolder], T.Union[str, mesonlib.File, CustomTargetHolder, CustomTargetIndexHolder], ...]', kwargs):

if len(args) < 1:

raise InterpreterException('add_install_script takes one or more arguments')

if isinstance(args[0], mesonlib.File):

FeatureNew.single_use('Passing file object to script parameter of add_install_script',

'0.57.0', self.interpreter.subproject)

script_args = self._process_script_args('add_install_script', args[1:], allow_built=True)

script = self._find_source_script(args[0], script_args)

self.build.install_scripts.append(script)

@permittedKwargs(set())

import typing as T

from . import environment

from .coredata import major_versions_differ, MesonVersionMismatchException

from .coredata import version as coredata_version

from .mesonlib import Popen_safe, RealPathAction, is_windows

destdir: str

dry_run: bool

skip_subprojects: str

symlink_warning = '''Warning: trying to copy a symlink that points to a file. This will copy the file,

help='Doesn\'t actually install, but print logs. (Since 0.57.0)')

parser.add_argument('--skip-subprojects', nargs='?', const='*', default='',

help='Do not install files from given subprojects. (Since 0.58.0)')

class DirMaker:

def __init__(self, lf: T.TextIO, makedirs: T.Callable[..., None]):

# ['*'] means skip all,

# ['sub1', ...] means skip only those.

self.skip_subprojects = [i.strip() for i in options.skip_subprojects.split(',')]

def remove(self, *args: T.Any, **kwargs: T.Any) -> None:

if not self.dry_run:

return run_exe(*args, **kwargs)

return 0

return False

return True

def install_subdirs(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:

for i in d.install_subdirs:

continue

self.did_install_something = True

full_dst_dir = get_destdir_path(destdir, fullprefix, i.install_path)

def install_data(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:

for i in d.data:

continue

fullfilename = i.path

outfilename = get_destdir_path(destdir, fullprefix, i.install_path)

def install_man(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:

for m in d.man:

continue

full_source_filename = m.path

outfilename = get_destdir_path(destdir, fullprefix, m.install_path)

def install_headers(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:

for t in d.headers:

continue

fullfilename = t.path

fname = os.path.basename(fullfilename)

env['MESON_INSTALL_QUIET'] = '1'

for i in d.install_scripts:

continue

name = ' '.join(i.cmd_args)

if i.skip_if_destdir and destdir:

def install_targets(self, d: InstallData, dm: DirMaker, destdir: str, fullprefix: str) -> None:

for t in d.targets:

continue

if not os.path.exists(t.fname):

# For example, import libraries of shared modules are optional

scankwargs['install'] = kwargs['install']

scankwargs['install_dir'] = kwargs.get('install_dir_gir',

os.path.join(state.environment.get_datadir(), 'gir-1.0'))

if 'build_by_default' in kwargs:

scankwargs['build_by_default'] = kwargs['build_by_default']

typelib_kwargs['install'] = kwargs['install']

typelib_kwargs['install_dir'] = kwargs.get('install_dir_typelib',

os.path.join(state.environment.get_libdir(), 'girepository-1.0'))

if 'build_by_default' in kwargs:

typelib_kwargs['build_by_default'] = kwargs['build_by_default']

state.test(check_args, env=check_env, workdir=check_workdir, depends=custom_target)

res = [custom_target, alias_target]

if kwargs.get('install', True):

return ModuleReturnValue(custom_target, res)

def _get_build_args(self, kwargs, state, depends):

'--builddir', os.path.join(self.builddir, self.subdir)] +

self.hotdoc.get_command() +

['run', '--conf-file', hotdoc_config_name])

return (target, install_script)

# to custom_targets. Crude hack: set the build target's subdir manually.

# Bonus: the build tree has something usable as an uninstalled bindtextdomain() target dir.

'install_dir': path.join(install_dir, l, 'LC_MESSAGES'),

}

gmotarget = build.CustomTarget(l+'.mo', path.join(state.subdir, l, 'LC_MESSAGES'), state.subproject, gmo_kwargs)

targets.append(gmotarget)

self._generate_pkgconfig_file(state, deps, subdirs, name, description, url,

version, pcfile, conflicts, variables,

unescaped_variables, False, dataonly)

variables = self.interpreter.extract_variables(kwargs, argname='uninstalled_variables', dict_new=True)

variables = parse_variable_list(variables)

unescaped_variables = self.interpreter.extract_variables(kwargs, argname='unescaped_uninstalled_variables')

pure: bool

subdir: str

class PythonInstallation(ExternalProgramHolder):

return dep

@typed_pos_args('install_data', varargs=(str, mesonlib.File))

def install_sources_method(self, args: T.Tuple[T.List[T.Union[str, mesonlib.File]]],

kwargs: 'PyInstallKw') -> 'Data':

return self.interpreter.install_data_impl(

self.interpreter.source_strings_to_files(args[0]),

self._get_install_dir_impl(kwargs['pure'], kwargs['subdir']),

@noPosargs

@typed_kwargs('python_installation.install_dir', _PURE_KW, _SUBDIR_KW)

lrelease_kwargs = {'output': '@BASENAME@.qm',

'input': ts,

'install': kwargs.get('install', False),

'build_by_default': kwargs.get('build_by_default', False),

'command': cmd}

if install_dir is not None: