# Copyright 2012-2017 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 collections import defaultdict , OrderedDict
from dataclasses import dataclass , field , InitVar
from functools import lru_cache
import abc
import copy
import hashlib
import itertools , pathlib
import os
import pickle
import re
import textwrap
import typing as T
from . import coredata
from . import environment
from . import dependencies
from . import mlog
from . import programs
from . mesonlib import (
HoldableObject , SecondLevelHolder ,
File , MesonException , MachineChoice , PerMachine , OrderedSet , listify ,
extract_as_list , typeslistify , stringlistify , classify_unity_sources ,
get_filenames_templates_dict , substitute_values , has_path_sep ,
OptionKey , PerMachineDefaultable , OptionOverrideProxy ,
MesonBugException , EnvironmentVariables , pickle_load ,
)
from . compilers import (
is_object , clink_langs , sort_clink , all_languages ,
is_known_suffix , detect_static_linker
)
from . interpreterbase import FeatureNew , FeatureDeprecated
if T . TYPE_CHECKING :
from typing_extensions import Literal
from . _typing import ImmutableListProtocol
from . backend . backends import Backend , ExecutableSerialisation
from . compilers import Compiler
from . interpreter . interpreter import Test , SourceOutputs , Interpreter
from . interpreterbase import SubProject
from . linkers import StaticLinker
from . mesonlib import FileMode , FileOrString
from . modules import ModuleState
from . mparser import BaseNode
from . wrap import WrapMode
GeneratedTypes = T . Union [ ' CustomTarget ' , ' CustomTargetIndex ' , ' GeneratedList ' ]
LibTypes = T . Union [ ' SharedLibrary ' , ' StaticLibrary ' , ' CustomTarget ' , ' CustomTargetIndex ' ]
BuildTargetTypes = T . Union [ ' BuildTarget ' , ' CustomTarget ' , ' CustomTargetIndex ' ]
ObjectTypes = T . Union [ str , ' File ' , ' ExtractedObjects ' , ' GeneratedTypes ' ]
pch_kwargs = { ' c_pch ' , ' cpp_pch ' }
lang_arg_kwargs = { f ' { lang } _args ' for lang in all_languages }
lang_arg_kwargs | = {
' d_import_dirs ' ,
' d_unittest ' ,
' d_module_versions ' ,
' d_debug ' ,
}
vala_kwargs = { ' vala_header ' , ' vala_gir ' , ' vala_vapi ' }
rust_kwargs = { ' rust_crate_type ' , ' rust_dependency_map ' }
cs_kwargs = { ' resources ' , ' cs_args ' }
buildtarget_kwargs = {
' build_by_default ' ,
' build_rpath ' ,
' dependencies ' ,
' extra_files ' ,
' gui_app ' ,
' link_with ' ,
' link_whole ' ,
' link_args ' ,
' link_depends ' ,
' implicit_include_directories ' ,
' include_directories ' ,
' install ' ,
' install_rpath ' ,
' install_dir ' ,
' install_mode ' ,
' install_tag ' ,
' name_prefix ' ,
' name_suffix ' ,
' native ' ,
' objects ' ,
' override_options ' ,
' sources ' ,
' gnu_symbol_visibility ' ,
' link_language ' ,
' win_subsystem ' ,
}
known_build_target_kwargs = (
buildtarget_kwargs |
lang_arg_kwargs |
pch_kwargs |
vala_kwargs |
rust_kwargs |
cs_kwargs )
known_exe_kwargs = known_build_target_kwargs | { ' implib ' , ' export_dynamic ' , ' pie ' }
known_shlib_kwargs = known_build_target_kwargs | { ' version ' , ' soversion ' , ' vs_module_defs ' , ' darwin_versions ' }
known_shmod_kwargs = known_build_target_kwargs | { ' vs_module_defs ' }
known_stlib_kwargs = known_build_target_kwargs | { ' pic ' , ' prelink ' }
known_jar_kwargs = known_exe_kwargs | { ' main_class ' , ' java_resources ' }
simplify install_tag handling according to the accepted API
There are two problems here: a typing problem, and an algorithm problem.
We expect it to always be passed to CustomTarget() as a list, but we ran
list() on it, which became horribly mangled if you violated the types
and passed a string instead. This caused weird*er* errors and didn't
even do anything. We want to do all validation in the interpreter,
anyway, and make the build level dumb.
Meanwhile we type it as accepting a T.Sequence, which technically
permits... a string, actually. This isn't intentional; the point of
using T.Sequence is out of a misguided idea that APIs are supposed to be
"technically correct" by allowing "anything that fulfills an interface",
which is a flawed concept because we aren't using interfaces here, and
also because "technically string fulfills the same interface as a list,
if we're talking sequences".
Basically:
- mypy is broken by design, because it typechecks "python", not "what we
wish python to be"
- we do not actually need to graciously permit passing tuples instead of
lists
As far as historic implementations of this logic go, we have formerly:
- originally, typeslistified anything
- switched to accepting list from the interpreter, redundantly ran list()
on the list we got, and mishandling API violations passing a string
(commit 11f96380351a88059ec55f1070fdebc1b1033117)
- switched to accepting anything, stringlistifying it if it was not
`None`, mishandling `[None]`, and invoking list(x) on a brand new list
from stringlistify (commit 157d43883515507f42618b065a64fb26501734a0)
- stopped stringlistify, just accept T.List[str | None] and re-cast to
list, violates typing because we use/handle plain None too
(commit a8521fef70ef76fb742d80aceb2e9ed634bd6a70)
- break typing by declaring we accept a simple string, which still
results in mishandling by converting 'foo' -> ['f', 'o', 'o']
(commit ac576530c43734495815f22456596772a8f6a8cc)
All of this. ALL of it. Is because we tried to be fancy and say we
accept T.Tuple; the only version of this logic that has ever worked
correctly is the original untyped do-all-validation-in-the-build-phase
typeslistified version.
Let's just call it what it is. We want a list | None, and we handle it too.
3 years ago
def _process_install_tag ( install_tag : T . Optional [ T . List [ T . Optional [ str ] ] ] ,
num_outputs : int ) - > T . List [ T . Optional [ str ] ] :
_install_tag : T . List [ T . Optional [ str ] ]
if not install_tag :
_install_tag = [ None ] * num_outputs
elif len ( install_tag ) == 1 :
simplify install_tag handling according to the accepted API
There are two problems here: a typing problem, and an algorithm problem.
We expect it to always be passed to CustomTarget() as a list, but we ran
list() on it, which became horribly mangled if you violated the types
and passed a string instead. This caused weird*er* errors and didn't
even do anything. We want to do all validation in the interpreter,
anyway, and make the build level dumb.
Meanwhile we type it as accepting a T.Sequence, which technically
permits... a string, actually. This isn't intentional; the point of
using T.Sequence is out of a misguided idea that APIs are supposed to be
"technically correct" by allowing "anything that fulfills an interface",
which is a flawed concept because we aren't using interfaces here, and
also because "technically string fulfills the same interface as a list,
if we're talking sequences".
Basically:
- mypy is broken by design, because it typechecks "python", not "what we
wish python to be"
- we do not actually need to graciously permit passing tuples instead of
lists
As far as historic implementations of this logic go, we have formerly:
- originally, typeslistified anything
- switched to accepting list from the interpreter, redundantly ran list()
on the list we got, and mishandling API violations passing a string
(commit 11f96380351a88059ec55f1070fdebc1b1033117)
- switched to accepting anything, stringlistifying it if it was not
`None`, mishandling `[None]`, and invoking list(x) on a brand new list
from stringlistify (commit 157d43883515507f42618b065a64fb26501734a0)
- stopped stringlistify, just accept T.List[str | None] and re-cast to
list, violates typing because we use/handle plain None too
(commit a8521fef70ef76fb742d80aceb2e9ed634bd6a70)
- break typing by declaring we accept a simple string, which still
results in mishandling by converting 'foo' -> ['f', 'o', 'o']
(commit ac576530c43734495815f22456596772a8f6a8cc)
All of this. ALL of it. Is because we tried to be fancy and say we
accept T.Tuple; the only version of this logic that has ever worked
correctly is the original untyped do-all-validation-in-the-build-phase
typeslistified version.
Let's just call it what it is. We want a list | None, and we handle it too.
3 years ago
_install_tag = install_tag * num_outputs
else :
simplify install_tag handling according to the accepted API
There are two problems here: a typing problem, and an algorithm problem.
We expect it to always be passed to CustomTarget() as a list, but we ran
list() on it, which became horribly mangled if you violated the types
and passed a string instead. This caused weird*er* errors and didn't
even do anything. We want to do all validation in the interpreter,
anyway, and make the build level dumb.
Meanwhile we type it as accepting a T.Sequence, which technically
permits... a string, actually. This isn't intentional; the point of
using T.Sequence is out of a misguided idea that APIs are supposed to be
"technically correct" by allowing "anything that fulfills an interface",
which is a flawed concept because we aren't using interfaces here, and
also because "technically string fulfills the same interface as a list,
if we're talking sequences".
Basically:
- mypy is broken by design, because it typechecks "python", not "what we
wish python to be"
- we do not actually need to graciously permit passing tuples instead of
lists
As far as historic implementations of this logic go, we have formerly:
- originally, typeslistified anything
- switched to accepting list from the interpreter, redundantly ran list()
on the list we got, and mishandling API violations passing a string
(commit 11f96380351a88059ec55f1070fdebc1b1033117)
- switched to accepting anything, stringlistifying it if it was not
`None`, mishandling `[None]`, and invoking list(x) on a brand new list
from stringlistify (commit 157d43883515507f42618b065a64fb26501734a0)
- stopped stringlistify, just accept T.List[str | None] and re-cast to
list, violates typing because we use/handle plain None too
(commit a8521fef70ef76fb742d80aceb2e9ed634bd6a70)
- break typing by declaring we accept a simple string, which still
results in mishandling by converting 'foo' -> ['f', 'o', 'o']
(commit ac576530c43734495815f22456596772a8f6a8cc)
All of this. ALL of it. Is because we tried to be fancy and say we
accept T.Tuple; the only version of this logic that has ever worked
correctly is the original untyped do-all-validation-in-the-build-phase
typeslistified version.
Let's just call it what it is. We want a list | None, and we handle it too.
3 years ago
_install_tag = install_tag
return _install_tag
@lru_cache ( maxsize = None )
def get_target_macos_dylib_install_name ( ld ) - > str :
name = [ ' @rpath/ ' , ld . prefix , ld . name ]
if ld . soversion is not None :
name . append ( ' . ' + ld . soversion )
name . append ( ' .dylib ' )
return ' ' . join ( name )
class InvalidArguments ( MesonException ) :
pass
@dataclass ( eq = False )
class DependencyOverride ( HoldableObject ) :
dep : dependencies . Dependency
node : ' BaseNode '
explicit : bool = True
@dataclass ( eq = False )
class Headers ( HoldableObject ) :
sources : T . List [ File ]
install_subdir : T . Optional [ str ]
custom_install_dir : T . Optional [ str ]
custom_install_mode : ' FileMode '
subproject : str
# TODO: we really don't need any of these methods, but they're preserved to
# keep APIs relying on them working.
def set_install_subdir ( self , subdir : str ) - > None :
self . install_subdir = subdir
def get_install_subdir ( self ) - > T . Optional [ str ] :
return self . install_subdir
def get_sources ( self ) - > T . List [ File ] :
return self . sources
def get_custom_install_dir ( self ) - > T . Optional [ str ] :
return self . custom_install_dir
def get_custom_install_mode ( self ) - > ' FileMode ' :
return self . custom_install_mode
@dataclass ( eq = False )
class Man ( HoldableObject ) :
sources : T . List [ File ]
custom_install_dir : T . Optional [ str ]
custom_install_mode : ' FileMode '
subproject : str
locale : T . Optional [ str ]
def get_custom_install_dir ( self ) - > T . Optional [ str ] :
return self . custom_install_dir
def get_custom_install_mode ( self ) - > ' FileMode ' :
return self . custom_install_mode
def get_sources ( self ) - > T . List [ ' File ' ] :
return self . sources
@dataclass ( eq = False )
class EmptyDir ( HoldableObject ) :
path : str
install_mode : ' FileMode '
subproject : str
install_tag : T . Optional [ str ] = None
@dataclass ( eq = False )
class InstallDir ( HoldableObject ) :
source_subdir : str
installable_subdir : str
install_dir : str
install_dir_name : str
install_mode : ' FileMode '
exclude : T . Tuple [ T . Set [ str ] , T . Set [ str ] ]
strip_directory : bool
subproject : str
from_source_dir : bool = True
install_tag : T . Optional [ str ] = None
@dataclass ( eq = False )
class DepManifest :
version : str
license : T . List [ str ]
license_files : T . List [ T . Tuple [ str , File ] ]
subproject : str
def to_json ( self ) - > T . Dict [ str , T . Union [ str , T . List [ str ] ] ] :
return {
' version ' : self . version ,
' license ' : self . license ,
' license_files ' : [ l [ 1 ] . relative_name ( ) for l in self . license_files ] ,
}
# literally everything isn't dataclass stuff
class Build :
""" A class that holds the status of one build including
all dependencies and so on .
"""
def __init__ ( self , environment : environment . Environment ) :
self . version = coredata . version
self . project_name = ' name of master project '
self . project_version = None
self . environment = environment
self . projects = { }
self . targets : ' T.OrderedDict[str, T.Union[CustomTarget, BuildTarget]] ' = OrderedDict ( )
self . global_args : PerMachine [ T . Dict [ str , T . List [ str ] ] ] = PerMachine ( { } , { } )
self . global_link_args : PerMachine [ T . Dict [ str , T . List [ str ] ] ] = PerMachine ( { } , { } )
self . projects_args : PerMachine [ T . Dict [ str , T . Dict [ str , T . List [ str ] ] ] ] = PerMachine ( { } , { } )
self . projects_link_args : PerMachine [ T . Dict [ str , T . Dict [ str , T . List [ str ] ] ] ] = PerMachine ( { } , { } )
self . tests : T . List [ ' Test ' ] = [ ]
self . benchmarks : T . List [ ' Test ' ] = [ ]
self . headers : T . List [ Headers ] = [ ]
self . man : T . List [ Man ] = [ ]
self . emptydir : T . List [ EmptyDir ] = [ ]
self . data : T . List [ Data ] = [ ]
self . symlinks : T . List [ SymlinkData ] = [ ]
self . static_linker : PerMachine [ StaticLinker ] = PerMachine ( None , None )
self . subprojects = { }
self . subproject_dir = ' '
self . install_scripts : T . List [ ' ExecutableSerialisation ' ] = [ ]
self . postconf_scripts : T . List [ ' ExecutableSerialisation ' ] = [ ]
self . dist_scripts : T . List [ ' ExecutableSerialisation ' ] = [ ]
self . install_dirs : T . List [ InstallDir ] = [ ]
self . dep_manifest_name : T . Optional [ str ] = None
self . dep_manifest : T . Dict [ str , DepManifest ] = { }
self . stdlibs = PerMachine ( { } , { } )
self . test_setups : T . Dict [ str , TestSetup ] = { }
self . test_setup_default_name = None
self . find_overrides : T . Dict [ str , T . Union [ ' Executable ' , programs . ExternalProgram , programs . OverrideProgram ] ] = { }
self . searched_programs : T . Set [ str ] = set ( ) # The list of all programs that have been searched for.
# If we are doing a cross build we need two caches, if we're doing a
# build == host compilation the both caches should point to the same place.
self . dependency_overrides : PerMachine [ T . Dict [ T . Tuple , DependencyOverride ] ] = PerMachineDefaultable . default (
environment . is_cross_build ( ) , { } , { } )
self . devenv : T . List [ EnvironmentVariables ] = [ ]
self . modules : T . List [ str ] = [ ]
def get_build_targets ( self ) :
build_targets = OrderedDict ( )
for name , t in self . targets . items ( ) :
if isinstance ( t , BuildTarget ) :
build_targets [ name ] = t
return build_targets
def get_custom_targets ( self ) :
custom_targets = OrderedDict ( )
for name , t in self . targets . items ( ) :
if isinstance ( t , CustomTarget ) :
custom_targets [ name ] = t
return custom_targets
def copy ( self ) - > Build :
other = Build ( self . environment )
for k , v in self . __dict__ . items ( ) :
if isinstance ( v , ( list , dict , set , OrderedDict ) ) :
other . __dict__ [ k ] = v . copy ( )
else :
other . __dict__ [ k ] = v
return other
def merge ( self , other : Build ) - > None :
for k , v in other . __dict__ . items ( ) :
self . __dict__ [ k ] = v
def ensure_static_linker ( self , compiler : Compiler ) - > None :
if self . static_linker [ compiler . for_machine ] is None and compiler . needs_static_linker ( ) :
self . static_linker [ compiler . for_machine ] = detect_static_linker ( self . environment , compiler )
def get_project ( self ) :
return self . projects [ ' ' ]
def get_subproject_dir ( self ) :
return self . subproject_dir
def get_targets ( self ) - > ' T.OrderedDict[str, T.Union[CustomTarget, BuildTarget]] ' :
return self . targets
def get_tests ( self ) - > T . List [ ' Test ' ] :
return self . tests
def get_benchmarks ( self ) - > T . List [ ' Test ' ] :
return self . benchmarks
def get_headers ( self ) - > T . List [ ' Headers ' ] :
return self . headers
def get_man ( self ) - > T . List [ ' Man ' ] :
return self . man
def get_data ( self ) - > T . List [ ' Data ' ] :
return self . data
def get_symlinks ( self ) - > T . List [ ' SymlinkData ' ] :
return self . symlinks
def get_emptydir ( self ) - > T . List [ ' EmptyDir ' ] :
return self . emptydir
def get_install_subdirs ( self ) - > T . List [ ' InstallDir ' ] :
return self . install_dirs
def get_global_args ( self , compiler : ' Compiler ' , for_machine : ' MachineChoice ' ) - > T . List [ str ] :
d = self . global_args [ for_machine ]
return d . get ( compiler . get_language ( ) , [ ] )
def get_project_args ( self , compiler : ' Compiler ' , project : str , for_machine : ' MachineChoice ' ) - > T . List [ str ] :
d = self . projects_args [ for_machine ]
args = d . get ( project )
if not args :
return [ ]
return args . get ( compiler . get_language ( ) , [ ] )
def get_global_link_args ( self , compiler : ' Compiler ' , for_machine : ' MachineChoice ' ) - > T . List [ str ] :
d = self . global_link_args [ for_machine ]
return d . get ( compiler . get_language ( ) , [ ] )
def get_project_link_args ( self , compiler : ' Compiler ' , project : str , for_machine : ' MachineChoice ' ) - > T . List [ str ] :
d = self . projects_link_args [ for_machine ]
link_args = d . get ( project )
if not link_args :
return [ ]
return link_args . get ( compiler . get_language ( ) , [ ] )
@dataclass ( eq = False )
class IncludeDirs ( HoldableObject ) :
""" Internal representation of an include_directories call. """
curdir : str
incdirs : T . List [ str ]
is_system : bool
# Interpreter has validated that all given directories
# actually exist.
extra_build_dirs : T . List [ str ] = field ( default_factory = list )
def __repr__ ( self ) - > str :
r = ' < {} {} / {} > '
return r . format ( self . __class__ . __name__ , self . curdir , self . incdirs )
def get_curdir ( self ) - > str :
return self . curdir
def get_incdirs ( self ) - > T . List [ str ] :
return self . incdirs
def get_extra_build_dirs ( self ) - > T . List [ str ] :
return self . extra_build_dirs
def to_string_list ( self , sourcedir : str , builddir : T . Optional [ str ] = None ) - > T . List [ str ] :
""" Convert IncludeDirs object to a list of strings.
: param sourcedir : The absolute source directory
: param builddir : The absolute build directory , option , build dir will not
be added if this is unset
: returns : A list of strings ( without compiler argument )
"""
strlist : T . List [ str ] = [ ]
for idir in self . incdirs :
strlist . append ( os . path . join ( sourcedir , self . curdir , idir ) )
if builddir :
strlist . append ( os . path . join ( builddir , self . curdir , idir ) )
return strlist
@dataclass ( eq = False )
class ExtractedObjects ( HoldableObject ) :
'''
Holds a list of sources for which the objects must be extracted
'''
target : ' BuildTarget '
srclist : T . List [ File ] = field ( default_factory = list )
genlist : T . List [ ' GeneratedTypes ' ] = field ( default_factory = list )
objlist : T . List [ T . Union [ str , ' File ' , ' ExtractedObjects ' ] ] = field ( default_factory = list )
recursive : bool = True
def __post_init__ ( self ) - > None :
if self . target . is_unity :
self . check_unity_compatible ( )
def __repr__ ( self ) - > str :
r = ' < {0} {1!r} : {2} > '
return r . format ( self . __class__ . __name__ , self . target . name , self . srclist )
@staticmethod
def get_sources ( sources : T . Sequence [ ' FileOrString ' ] , generated_sources : T . Sequence [ ' GeneratedTypes ' ] ) - > T . List [ ' FileOrString ' ] :
# Merge sources and generated sources
sources = list ( sources )
for gensrc in generated_sources :
for s in gensrc . get_outputs ( ) :
# We cannot know the path where this source will be generated,
# but all we need here is the file extension to determine the
# compiler.
sources . append ( s )
# Filter out headers and all non-source files
return [ s for s in sources if environment . is_source ( s ) ]
def classify_all_sources ( self , sources : T . List [ FileOrString ] , generated_sources : T . Sequence [ ' GeneratedTypes ' ] ) - > T . Dict [ ' Compiler ' , T . List [ ' FileOrString ' ] ] :
sources_ = self . get_sources ( sources , generated_sources )
return classify_unity_sources ( self . target . compilers . values ( ) , sources_ )
def check_unity_compatible ( self ) - > None :
# Figure out if the extracted object list is compatible with a Unity
# build. When we're doing a Unified build, we go through the sources,
# and create a single source file from each subset of the sources that
# can be compiled with a specific compiler. Then we create one object
# from each unified source file. So for each compiler we can either
# extra all its sources or none.
cmpsrcs = self . classify_all_sources ( self . target . sources , self . target . generated )
extracted_cmpsrcs = self . classify_all_sources ( self . srclist , self . genlist )
for comp , srcs in extracted_cmpsrcs . items ( ) :
if set ( srcs ) != set ( cmpsrcs [ comp ] ) :
raise MesonException ( ' Single object files cannot be extracted '
' in Unity builds. You can only extract all '
' the object files for each compiler at once. ' )
@dataclass ( eq = False , order = False )
class StructuredSources ( HoldableObject ) :
""" A container for sources in languages that use filesystem hierarchy.
Languages like Rust and Cython rely on the layout of files in the filesystem
as part of the compiler implementation . This structure allows us to
represent the required filesystem layout .
"""
sources : T . DefaultDict [ str , T . List [ T . Union [ File , CustomTarget , CustomTargetIndex , GeneratedList ] ] ] = field (
default_factory = lambda : defaultdict ( list ) )
def __add__ ( self , other : StructuredSources ) - > StructuredSources :
sources = self . sources . copy ( )
for k , v in other . sources . items ( ) :
sources [ k ] . extend ( v )
return StructuredSources ( sources )
def __bool__ ( self ) - > bool :
return bool ( self . sources )
def first_file ( self ) - > T . Union [ File , CustomTarget , CustomTargetIndex , GeneratedList ] :
""" Get the first source in the root
: return : The first source in the root
"""
return self . sources [ ' ' ] [ 0 ]
def as_list ( self ) - > T . List [ T . Union [ File , CustomTarget , CustomTargetIndex , GeneratedList ] ] :
return list ( itertools . chain . from_iterable ( self . sources . values ( ) ) )
def needs_copy ( self ) - > bool :
""" Do we need to create a structure in the build directory.
This allows us to avoid making copies if the structures exists in the
source dir . Which could happen in situations where a generated source
only exists in some configurations
"""
for files in self . sources . values ( ) :
for f in files :
if isinstance ( f , File ) :
if f . is_built :
return True
else :
return True
return False
@dataclass ( eq = False )
class Target ( HoldableObject , metaclass = abc . ABCMeta ) :
name : str
subdir : str
subproject : ' SubProject '
build_by_default : bool
for_machine : MachineChoice
environment : environment . Environment
install : bool = False
build_always_stale : bool = False
extra_files : T . List [ File ] = field ( default_factory = list )
override_options : InitVar [ T . Optional [ T . Dict [ OptionKey , str ] ] ] = None
@abc . abstractproperty
def typename ( self ) - > str :
pass
@abc . abstractmethod
def type_suffix ( self ) - > str :
pass
def __post_init__ ( self , overrides : T . Optional [ T . Dict [ OptionKey , str ] ] ) - > None :
if overrides :
ovr = { k . evolve ( machine = self . for_machine ) if k . lang else k : v
for k , v in overrides . items ( ) }
else :
ovr = { }
self . options = OptionOverrideProxy ( ovr , self . environment . coredata . options , self . subproject )
# XXX: this should happen in the interpreter
if has_path_sep ( self . name ) :
# Fix failing test 53 when this becomes an error.
mlog . warning ( textwrap . dedent ( f ''' \
Target " {self.name} " has a path separator in its name .
This is not supported , it can cause unexpected failures and will become
a hard error in the future . ''' ))
# dataclass comparators?
def __lt__ ( self , other : object ) - > bool :
if not isinstance ( other , Target ) :
return NotImplemented
return self . get_id ( ) < other . get_id ( )
def __le__ ( self , other : object ) - > bool :
if not isinstance ( other , Target ) :
return NotImplemented
return self . get_id ( ) < = other . get_id ( )
def __gt__ ( self , other : object ) - > bool :
if not isinstance ( other , Target ) :
return NotImplemented
return self . get_id ( ) > other . get_id ( )
def __ge__ ( self , other : object ) - > bool :
if not isinstance ( other , Target ) :
return NotImplemented
return self . get_id ( ) > = other . get_id ( )
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
raise NotImplementedError
def get_custom_install_dir ( self ) - > T . List [ T . Union [ str , Literal [ False ] ] ] :
raise NotImplementedError
def get_install_dir ( self ) - > T . Tuple [ T . List [ T . Union [ str , Literal [ False ] ] ] , str , Literal [ False ] ] :
# Find the installation directory.
default_install_dir , default_install_dir_name = self . get_default_install_dir ( )
outdirs = self . get_custom_install_dir ( )
if outdirs and outdirs [ 0 ] != default_install_dir and outdirs [ 0 ] is not True :
# Either the value is set to a non-default value, or is set to
# False (which means we want this specific output out of many
# outputs to not be installed).
custom_install_dir = True
install_dir_names = [ getattr ( i , ' optname ' , None ) for i in outdirs ]
else :
custom_install_dir = False
# if outdirs is empty we need to set to something, otherwise we set
# only the first value to the default.
if outdirs :
outdirs [ 0 ] = default_install_dir
else :
outdirs = [ default_install_dir ]
install_dir_names = [ default_install_dir_name ] * len ( outdirs )
return outdirs , install_dir_names , custom_install_dir
def get_basename ( self ) - > str :
return self . name
def get_subdir ( self ) - > str :
return self . subdir
def get_typename ( self ) - > str :
return self . typename
@staticmethod
def _get_id_hash ( target_id : str ) - > str :
# We don't really need cryptographic security here.
# Small-digest hash function with unlikely collision is good enough.
h = hashlib . sha256 ( )
h . update ( target_id . encode ( encoding = ' utf-8 ' , errors = ' replace ' ) )
# This ID should be case-insensitive and should work in Visual Studio,
# e.g. it should not start with leading '-'.
return h . hexdigest ( ) [ : 7 ]
@staticmethod
def construct_id_from_path ( subdir : str , name : str , type_suffix : str ) - > str :
""" Construct target ID from subdir, name and type suffix.
This helper function is made public mostly for tests . """
# This ID must also be a valid file name on all OSs.
# It should also avoid shell metacharacters for obvious
# reasons. '@' is not used as often as '_' in source code names.
# In case of collisions consider using checksums.
# FIXME replace with assert when slash in names is prohibited
name_part = name . replace ( ' / ' , ' @ ' ) . replace ( ' \\ ' , ' @ ' )
assert not has_path_sep ( type_suffix )
my_id = name_part + type_suffix
if subdir :
subdir_part = Target . _get_id_hash ( subdir )
# preserve myid for better debuggability
return subdir_part + ' @@ ' + my_id
return my_id
def get_id ( self ) - > str :
return self . construct_id_from_path (
self . subdir , self . name , self . type_suffix ( ) )
def process_kwargs_base ( self , kwargs : T . Dict [ str , T . Any ] ) - > None :
if ' build_by_default ' in kwargs :
self . build_by_default = kwargs [ ' build_by_default ' ]
if not isinstance ( self . build_by_default , bool ) :
raise InvalidArguments ( ' build_by_default must be a boolean value. ' )
elif kwargs . get ( ' install ' , False ) :
# For backward compatibility, if build_by_default is not explicitly
# set, use the value of 'install' if it's enabled.
self . build_by_default = True
self . set_option_overrides ( self . parse_overrides ( kwargs ) )
def set_option_overrides ( self , option_overrides : T . Dict [ OptionKey , str ] ) - > None :
self . options . overrides = { }
for k , v in option_overrides . items ( ) :
if k . lang :
self . options . overrides [ k . evolve ( machine = self . for_machine ) ] = v
else :
self . options . overrides [ k ] = v
def get_options ( self ) - > OptionOverrideProxy :
return self . options
def get_option ( self , key : ' OptionKey ' ) - > T . Union [ str , int , bool , ' WrapMode ' ] :
# We don't actually have wrapmode here to do an assert, so just do a
# cast, we know what's in coredata anyway.
# TODO: if it's possible to annotate get_option or validate_option_value
# in the future we might be able to remove the cast here
return T . cast ( ' T.Union[str, int, bool, WrapMode] ' , self . options [ key ] . value )
@staticmethod
def parse_overrides ( kwargs : T . Dict [ str , T . Any ] ) - > T . Dict [ OptionKey , str ] :
opts = kwargs . get ( ' override_options ' , [ ] )
# In this case we have an already parsed and ready to go dictionary
# provided by typed_kwargs
if isinstance ( opts , dict ) :
return T . cast ( ' T.Dict[OptionKey, str] ' , opts )
result : T . Dict [ OptionKey , str ] = { }
overrides = stringlistify ( opts )
for o in overrides :
if ' = ' not in o :
raise InvalidArguments ( ' Overrides must be of form " key=value " ' )
k , v = o . split ( ' = ' , 1 )
key = OptionKey . from_string ( k . strip ( ) )
v = v . strip ( )
result [ key ] = v
return result
def is_linkable_target ( self ) - > bool :
return False
def get_outputs ( self ) - > T . List [ str ] :
return [ ]
def should_install ( self ) - > bool :
return False
class BuildTarget ( Target ) :
known_kwargs = known_build_target_kwargs
install_dir : T . List [ T . Union [ str , Literal [ False ] ] ]
def __init__ (
self ,
name : str ,
subdir : str ,
subproject : SubProject ,
for_machine : MachineChoice ,
sources : T . List [ ' SourceOutputs ' ] ,
structured_sources : T . Optional [ StructuredSources ] ,
objects : T . List [ ObjectTypes ] ,
environment : environment . Environment ,
compilers : T . Dict [ str , ' Compiler ' ] ,
kwargs ) :
super ( ) . __init__ ( name , subdir , subproject , True , for_machine , environment )
self . all_compilers = compilers
self . compilers = OrderedDict ( ) # type: OrderedDict[str, Compiler]
self . objects : T . List [ ObjectTypes ] = [ ]
self . structured_sources = structured_sources
self . external_deps : T . List [ dependencies . Dependency ] = [ ]
self . include_dirs : T . List [ ' IncludeDirs ' ] = [ ]
self . link_language = kwargs . get ( ' link_language ' )
self . link_targets : T . List [ LibTypes ] = [ ]
self . link_whole_targets : T . List [ T . Union [ StaticLibrary , CustomTarget , CustomTargetIndex ] ] = [ ]
self . link_depends = [ ]
self . added_deps = set ( )
self . name_prefix_set = False
self . name_suffix_set = False
self . filename = ' no_name '
# The list of all files outputted by this target. Useful in cases such
# as Vala which generates .vapi and .h besides the compiled output.
self . outputs = [ self . filename ]
self . need_install = False
self . pch : T . Dict [ str , T . List [ str ] ] = { }
self . extra_args : T . Dict [ str , T . List [ ' FileOrString ' ] ] = { }
self . sources : T . List [ File ] = [ ]
self . generated : T . List [ ' GeneratedTypes ' ] = [ ]
self . extra_files : T . List [ File ] = [ ]
self . d_features = defaultdict ( list )
self . pic = False
self . pie = False
# Track build_rpath entries so we can remove them at install time
self . rpath_dirs_to_remove : T . Set [ bytes ] = set ( )
self . process_sourcelist ( sources )
# Objects can be:
# 1. Preexisting objects provided by the user with the `objects:` kwarg
# 2. Compiled objects created by and extracted from another target
self . process_objectlist ( objects )
self . process_kwargs ( kwargs )
if not any ( [ self . sources , self . generated , self . objects , self . link_whole_targets , self . structured_sources ,
kwargs . pop ( ' _allow_no_sources ' , False ) ] ) :
mlog . warning ( f ' Build target { name } has no sources. '
' This was never supposed to be allowed but did because of a bug, '
' support will be removed in a future release of Meson ' )
self . check_unknown_kwargs ( kwargs )
self . validate_install ( )
self . check_module_linking ( )
def post_init ( self ) - > None :
''' Initialisations and checks requiring the final list of compilers to be known
'''
self . validate_sources ( )
if self . structured_sources and any ( [ self . sources , self . generated ] ) :
raise MesonException ( ' cannot mix structured sources and unstructured sources ' )
if self . structured_sources and ' rust ' not in self . compilers :
raise MesonException ( ' structured sources are only supported in Rust targets ' )
if self . uses_rust ( ) :
# relocation-model=pic is rustc's default and Meson does not
# currently have a way to disable PIC.
self . pic = True
def __repr__ ( self ) :
repr_str = " < {0} {1} : {2} > "
return repr_str . format ( self . __class__ . __name__ , self . get_id ( ) , self . filename )
def __str__ ( self ) :
return f " { self . name } "
@property
def is_unity ( self ) - > bool :
unity_opt = self . get_option ( OptionKey ( ' unity ' ) )
return unity_opt == ' on ' or ( unity_opt == ' subprojects ' and self . subproject != ' ' )
def validate_install ( self ) :
if self . for_machine is MachineChoice . BUILD and self . need_install :
if self . environment . is_cross_build ( ) :
raise InvalidArguments ( ' Tried to install a target for the build machine in a cross build. ' )
else :
mlog . warning ( ' Installing target build for the build machine. This will fail in a cross build. ' )
def check_unknown_kwargs ( self , kwargs ) :
# Override this method in derived classes that have more
# keywords.
self . check_unknown_kwargs_int ( kwargs , self . known_kwargs )
def check_unknown_kwargs_int ( self , kwargs , known_kwargs ) :
unknowns = [ ]
for k in kwargs :
if k not in known_kwargs :
unknowns . append ( k )
if len ( unknowns ) > 0 :
mlog . warning ( ' Unknown keyword argument(s) in target {} : {} . ' . format ( self . name , ' , ' . join ( unknowns ) ) )
def process_objectlist ( self , objects ) :
assert isinstance ( objects , list )
for s in objects :
if isinstance ( s , ( str , File , ExtractedObjects ) ) :
self . objects . append ( s )
elif isinstance ( s , ( CustomTarget , CustomTargetIndex , GeneratedList ) ) :
non_objects = [ o for o in s . get_outputs ( ) if not is_object ( o ) ]
if non_objects :
raise InvalidArguments ( f ' Generated file { non_objects [ 0 ] } in the \' objects \' kwarg is not an object. ' )
self . generated . append ( s )
else :
raise InvalidArguments ( f ' Bad object of type { type ( s ) . __name__ !r} in target { self . name !r} . ' )
def process_sourcelist ( self , sources : T . List [ ' SourceOutputs ' ] ) - > None :
""" Split sources into generated and static sources.
Sources can be :
1. Preexisting source files in the source tree ( static )
2. Preexisting sources generated by configure_file in the build tree .
( static as they are only regenerated if meson itself is regenerated )
3. Sources files generated by another target or a Generator ( generated )
"""
added_sources : T . Set [ File ] = set ( ) # If the same source is defined multiple times, use it only once.
for s in sources :
if isinstance ( s , File ) :
if s not in added_sources :
self . sources . append ( s )
added_sources . add ( s )
elif isinstance ( s , ( CustomTarget , CustomTargetIndex , GeneratedList ) ) :
self . generated . append ( s )
@staticmethod
def can_compile_remove_sources ( compiler : ' Compiler ' , sources : T . List [ ' FileOrString ' ] ) - > bool :
removed = False
for s in sources [ : ] :
if compiler . can_compile ( s ) :
sources . remove ( s )
removed = True
return removed
def process_compilers_late ( self , extra_languages : T . List [ str ] ) :
""" Processes additional compilers after kwargs have been evaluated.
This can add extra compilers that might be required by keyword
arguments , such as link_with or dependencies . It will also try to guess
which compiler to use if one hasn ' t been selected already.
"""
for lang in extra_languages :
self . compilers [ lang ] = self . all_compilers [ lang ]
# did user override clink_langs for this target?
link_langs = [ self . link_language ] if self . link_language else clink_langs
# If this library is linked against another library we need to consider
# the languages of those libraries as well.
if self . link_targets or self . link_whole_targets :
for t in itertools . chain ( self . link_targets , self . link_whole_targets ) :
if isinstance ( t , ( CustomTarget , CustomTargetIndex ) ) :
continue # We can't know anything about these.
for name , compiler in t . compilers . items ( ) :
if name in link_langs and name not in self . compilers :
self . compilers [ name ] = compiler
if not self . compilers :
# No source files or parent targets, target consists of only object
# files of unknown origin. Just add the first clink compiler
# that we have and hope that it can link these objects
for lang in link_langs :
if lang in self . all_compilers :
self . compilers [ lang ] = self . all_compilers [ lang ]
break
# Now that we have the final list of compilers we can sort it according
# to clink_langs and do sanity checks.
self . compilers = OrderedDict ( sorted ( self . compilers . items ( ) ,
key = lambda t : sort_clink ( t [ 0 ] ) ) )
self . post_init ( )
def process_compilers ( self ) - > T . List [ str ] :
'''
Populate self . compilers , which is the list of compilers that this
target will use for compiling all its sources .
We also add compilers that were used by extracted objects to simplify
dynamic linker determination .
Returns a list of missing languages that we can add implicitly , such as
C / C + + compiler for cython .
'''
missing_languages : T . List [ str ] = [ ]
if not any ( [ self . sources , self . generated , self . objects , self . structured_sources ] ) :
return missing_languages
# Preexisting sources
sources : T . List [ ' FileOrString ' ] = list ( self . sources )
generated = self . generated . copy ( )
if self . structured_sources :
for v in self . structured_sources . sources . values ( ) :
for src in v :
if isinstance ( src , ( str , File ) ) :
sources . append ( src )
else :
generated . append ( src )
# All generated sources
for gensrc in generated :
for s in gensrc . get_outputs ( ) :
# Generated objects can't be compiled, so don't use them for
# compiler detection. If our target only has generated objects,
# we will fall back to using the first c-like compiler we find,
# which is what we need.
if not is_object ( s ) :
sources . append ( s )
for d in self . external_deps :
for s in d . sources :
if isinstance ( s , ( str , File ) ) :
sources . append ( s )
# Sources that were used to create our extracted objects
for o in self . objects :
if not isinstance ( o , ExtractedObjects ) :
continue
compsrcs = o . classify_all_sources ( o . srclist , [ ] )
for comp in compsrcs :
# Don't add Vala sources since that will pull in the Vala
# compiler even though we will never use it since we are
# dealing with compiled C code.
if comp . language == ' vala ' :
continue
if comp . language not in self . compilers :
self . compilers [ comp . language ] = comp
if sources :
# For each source, try to add one compiler that can compile it.
#
# If it has a suffix that belongs to a known language, we must have
# a compiler for that language.
#
# Otherwise, it's ok if no compilers can compile it, because users
# are expected to be able to add arbitrary non-source files to the
# sources list
for s in sources :
for lang , compiler in self . all_compilers . items ( ) :
if compiler . can_compile ( s ) :
if lang not in self . compilers :
self . compilers [ lang ] = compiler
break
else :
if is_known_suffix ( s ) :
path = pathlib . Path ( str ( s ) ) . as_posix ( )
m = f ' No { self . for_machine . get_lower_case_name ( ) } machine compiler for { path !r} '
raise MesonException ( m )
# If all our sources are Vala, our target also needs the C compiler but
# it won't get added above.
if ' vala ' in self . compilers and ' c ' not in self . compilers :
self . compilers [ ' c ' ] = self . all_compilers [ ' c ' ]
if ' cython ' in self . compilers :
key = OptionKey ( ' language ' , machine = self . for_machine , lang = ' cython ' )
value = self . get_option ( key )
try :
self . compilers [ value ] = self . all_compilers [ value ]
except KeyError :
missing_languages . append ( value )
return missing_languages
def validate_sources ( self ) :
if len ( self . compilers ) > 1 and any ( lang in self . compilers for lang in [ ' cs ' , ' java ' ] ) :
langs = ' , ' . join ( self . compilers . keys ( ) )
raise InvalidArguments ( f ' Cannot mix those languages into a target: { langs } ' )
def process_link_depends ( self , sources ) :
""" Process the link_depends keyword argument.
This is designed to handle strings , Files , and the output of Custom
Targets . Notably it doesn ' t handle generator() returned objects, since
adding them as a link depends would inherently cause them to be
generated twice , since the output needs to be passed to the ld_args and
link_depends .
"""
sources = listify ( sources )
for s in sources :
if isinstance ( s , File ) :
self . link_depends . append ( s )
elif isinstance ( s , str ) :
self . link_depends . append (
File . from_source_file ( self . environment . source_dir , self . subdir , s ) )
elif hasattr ( s , ' get_outputs ' ) :
self . link_depends . append ( s )
else :
raise InvalidArguments (
' Link_depends arguments must be strings, Files, '
' or a Custom Target, or lists thereof. ' )
def get_original_kwargs ( self ) :
return self . kwargs
def copy_kwargs ( self , kwargs ) :
self . kwargs = copy . copy ( kwargs )
for k , v in self . kwargs . items ( ) :
if isinstance ( v , list ) :
self . kwargs [ k ] = listify ( v , flatten = True )
for t in [ ' dependencies ' , ' link_with ' , ' include_directories ' , ' sources ' ] :
if t in self . kwargs :
self . kwargs [ t ] = listify ( self . kwargs [ t ] , flatten = True )
def extract_objects ( self , srclist : T . List [ T . Union [ ' FileOrString ' , ' GeneratedTypes ' ] ] ) - > ExtractedObjects :
sources_set = set ( self . sources )
generated_set = set ( self . generated )
obj_src : T . List [ ' File ' ] = [ ]
obj_gen : T . List [ ' GeneratedTypes ' ] = [ ]
for src in srclist :
if isinstance ( src , ( str , File ) ) :
if isinstance ( src , str ) :
src = File ( False , self . subdir , src )
else :
FeatureNew . single_use ( ' File argument for extract_objects ' , ' 0.50.0 ' , self . subproject )
if src not in sources_set :
raise MesonException ( f ' Tried to extract unknown source { src } . ' )
obj_src . append ( src )
elif isinstance ( src , ( CustomTarget , CustomTargetIndex , GeneratedList ) ) :
FeatureNew . single_use ( ' Generated sources for extract_objects ' , ' 0.61.0 ' , self . subproject )
target = src . target if isinstance ( src , CustomTargetIndex ) else src
if src not in generated_set and target not in generated_set :
raise MesonException ( f ' Tried to extract unknown source { target . get_basename ( ) } . ' )
obj_gen . append ( src )
else :
raise MesonException ( f ' Object extraction arguments must be strings, Files or targets (got { type ( src ) . __name__ } ). ' )
return ExtractedObjects ( self , obj_src , obj_gen )
def extract_all_objects ( self , recursive : bool = True ) - > ExtractedObjects :
return ExtractedObjects ( self , self . sources , self . generated , self . objects ,
recursive )
def get_all_link_deps ( self ) - > ImmutableListProtocol [ BuildTargetTypes ] :
return self . get_transitive_link_deps ( )
@lru_cache ( maxsize = None )
def get_transitive_link_deps ( self ) - > ImmutableListProtocol [ BuildTargetTypes ] :
result : T . List [ Target ] = [ ]
for i in self . link_targets :
result + = i . get_all_link_deps ( )
return result
def get_link_deps_mapping ( self , prefix : str ) - > T . Mapping [ str , str ] :
return self . get_transitive_link_deps_mapping ( prefix )
@lru_cache ( maxsize = None )
def get_transitive_link_deps_mapping ( self , prefix : str ) - > T . Mapping [ str , str ] :
result : T . Dict [ str , str ] = { }
for i in self . link_targets :
mapping = i . get_link_deps_mapping ( prefix )
#we are merging two dictionaries, while keeping the earlier one dominant
result_tmp = mapping . copy ( )
result_tmp . update ( result )
result = result_tmp
return result
@lru_cache ( maxsize = None )
def get_link_dep_subdirs ( self ) - > T . AbstractSet [ str ] :
result : OrderedSet [ str ] = OrderedSet ( )
for i in self . link_targets :
if not isinstance ( i , StaticLibrary ) :
result . add ( i . get_subdir ( ) )
result . update ( i . get_link_dep_subdirs ( ) )
return result
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return self . environment . get_libdir ( ) , ' {libdir} '
def get_custom_install_dir ( self ) - > T . List [ T . Union [ str , Literal [ False ] ] ] :
return self . install_dir
def get_custom_install_mode ( self ) - > T . Optional [ ' FileMode ' ] :
return self . install_mode
def process_kwargs ( self , kwargs ) :
self . process_kwargs_base ( kwargs )
self . copy_kwargs ( kwargs )
kwargs . get ( ' modules ' , [ ] )
self . need_install = kwargs . get ( ' install ' , self . need_install )
llist = extract_as_list ( kwargs , ' link_with ' )
for linktarget in llist :
if isinstance ( linktarget , dependencies . ExternalLibrary ) :
raise MesonException ( textwrap . dedent ( ''' \
An external library was used in link_with keyword argument , which
is reserved for libraries built as part of this project . External
libraries must be passed using the dependencies keyword argument
instead , because they are conceptually " external dependencies " ,
just like those detected with the dependency ( ) function .
''' ))
self . link ( linktarget )
lwhole = extract_as_list ( kwargs , ' link_whole ' )
for linktarget in lwhole :
self . link_whole ( linktarget )
for lang in all_languages :
lang_args = extract_as_list ( kwargs , f ' { lang } _args ' )
self . add_compiler_args ( lang , lang_args )
self . add_pch ( ' c ' , extract_as_list ( kwargs , ' c_pch ' ) )
self . add_pch ( ' cpp ' , extract_as_list ( kwargs , ' cpp_pch ' ) )
if not isinstance ( self , Executable ) or kwargs . get ( ' export_dynamic ' , False ) :
self . vala_header = kwargs . get ( ' vala_header ' , self . name + ' .h ' )
self . vala_vapi = kwargs . get ( ' vala_vapi ' , self . name + ' .vapi ' )
self . vala_gir = kwargs . get ( ' vala_gir ' , None )
dfeatures = defaultdict ( list )
dfeature_unittest = kwargs . get ( ' d_unittest ' , False )
if dfeature_unittest :
dfeatures [ ' unittest ' ] = dfeature_unittest
dfeature_versions = kwargs . get ( ' d_module_versions ' , [ ] )
if dfeature_versions :
dfeatures [ ' versions ' ] = dfeature_versions
dfeature_debug = kwargs . get ( ' d_debug ' , [ ] )
if dfeature_debug :
dfeatures [ ' debug ' ] = dfeature_debug
if ' d_import_dirs ' in kwargs :
dfeature_import_dirs = extract_as_list ( kwargs , ' d_import_dirs ' )
for d in dfeature_import_dirs :
if not isinstance ( d , IncludeDirs ) :
raise InvalidArguments ( ' Arguments to d_import_dirs must be include_directories. ' )
dfeatures [ ' import_dirs ' ] = dfeature_import_dirs
if dfeatures :
self . d_features = dfeatures
self . link_args = extract_as_list ( kwargs , ' link_args ' )
for i in self . link_args :
if not isinstance ( i , str ) :
raise InvalidArguments ( ' Link_args arguments must be strings. ' )
for l in self . link_args :
if ' -Wl,-rpath ' in l or l . startswith ( ' -rpath ' ) :
mlog . warning ( textwrap . dedent ( ''' \
Please do not define rpath with a linker argument , use install_rpath
or build_rpath properties instead .
This will become a hard error in a future Meson release .
''' ))
self . process_link_depends ( kwargs . get ( ' link_depends ' , [ ] ) )
# Target-specific include dirs must be added BEFORE include dirs from
# internal deps (added inside self.add_deps()) to override them.
inclist = extract_as_list ( kwargs , ' include_directories ' )
self . add_include_dirs ( inclist )
# Add dependencies (which also have include_directories)
deplist = extract_as_list ( kwargs , ' dependencies ' )
self . add_deps ( deplist )
# If an item in this list is False, the output corresponding to
# the list index of that item will not be installed
self . install_dir = typeslistify ( kwargs . get ( ' install_dir ' , [ ] ) ,
( str , bool ) )
self . install_mode = kwargs . get ( ' install_mode ' , None )
self . install_tag = stringlistify ( kwargs . get ( ' install_tag ' , [ None ] ) )
main_class = kwargs . get ( ' main_class ' , ' ' )
if not isinstance ( main_class , str ) :
raise InvalidArguments ( ' Main class must be a string ' )
self . main_class = main_class
if isinstance ( self , Executable ) :
# This kwarg is deprecated. The value of "none" means that the kwarg
# was not specified and win_subsystem should be used instead.
self . gui_app = None
if ' gui_app ' in kwargs :
if ' win_subsystem ' in kwargs :
raise InvalidArguments ( ' Can specify only gui_app or win_subsystem for a target, not both. ' )
self . gui_app = kwargs [ ' gui_app ' ]
if not isinstance ( self . gui_app , bool ) :
raise InvalidArguments ( ' Argument gui_app must be boolean. ' )
self . win_subsystem = self . validate_win_subsystem ( kwargs . get ( ' win_subsystem ' , ' console ' ) )
elif ' gui_app ' in kwargs :
raise InvalidArguments ( ' Argument gui_app can only be used on executables. ' )
elif ' win_subsystem ' in kwargs :
raise InvalidArguments ( ' Argument win_subsystem can only be used on executables. ' )
extra_files = extract_as_list ( kwargs , ' extra_files ' )
for i in extra_files :
assert isinstance ( i , File )
if i in self . extra_files :
continue
trial = os . path . join ( self . environment . get_source_dir ( ) , i . subdir , i . fname )
if not os . path . isfile ( trial ) :
raise InvalidArguments ( f ' Tried to add non-existing extra file { i } . ' )
self . extra_files . append ( i )
self . install_rpath : str = kwargs . get ( ' install_rpath ' , ' ' )
if not isinstance ( self . install_rpath , str ) :
raise InvalidArguments ( ' Install_rpath is not a string. ' )
self . build_rpath = kwargs . get ( ' build_rpath ' , ' ' )
if not isinstance ( self . build_rpath , str ) :
raise InvalidArguments ( ' Build_rpath is not a string. ' )
resources = extract_as_list ( kwargs , ' resources ' )
for r in resources :
if not isinstance ( r , str ) :
raise InvalidArguments ( ' Resource argument is not a string. ' )
trial = os . path . join ( self . environment . get_source_dir ( ) , self . subdir , r )
if not os . path . isfile ( trial ) :
raise InvalidArguments ( f ' Tried to add non-existing resource { r } . ' )
self . resources = resources
if ' name_prefix ' in kwargs :
name_prefix = kwargs [ ' name_prefix ' ]
if isinstance ( name_prefix , list ) :
if name_prefix :
raise InvalidArguments ( ' name_prefix array must be empty to signify default. ' )
else :
if not isinstance ( name_prefix , str ) :
raise InvalidArguments ( ' name_prefix must be a string. ' )
self . prefix = name_prefix
self . name_prefix_set = True
if ' name_suffix ' in kwargs :
name_suffix = kwargs [ ' name_suffix ' ]
if isinstance ( name_suffix , list ) :
if name_suffix :
raise InvalidArguments ( ' name_suffix array must be empty to signify default. ' )
else :
if not isinstance ( name_suffix , str ) :
raise InvalidArguments ( ' name_suffix must be a string. ' )
if name_suffix == ' ' :
raise InvalidArguments ( ' name_suffix should not be an empty string. '
' If you want meson to use the default behaviour '
' for each platform pass `[]` (empty array) ' )
self . suffix = name_suffix
self . name_suffix_set = True
if isinstance ( self , StaticLibrary ) :
# You can't disable PIC on OS X. The compiler ignores -fno-PIC.
# PIC is always on for Windows (all code is position-independent
# since library loading is done differently)
m = self . environment . machines [ self . for_machine ]
if m . is_darwin ( ) or m . is_windows ( ) :
self . pic = True
else :
self . pic = self . _extract_pic_pie ( kwargs , ' pic ' , ' b_staticpic ' )
if isinstance ( self , Executable ) or ( isinstance ( self , StaticLibrary ) and not self . pic ) :
# Executables must be PIE on Android
if self . environment . machines [ self . for_machine ] . is_android ( ) :
self . pie = True
else :
self . pie = self . _extract_pic_pie ( kwargs , ' pie ' , ' b_pie ' )
self . implicit_include_directories = kwargs . get ( ' implicit_include_directories ' , True )
if not isinstance ( self . implicit_include_directories , bool ) :
raise InvalidArguments ( ' Implicit_include_directories must be a boolean. ' )
self . gnu_symbol_visibility = kwargs . get ( ' gnu_symbol_visibility ' , ' ' )
if not isinstance ( self . gnu_symbol_visibility , str ) :
raise InvalidArguments ( ' GNU symbol visibility must be a string. ' )
if self . gnu_symbol_visibility != ' ' :
permitted = [ ' default ' , ' internal ' , ' hidden ' , ' protected ' , ' inlineshidden ' ]
if self . gnu_symbol_visibility not in permitted :
raise InvalidArguments ( ' GNU symbol visibility arg {} not one of: {} ' . format ( self . gnu_symbol_visibility , ' , ' . join ( permitted ) ) )
rust_dependency_map = kwargs . get ( ' rust_dependency_map ' , { } )
if not isinstance ( rust_dependency_map , dict ) :
raise InvalidArguments ( f ' Invalid rust_dependency_map " { rust_dependency_map } " : must be a dictionary. ' )
if any ( not isinstance ( v , str ) for v in rust_dependency_map . values ( ) ) :
raise InvalidArguments ( f ' Invalid rust_dependency_map " { rust_dependency_map } " : must be a dictionary with string values. ' )
self . rust_dependency_map = rust_dependency_map
def validate_win_subsystem ( self , value : str ) - > str :
value = value . lower ( )
if re . fullmatch ( r ' (boot_application|console|efi_application|efi_boot_service_driver|efi_rom|efi_runtime_driver|native|posix|windows)(, \ d+( \ . \ d+)?)? ' , value ) is None :
raise InvalidArguments ( f ' Invalid value for win_subsystem: { value } . ' )
return value
def _extract_pic_pie ( self , kwargs , arg : str , option : str ) :
# Check if we have -fPIC, -fpic, -fPIE, or -fpie in cflags
all_flags = self . extra_args [ ' c ' ] + self . extra_args [ ' cpp ' ]
if ' -f ' + arg . lower ( ) in all_flags or ' -f ' + arg . upper ( ) in all_flags :
mlog . warning ( f " Use the ' { arg } ' kwarg instead of passing ' -f { arg } ' manually to { self . name !r} " )
return True
k = OptionKey ( option )
if arg in kwargs :
val = kwargs [ arg ]
elif k in self . environment . coredata . options :
val = self . environment . coredata . options [ k ] . value
else :
val = False
if not isinstance ( val , bool ) :
raise InvalidArguments ( f ' Argument { arg } to { self . name !r} must be boolean ' )
return val
def get_filename ( self ) - > str :
return self . filename
def get_outputs ( self ) - > T . List [ str ] :
return self . outputs
def get_extra_args ( self , language ) :
return self . extra_args . get ( language , [ ] )
def get_dependencies ( self , exclude = None ) :
transitive_deps = [ ]
if exclude is None :
exclude = [ ]
for t in itertools . chain ( self . link_targets , self . link_whole_targets ) :
if t in transitive_deps or t in exclude :
continue
transitive_deps . append ( t )
if isinstance ( t , StaticLibrary ) :
transitive_deps + = t . get_dependencies ( transitive_deps + exclude )
return transitive_deps
def get_source_subdir ( self ) :
return self . subdir
def get_sources ( self ) :
return self . sources
def get_objects ( self ) - > T . List [ T . Union [ str , ' File ' , ' ExtractedObjects ' ] ] :
return self . objects
def get_generated_sources ( self ) - > T . List [ ' GeneratedTypes ' ] :
return self . generated
def should_install ( self ) - > bool :
return self . need_install
def has_pch ( self ) - > bool :
return bool ( self . pch )
def get_pch ( self , language : str ) - > T . List [ str ] :
return self . pch . get ( language , [ ] )
def get_include_dirs ( self ) - > T . List [ ' IncludeDirs ' ] :
return self . include_dirs
def add_deps ( self , deps ) :
deps = listify ( deps )
for dep in deps :
if dep in self . added_deps :
continue
if isinstance ( dep , dependencies . InternalDependency ) :
# Those parts that are internal.
self . process_sourcelist ( dep . sources )
self . extra_files . extend ( f for f in dep . extra_files if f not in self . extra_files )
self . add_include_dirs ( dep . include_directories , dep . get_include_type ( ) )
self . objects . extend ( dep . objects )
for l in dep . libraries :
self . link ( l )
for l in dep . whole_libraries :
self . link_whole ( l )
if dep . get_compile_args ( ) or dep . get_link_args ( ) :
# Those parts that are external.
extpart = dependencies . InternalDependency ( ' undefined ' ,
[ ] ,
dep . get_compile_args ( ) ,
dep . get_link_args ( ) ,
[ ] , [ ] , [ ] , [ ] , [ ] , { } , [ ] , [ ] , [ ] )
self . external_deps . append ( extpart )
# Deps of deps.
self . add_deps ( dep . ext_deps )
elif isinstance ( dep , dependencies . Dependency ) :
if dep not in self . external_deps :
self . external_deps . append ( dep )
self . process_sourcelist ( dep . get_sources ( ) )
self . add_deps ( dep . ext_deps )
elif isinstance ( dep , BuildTarget ) :
raise InvalidArguments ( ''' Tried to use a build target as a dependency.
You probably should put it in link_with instead . ''' )
else :
# This is a bit of a hack. We do not want Build to know anything
# about the interpreter so we can't import it and use isinstance.
# This should be reliable enough.
if hasattr ( dep , ' held_object ' ) :
# FIXME: subproject is not a real ObjectHolder so we have to do this by hand
dep = dep . held_object
if hasattr ( dep , ' project_args_frozen ' ) or hasattr ( dep , ' global_args_frozen ' ) :
raise InvalidArguments ( ' Tried to use subproject object as a dependency. \n '
' You probably wanted to use a dependency declared in it instead. \n '
' Access it by calling get_variable() on the subproject object. ' )
raise InvalidArguments ( f ' Argument is of an unacceptable type { type ( dep ) . __name__ !r} . \n Must be '
' either an external dependency (returned by find_library() or '
' dependency()) or an internal dependency (returned by '
' declare_dependency()). ' )
dep_d_features = dep . d_features
for feature in ( ' versions ' , ' import_dirs ' ) :
if feature in dep_d_features :
self . d_features [ feature ] . extend ( dep_d_features [ feature ] )
self . added_deps . add ( dep )
def get_external_deps ( self ) - > T . List [ dependencies . Dependency ] :
return self . external_deps
def is_internal ( self ) - > bool :
return False
def link ( self , target ) :
for t in listify ( target ) :
if isinstance ( self , StaticLibrary ) and self . need_install :
if isinstance ( t , ( CustomTarget , CustomTargetIndex ) ) :
if not t . should_install ( ) :
mlog . warning ( f ' Try to link an installed static library target { self . name } with a '
' custom target that is not installed, this might cause problems '
' when you try to use this static library ' )
elif t . is_internal ( ) and not t . uses_rust ( ) :
# When we're a static library and we link_with to an
# internal/convenience library, promote to link_whole.
#
# There are cases we cannot do this, however. In Rust, for
# example, this can't be done with Rust ABI libraries, though
# it could be done with C ABI libraries, though there are
# several meson issues that need to be fixed:
# https://github.com/mesonbuild/meson/issues/10722
# https://github.com/mesonbuild/meson/issues/10723
# https://github.com/mesonbuild/meson/issues/10724
return self . link_whole ( t )
if not isinstance ( t , ( Target , CustomTargetIndex ) ) :
raise InvalidArguments ( f ' { t !r} is not a target. ' )
if not t . is_linkable_target ( ) :
raise InvalidArguments ( f " Link target ' { t !s} ' is not linkable. " )
if isinstance ( self , SharedLibrary ) and isinstance ( t , StaticLibrary ) and not t . pic :
msg = f " Can ' t link non-PIC static library { t . name !r} into shared library { self . name !r} . "
msg + = " Use the ' pic ' option to static_library to build with PIC. "
raise InvalidArguments ( msg )
if self . for_machine is not t . for_machine :
msg = f ' Tried to mix libraries for machines { self . for_machine } and { t . for_machine } in target { self . name !r} '
if self . environment . is_cross_build ( ) :
raise InvalidArguments ( msg + ' This is not possible in a cross build. ' )
else :
mlog . warning ( msg + ' This will fail in cross build. ' )
self . link_targets . append ( t )
def link_whole ( self , target ) :
for t in listify ( target ) :
if isinstance ( t , ( CustomTarget , CustomTargetIndex ) ) :
if not t . is_linkable_target ( ) :
raise InvalidArguments ( f ' Custom target { t !r} is not linkable. ' )
if t . links_dynamically ( ) :
raise InvalidArguments ( ' Can only link_whole custom targets that are static archives. ' )
if isinstance ( self , StaticLibrary ) :
# FIXME: We could extract the .a archive to get object files
raise InvalidArguments ( ' Cannot link_whole a custom target into a static library ' )
elif not isinstance ( t , StaticLibrary ) :
raise InvalidArguments ( f ' { t !r} is not a static library. ' )
elif isinstance ( self , SharedLibrary ) and not t . pic :
msg = f " Can ' t link non-PIC static library { t . name !r} into shared library { self . name !r} . "
msg + = " Use the ' pic ' option to static_library to build with PIC. "
raise InvalidArguments ( msg )
if self . for_machine is not t . for_machine :
msg = f ' Tried to mix libraries for machines { self . for_machine } and { t . for_machine } in target { self . name !r} '
if self . environment . is_cross_build ( ) :
raise InvalidArguments ( msg + ' This is not possible in a cross build. ' )
else :
mlog . warning ( msg + ' This will fail in cross build. ' )
if isinstance ( self , StaticLibrary ) :
# When we're a static library and we link_whole: to another static
# library, we need to add that target's objects to ourselves.
self . objects + = t . extract_all_objects_recurse ( )
self . link_whole_targets . append ( t )
def extract_all_objects_recurse ( self ) - > T . List [ T . Union [ str , ' ExtractedObjects ' ] ] :
objs = [ self . extract_all_objects ( ) ]
for t in self . link_targets :
if t . is_internal ( ) :
objs + = t . extract_all_objects_recurse ( )
return objs
def add_pch ( self , language : str , pchlist : T . List [ str ] ) - > None :
if not pchlist :
return
elif len ( pchlist ) == 1 :
if not environment . is_header ( pchlist [ 0 ] ) :
raise InvalidArguments ( f ' PCH argument { pchlist [ 0 ] } is not a header. ' )
elif len ( pchlist ) == 2 :
if environment . is_header ( pchlist [ 0 ] ) :
if not environment . is_source ( pchlist [ 1 ] ) :
raise InvalidArguments ( ' PCH definition must contain one header and at most one source. ' )
elif environment . is_source ( pchlist [ 0 ] ) :
if not environment . is_header ( pchlist [ 1 ] ) :
raise InvalidArguments ( ' PCH definition must contain one header and at most one source. ' )
pchlist = [ pchlist [ 1 ] , pchlist [ 0 ] ]
else :
raise InvalidArguments ( f ' PCH argument { pchlist [ 0 ] } is of unknown type. ' )
if os . path . dirname ( pchlist [ 0 ] ) != os . path . dirname ( pchlist [ 1 ] ) :
raise InvalidArguments ( ' PCH files must be stored in the same folder. ' )
FeatureDeprecated . single_use ( ' PCH source files ' , ' 0.50.0 ' , self . subproject ,
' Only a single header file should be used. ' )
elif len ( pchlist ) > 2 :
raise InvalidArguments ( ' PCH definition may have a maximum of 2 files. ' )
for f in pchlist :
if not isinstance ( f , str ) :
raise MesonException ( ' PCH arguments must be strings. ' )
if not os . path . isfile ( os . path . join ( self . environment . source_dir , self . subdir , f ) ) :
raise MesonException ( f ' File { f } does not exist. ' )
self . pch [ language ] = pchlist
def add_include_dirs ( self , args : T . Sequence [ ' IncludeDirs ' ] , set_is_system : T . Optional [ str ] = None ) - > None :
ids : T . List [ ' IncludeDirs ' ] = [ ]
for a in args :
if not isinstance ( a , IncludeDirs ) :
raise InvalidArguments ( ' Include directory to be added is not an include directory object. ' )
ids . append ( a )
if set_is_system is None :
set_is_system = ' preserve '
if set_is_system != ' preserve ' :
is_system = set_is_system == ' system '
ids = [ IncludeDirs ( x . get_curdir ( ) , x . get_incdirs ( ) , is_system , x . get_extra_build_dirs ( ) ) for x in ids ]
self . include_dirs + = ids
def add_compiler_args ( self , language : str , args : T . List [ ' FileOrString ' ] ) - > None :
args = listify ( args )
for a in args :
if not isinstance ( a , ( str , File ) ) :
raise InvalidArguments ( ' A non-string passed to compiler args. ' )
if language in self . extra_args :
self . extra_args [ language ] + = args
else :
self . extra_args [ language ] = args
def get_aliases ( self ) - > T . List [ T . Tuple [ str , str , str ] ] :
return [ ]
def get_langs_used_by_deps ( self ) - > T . List [ str ] :
'''
Sometimes you want to link to a C + + library that exports C API , which
means the linker must link in the C + + stdlib , and we must use a C + +
compiler for linking . The same is also applicable for objc / objc + + , etc ,
so we can keep using clink_langs for the priority order .
See : https : / / github . com / mesonbuild / meson / issues / 1653
'''
langs = [ ] # type: T.List[str]
# Check if any of the external libraries were written in this language
for dep in self . external_deps :
if dep . language is None :
continue
if dep . language not in langs :
langs . append ( dep . language )
# Check if any of the internal libraries this target links to were
# written in this language
for link_target in itertools . chain ( self . link_targets , self . link_whole_targets ) :
if isinstance ( link_target , ( CustomTarget , CustomTargetIndex ) ) :
continue
for language in link_target . compilers :
if language not in langs :
langs . append ( language )
return langs
def get_prelinker ( self ) :
if self . link_language :
comp = self . all_compilers [ self . link_language ]
return comp
for l in clink_langs :
if l in self . compilers :
try :
prelinker = self . all_compilers [ l ]
except KeyError :
raise MesonException (
f ' Could not get a prelinker linker for build target { self . name !r} . '
f ' Requires a compiler for language " { l } " , but that is not '
' a project language. ' )
return prelinker
raise MesonException ( f ' Could not determine prelinker for { self . name !r} . ' )
def get_clink_dynamic_linker_and_stdlibs ( self ) - > T . Tuple [ ' Compiler ' , T . List [ str ] ] :
'''
We use the order of languages in ` clink_langs ` to determine which
linker to use in case the target has sources compiled with multiple
compilers . All languages other than those in this list have their own
linker .
Note that Vala outputs C code , so Vala sources can use any linker
that can link compiled C . We don ' t actually need to add an exception
for Vala here because of that .
'''
# If the user set the link_language, just return that.
if self . link_language :
comp = self . all_compilers [ self . link_language ]
return comp , comp . language_stdlib_only_link_flags ( self . environment )
# Since dependencies could come from subprojects, they could have
# languages we don't have in self.all_compilers. Use the global list of
# all compilers here.
all_compilers = self . environment . coredata . compilers [ self . for_machine ]
# Languages used by dependencies
dep_langs = self . get_langs_used_by_deps ( )
# This set contains all the languages a linker can link natively
# without extra flags. For instance, nvcc (cuda) can link C++
# without injecting -lc++/-lstdc++, see
# https://github.com/mesonbuild/meson/issues/10570
MASK_LANGS = frozenset ( [
# (language, linker)
( ' cpp ' , ' cuda ' ) ,
] )
# Pick a compiler based on the language priority-order
for l in clink_langs :
if l in self . compilers or l in dep_langs :
try :
linker = all_compilers [ l ]
except KeyError :
raise MesonException (
f ' Could not get a dynamic linker for build target { self . name !r} . '
f ' Requires a linker for language " { l } " , but that is not '
' a project language. ' )
stdlib_args : T . List [ str ] = [ ]
for dl in itertools . chain ( self . compilers , dep_langs ) :
if dl != linker . language and ( dl , linker . language ) not in MASK_LANGS :
stdlib_args + = all_compilers [ dl ] . language_stdlib_only_link_flags ( self . environment )
# Type of var 'linker' is Compiler.
# Pretty hard to fix because the return value is passed everywhere
return linker , stdlib_args
# None of our compilers can do clink, this happens for example if the
# target only has ASM sources. Pick the first capable compiler.
for l in clink_langs :
try :
comp = self . all_compilers [ l ]
return comp , comp . language_stdlib_only_link_flags ( self . environment )
except KeyError :
pass
raise AssertionError ( f ' Could not get a dynamic linker for build target { self . name !r} ' )
def uses_rust ( self ) - > bool :
return ' rust ' in self . compilers
def uses_fortran ( self ) - > bool :
return ' fortran ' in self . compilers
def get_using_msvc ( self ) - > bool :
'''
Check if the dynamic linker is MSVC . Used by Executable , StaticLibrary ,
and SharedLibrary for deciding when to use MSVC - specific file naming
and debug filenames .
If at least some code is built with MSVC and the final library is
linked with MSVC , we can be sure that some debug info will be
generated . We only check the dynamic linker here because the static
linker is guaranteed to be of the same type .
Interesting cases :
1. The Vala compiler outputs C code to be compiled by whatever
C compiler we ' re using, so all objects will still be created by the
MSVC compiler .
2. If the target contains only objects , process_compilers guesses and
picks the first compiler that smells right .
'''
# Rustc can use msvc style linkers
if self . uses_rust ( ) :
compiler = self . all_compilers [ ' rust ' ]
else :
compiler , _ = self . get_clink_dynamic_linker_and_stdlibs ( )
# Mixing many languages with MSVC is not supported yet so ignore stdlibs.
return compiler and compiler . get_linker_id ( ) in { ' link ' , ' lld-link ' , ' xilink ' , ' optlink ' }
def check_module_linking ( self ) :
'''
Warn if shared modules are linked with target : ( link_with ) #2865
'''
for link_target in self . link_targets :
if isinstance ( link_target , SharedModule ) and not link_target . force_soname :
if self . environment . machines [ self . for_machine ] . is_darwin ( ) :
raise MesonException (
f ' target { self . name } links against shared module { link_target . name } . This is not permitted on OSX ' )
elif self . environment . machines [ self . for_machine ] . is_android ( ) and isinstance ( self , SharedModule ) :
# Android requires shared modules that use symbols from other shared modules to
# be linked before they can be dlopen()ed in the correct order. Not doing so
# leads to a missing symbol error: https://github.com/android/ndk/issues/201
link_target . force_soname = True
else :
mlog . deprecation ( f ' target { self . name } links against shared module { link_target . name } , which is incorrect. '
' \n '
f ' This will be an error in the future, so please use shared_library() for { link_target . name } instead. '
' \n '
f ' If shared_module() was used for { link_target . name } because it has references to undefined symbols, '
' \n '
' use shared_library() with `override_options: [ \' b_lundef=false \' ]` instead. ' )
link_target . force_soname = True
class FileInTargetPrivateDir :
""" Represents a file with the path ' /path/to/build/target_private_dir/fname ' .
target_private_dir is the return value of get_target_private_dir which is e . g . ' subdir/target.p ' .
"""
def __init__ ( self , fname : str ) :
self . fname = fname
class FileMaybeInTargetPrivateDir :
""" Union between ' File ' and ' FileInTargetPrivateDir ' """
def __init__ ( self , inner : T . Union [ File , FileInTargetPrivateDir ] ) :
self . inner = inner
@property
def fname ( self ) - > str :
return self . inner . fname
def rel_to_builddir ( self , build_to_src : str , target_private_dir : str ) - > str :
if isinstance ( self . inner , FileInTargetPrivateDir ) :
return os . path . join ( target_private_dir , self . inner . fname )
return self . inner . rel_to_builddir ( build_to_src )
def absolute_path ( self , srcdir : str , builddir : str ) - > str :
if isinstance ( self . inner , FileInTargetPrivateDir ) :
raise RuntimeError ( ' Unreachable code ' )
return self . inner . absolute_path ( srcdir , builddir )
class Generator ( HoldableObject ) :
def __init__ ( self , exe : T . Union [ ' Executable ' , programs . ExternalProgram ] ,
arguments : T . List [ str ] ,
output : T . List [ str ] ,
# how2dataclass
* ,
depfile : T . Optional [ str ] = None ,
capture : bool = False ,
depends : T . Optional [ T . List [ T . Union [ BuildTarget , ' CustomTarget ' ] ] ] = None ,
name : str = ' Generator ' ) :
self . exe = exe
self . depfile = depfile
self . capture = capture
self . depends : T . List [ T . Union [ BuildTarget , ' CustomTarget ' ] ] = depends or [ ]
self . arglist = arguments
self . outputs = output
self . name = name
def __repr__ ( self ) - > str :
repr_str = " < {0} : {1} > "
return repr_str . format ( self . __class__ . __name__ , self . exe )
def get_exe ( self ) - > T . Union [ ' Executable ' , programs . ExternalProgram ] :
return self . exe
def get_base_outnames ( self , inname : str ) - > T . List [ str ] :
plainname = os . path . basename ( inname )
basename = os . path . splitext ( plainname ) [ 0 ]
bases = [ x . replace ( ' @BASENAME@ ' , basename ) . replace ( ' @PLAINNAME@ ' , plainname ) for x in self . outputs ]
return bases
def get_dep_outname ( self , inname : str ) - > T . List [ str ] :
if self . depfile is None :
raise InvalidArguments ( ' Tried to get dep name for rule that does not have dependency file defined. ' )
plainname = os . path . basename ( inname )
basename = os . path . splitext ( plainname ) [ 0 ]
return self . depfile . replace ( ' @BASENAME@ ' , basename ) . replace ( ' @PLAINNAME@ ' , plainname )
def get_arglist ( self , inname : str ) - > T . List [ str ] :
plainname = os . path . basename ( inname )
basename = os . path . splitext ( plainname ) [ 0 ]
return [ x . replace ( ' @BASENAME@ ' , basename ) . replace ( ' @PLAINNAME@ ' , plainname ) for x in self . arglist ]
@staticmethod
def is_parent_path ( parent : str , trial : str ) - > bool :
relpath = pathlib . PurePath ( trial ) . relative_to ( parent )
return relpath . parts [ 0 ] != ' .. ' # For subdirs we can only go "down".
def process_files ( self , files : T . Iterable [ T . Union [ str , File , ' CustomTarget ' , ' CustomTargetIndex ' , ' GeneratedList ' ] ] ,
state : T . Union [ ' Interpreter ' , ' ModuleState ' ] ,
preserve_path_from : T . Optional [ str ] = None ,
extra_args : T . Optional [ T . List [ str ] ] = None ) - > ' GeneratedList ' :
output = GeneratedList ( self , state . subdir , preserve_path_from , extra_args = extra_args if extra_args is not None else [ ] )
for e in files :
if isinstance ( e , CustomTarget ) :
output . depends . add ( e )
if isinstance ( e , CustomTargetIndex ) :
output . depends . add ( e . target )
if isinstance ( e , ( CustomTarget , CustomTargetIndex ) ) :
output . depends . add ( e )
fs = [ File . from_built_file ( state . subdir , f ) for f in e . get_outputs ( ) ]
elif isinstance ( e , GeneratedList ) :
if preserve_path_from :
raise InvalidArguments ( " generator.process: ' preserve_path_from ' is not allowed if one input is a ' generated_list ' . " )
output . depends . add ( e )
fs = [ FileInTargetPrivateDir ( f ) for f in e . get_outputs ( ) ]
elif isinstance ( e , str ) :
fs = [ File . from_source_file ( state . environment . source_dir , state . subdir , e ) ]
else :
fs = [ e ]
for f in fs :
if preserve_path_from :
abs_f = f . absolute_path ( state . environment . source_dir , state . environment . build_dir )
if not self . is_parent_path ( preserve_path_from , abs_f ) :
raise InvalidArguments ( ' generator.process: When using preserve_path_from, all input files must be in a subdirectory of the given dir. ' )
f = FileMaybeInTargetPrivateDir ( f )
output . add_file ( f , state )
return output
@dataclass ( eq = False )
class GeneratedList ( HoldableObject ) :
""" The output of generator.process. """
generator : Generator
subdir : str
preserve_path_from : T . Optional [ str ]
extra_args : T . List [ str ]
def __post_init__ ( self ) - > None :
self . name = self . generator . exe
self . depends : T . Set [ GeneratedTypes ] = set ( )
self . infilelist : T . List [ FileMaybeInTargetPrivateDir ] = [ ]
self . outfilelist : T . List [ str ] = [ ]
self . outmap : T . Dict [ FileMaybeInTargetPrivateDir , T . List [ str ] ] = { }
self . extra_depends = [ ] # XXX: Doesn't seem to be used?
self . depend_files : T . List [ File ] = [ ]
if self . extra_args is None :
self . extra_args : T . List [ str ] = [ ]
if isinstance ( self . generator . exe , programs . ExternalProgram ) :
if not self . generator . exe . found ( ) :
raise InvalidArguments ( ' Tried to use not-found external program as generator ' )
path = self . generator . exe . get_path ( )
if os . path . isabs ( path ) :
# Can only add a dependency on an external program which we
# know the absolute path of
self . depend_files . append ( File . from_absolute_file ( path ) )
def add_preserved_path_segment ( self , infile : FileMaybeInTargetPrivateDir , outfiles : T . List [ str ] , state : T . Union [ ' Interpreter ' , ' ModuleState ' ] ) - > T . List [ str ] :
result : T . List [ str ] = [ ]
in_abs = infile . absolute_path ( state . environment . source_dir , state . environment . build_dir )
assert os . path . isabs ( self . preserve_path_from )
rel = os . path . relpath ( in_abs , self . preserve_path_from )
path_segment = os . path . dirname ( rel )
for of in outfiles :
result . append ( os . path . join ( path_segment , of ) )
return result
def add_file ( self , newfile : FileMaybeInTargetPrivateDir , state : T . Union [ ' Interpreter ' , ' ModuleState ' ] ) - > None :
self . infilelist . append ( newfile )
outfiles = self . generator . get_base_outnames ( newfile . fname )
if self . preserve_path_from :
outfiles = self . add_preserved_path_segment ( newfile , outfiles , state )
self . outfilelist + = outfiles
self . outmap [ newfile ] = outfiles
def get_inputs ( self ) - > T . List [ FileMaybeInTargetPrivateDir ] :
return self . infilelist
def get_outputs ( self ) - > T . List [ str ] :
return self . outfilelist
def get_outputs_for ( self , filename : FileMaybeInTargetPrivateDir ) - > T . List [ str ] :
return self . outmap [ filename ]
def get_generator ( self ) - > ' Generator ' :
return self . generator
def get_extra_args ( self ) - > T . List [ str ] :
return self . extra_args
def get_subdir ( self ) - > str :
return self . subdir
class Executable ( BuildTarget ) :
known_kwargs = known_exe_kwargs
typename = ' executable '
def __init__ (
self ,
name : str ,
subdir : str ,
subproject : SubProject ,
for_machine : MachineChoice ,
sources : T . List [ ' SourceOutputs ' ] ,
structured_sources : T . Optional [ StructuredSources ] ,
objects : T . List [ ObjectTypes ] ,
environment : environment . Environment ,
compilers : T . Dict [ str , ' Compiler ' ] ,
kwargs ) :
key = OptionKey ( ' b_pie ' )
if ' pie ' not in kwargs and key in environment . coredata . options :
kwargs [ ' pie ' ] = environment . coredata . options [ key ] . value
super ( ) . __init__ ( name , subdir , subproject , for_machine , sources , structured_sources , objects ,
environment , compilers , kwargs )
# Check for export_dynamic
self . export_dynamic = kwargs . get ( ' export_dynamic ' , False )
if not isinstance ( self . export_dynamic , bool ) :
raise InvalidArguments ( ' " export_dynamic " keyword argument must be a boolean ' )
self . implib = kwargs . get ( ' implib ' )
if not isinstance ( self . implib , ( bool , str , type ( None ) ) ) :
raise InvalidArguments ( ' " export_dynamic " keyword argument must be a boolean or string ' )
if self . implib :
self . export_dynamic = True
if self . export_dynamic and self . implib is False :
raise InvalidArguments ( ' " implib " keyword argument must not be false for if " export_dynamic " is true ' )
# Only linkwithable if using export_dynamic
self . is_linkwithable = self . export_dynamic
# Remember that this exe was returned by `find_program()` through an override
self . was_returned_by_find_program = False
def post_init ( self ) - > None :
super ( ) . post_init ( )
machine = self . environment . machines [ self . for_machine ]
# Unless overridden, executables have no suffix or prefix. Except on
# Windows and with C#/Mono executables where the suffix is 'exe'
if not hasattr ( self , ' prefix ' ) :
self . prefix = ' '
if not hasattr ( self , ' suffix ' ) :
# Executable for Windows or C#/Mono
if machine . is_windows ( ) or machine . is_cygwin ( ) or ' cs ' in self . compilers :
self . suffix = ' exe '
elif machine . system . startswith ( ' wasm ' ) or machine . system == ' emscripten ' :
self . suffix = ' js '
elif ( ' c ' in self . compilers and self . compilers [ ' c ' ] . get_id ( ) . startswith ( ' armclang ' ) or
' cpp ' in self . compilers and self . compilers [ ' cpp ' ] . get_id ( ) . startswith ( ' armclang ' ) ) :
self . suffix = ' axf '
elif ( ' c ' in self . compilers and self . compilers [ ' c ' ] . get_id ( ) . startswith ( ' ccrx ' ) or
' cpp ' in self . compilers and self . compilers [ ' cpp ' ] . get_id ( ) . startswith ( ' ccrx ' ) ) :
self . suffix = ' abs '
elif ( ' c ' in self . compilers and self . compilers [ ' c ' ] . get_id ( ) . startswith ( ' xc16 ' ) ) :
self . suffix = ' elf '
elif ( ' c ' in self . compilers and self . compilers [ ' c ' ] . get_id ( ) in { ' ti ' , ' c2000 ' } or
' cpp ' in self . compilers and self . compilers [ ' cpp ' ] . get_id ( ) in { ' ti ' , ' c2000 ' } ) :
self . suffix = ' out '
elif ( ' c ' in self . compilers and self . compilers [ ' c ' ] . get_id ( ) in { ' mwccarm ' , ' mwcceppc ' } or
' cpp ' in self . compilers and self . compilers [ ' cpp ' ] . get_id ( ) in { ' mwccarm ' , ' mwcceppc ' } ) :
self . suffix = ' nef '
else :
self . suffix = machine . get_exe_suffix ( )
self . filename = self . name
if self . suffix :
self . filename + = ' . ' + self . suffix
self . outputs = [ self . filename ]
# The import library this target will generate
self . import_filename = None
# The import library that Visual Studio would generate (and accept)
self . vs_import_filename = None
# The import library that GCC would generate (and prefer)
self . gcc_import_filename = None
# The debugging information file this target will generate
self . debug_filename = None
# If using export_dynamic, set the import library name
if self . export_dynamic :
implib_basename = self . name + ' .exe '
if isinstance ( self . implib , str ) :
implib_basename = self . implib
if machine . is_windows ( ) or machine . is_cygwin ( ) :
self . vs_import_filename = f ' { implib_basename } .lib '
self . gcc_import_filename = f ' lib { implib_basename } .a '
if self . get_using_msvc ( ) :
self . import_filename = self . vs_import_filename
else :
self . import_filename = self . gcc_import_filename
create_debug_file = (
machine . is_windows ( )
and ( ' cs ' in self . compilers or self . uses_rust ( ) or self . get_using_msvc ( ) )
# .pdb file is created only when debug symbols are enabled
and self . environment . coredata . get_option ( OptionKey ( " debug " ) )
)
if create_debug_file :
self . debug_filename = self . name + ' .pdb '
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return self . environment . get_bindir ( ) , ' {bindir} '
def description ( self ) :
''' Human friendly description of the executable '''
return self . name
def type_suffix ( self ) :
return " @exe "
def get_import_filename ( self ) - > T . Optional [ str ] :
"""
The name of the import library that will be outputted by the compiler
Returns None if there is no import library required for this platform
"""
return self . import_filename
def get_import_filenameslist ( self ) :
if self . import_filename :
return [ self . vs_import_filename , self . gcc_import_filename ]
return [ ]
def get_debug_filename ( self ) - > T . Optional [ str ] :
"""
The name of debuginfo file that will be created by the compiler
Returns None if the build won ' t create any debuginfo file
"""
return self . debug_filename
def is_linkable_target ( self ) :
return self . is_linkwithable
def get_command ( self ) - > ' ImmutableListProtocol[str] ' :
""" Provides compatibility with ExternalProgram.
Since you can override ExternalProgram instances with Executables .
"""
return self . outputs
def get_path ( self ) - > str :
""" Provides compatibility with ExternalProgram. """
return os . path . join ( self . subdir , self . filename )
def found ( self ) - > bool :
""" Provides compatibility with ExternalProgram. """
return True
class StaticLibrary ( BuildTarget ) :
known_kwargs = known_stlib_kwargs
typename = ' static library '
def __init__ (
self ,
name : str ,
subdir : str ,
subproject : SubProject ,
for_machine : MachineChoice ,
sources : T . List [ ' SourceOutputs ' ] ,
structured_sources : T . Optional [ StructuredSources ] ,
objects : T . List [ ObjectTypes ] ,
environment : environment . Environment ,
compilers : T . Dict [ str , ' Compiler ' ] ,
kwargs ) :
self . prelink = kwargs . get ( ' prelink ' , False )
if not isinstance ( self . prelink , bool ) :
raise InvalidArguments ( ' Prelink keyword argument must be a boolean. ' )
super ( ) . __init__ ( name , subdir , subproject , for_machine , sources , structured_sources , objects ,
environment , compilers , kwargs )
def post_init ( self ) - > None :
super ( ) . post_init ( )
if ' cs ' in self . compilers :
raise InvalidArguments ( ' Static libraries not supported for C#. ' )
if ' rust ' in self . compilers :
# If no crate type is specified, or it's the generic lib type, use rlib
if not hasattr ( self , ' rust_crate_type ' ) or self . rust_crate_type == ' lib ' :
mlog . debug ( ' Defaulting Rust static library target crate type to rlib ' )
self . rust_crate_type = ' rlib '
# Don't let configuration proceed with a non-static crate type
elif self . rust_crate_type not in [ ' rlib ' , ' staticlib ' ] :
raise InvalidArguments ( f ' Crate type " { self . rust_crate_type } " invalid for static libraries; must be " rlib " or " staticlib " ' )
# See https://github.com/rust-lang/rust/issues/110460
if self . rust_crate_type == ' rlib ' and any ( c in self . name for c in [ ' - ' , ' ' , ' . ' ] ) :
raise InvalidArguments ( ' Rust crate type " rlib " does not allow spaces, periods or dashes in the library name '
' due to a limitation of rustc. Replace them with underscores, for example ' )
if self . rust_crate_type == ' staticlib ' :
# FIXME: In the case of no-std we should not add those libraries,
# but we have no way to know currently.
rustc = self . compilers [ ' rust ' ]
d = dependencies . InternalDependency ( ' undefined ' , [ ] , [ ] ,
rustc . native_static_libs ,
[ ] , [ ] , [ ] , [ ] , [ ] , { } , [ ] , [ ] , [ ] )
self . external_deps . append ( d )
# By default a static library is named libfoo.a even on Windows because
# MSVC does not have a consistent convention for what static libraries
# are called. The MSVC CRT uses libfoo.lib syntax but nothing else uses
# it and GCC only looks for static libraries called foo.lib and
# libfoo.a. However, we cannot use foo.lib because that's the same as
# the import library. Using libfoo.a is ok because people using MSVC
# always pass the library filename while linking anyway.
if not hasattr ( self , ' prefix ' ) :
self . prefix = ' lib '
if not hasattr ( self , ' suffix ' ) :
if ' rust ' in self . compilers :
if not hasattr ( self , ' rust_crate_type ' ) or self . rust_crate_type == ' rlib ' :
# default Rust static library suffix
self . suffix = ' rlib '
elif self . rust_crate_type == ' staticlib ' :
self . suffix = ' a '
else :
self . suffix = ' a '
self . filename = self . prefix + self . name + ' . ' + self . suffix
self . outputs = [ self . filename ]
def get_link_deps_mapping ( self , prefix : str ) - > T . Mapping [ str , str ] :
return { }
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return self . environment . get_static_lib_dir ( ) , ' {libdir_static} '
def type_suffix ( self ) :
return " @sta "
def process_kwargs ( self , kwargs ) :
super ( ) . process_kwargs ( kwargs )
if ' rust_crate_type ' in kwargs :
rust_crate_type = kwargs [ ' rust_crate_type ' ]
if isinstance ( rust_crate_type , str ) :
self . rust_crate_type = rust_crate_type
else :
raise InvalidArguments ( f ' Invalid rust_crate_type " { rust_crate_type } " : must be a string. ' )
def is_linkable_target ( self ) :
return True
def is_internal ( self ) - > bool :
return not self . need_install
class SharedLibrary ( BuildTarget ) :
known_kwargs = known_shlib_kwargs
typename = ' shared library '
def __init__ (
self ,
name : str ,
subdir : str ,
subproject : SubProject ,
for_machine : MachineChoice ,
sources : T . List [ ' SourceOutputs ' ] ,
structured_sources : T . Optional [ StructuredSources ] ,
objects : T . List [ ObjectTypes ] ,
environment : environment . Environment ,
compilers : T . Dict [ str , ' Compiler ' ] ,
kwargs ) :
self . soversion = None
self . ltversion = None
# Max length 2, first element is compatibility_version, second is current_version
self . darwin_versions = [ ]
self . vs_module_defs = None
# The import library this target will generate
self . import_filename = None
# The import library that Visual Studio would generate (and accept)
self . vs_import_filename = None
# The import library that GCC would generate (and prefer)
self . gcc_import_filename = None
# The debugging information file this target will generate
self . debug_filename = None
# Use by the pkgconfig module
self . shared_library_only = False
super ( ) . __init__ ( name , subdir , subproject , for_machine , sources , structured_sources , objects ,
environment , compilers , kwargs )
def post_init ( self ) - > None :
super ( ) . post_init ( )
if ' rust ' in self . compilers :
# If no crate type is specified, or it's the generic lib type, use dylib
if not hasattr ( self , ' rust_crate_type ' ) or self . rust_crate_type == ' lib ' :
mlog . debug ( ' Defaulting Rust dynamic library target crate type to " dylib " ' )
self . rust_crate_type = ' dylib '
# Don't let configuration proceed with a non-dynamic crate type
elif self . rust_crate_type not in [ ' dylib ' , ' cdylib ' , ' proc-macro ' ] :
raise InvalidArguments ( f ' Crate type " { self . rust_crate_type } " invalid for dynamic libraries; must be " dylib " , " cdylib " , or " proc-macro " ' )
# See https://github.com/rust-lang/rust/issues/110460
if self . rust_crate_type != ' cdylib ' and any ( c in self . name for c in [ ' - ' , ' ' , ' . ' ] ) :
raise InvalidArguments ( ' Rust crate types " dylib " and " proc-macro " do not allow spaces, periods or dashes in the library name '
' due to a limitation of rustc. Replace them with underscores, for example ' )
if not hasattr ( self , ' prefix ' ) :
self . prefix = None
if not hasattr ( self , ' suffix ' ) :
self . suffix = None
self . basic_filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
self . determine_filenames ( )
def get_link_deps_mapping ( self , prefix : str ) - > T . Mapping [ str , str ] :
result : T . Dict [ str , str ] = { }
mappings = self . get_transitive_link_deps_mapping ( prefix )
old = get_target_macos_dylib_install_name ( self )
if old not in mappings :
fname = self . get_filename ( )
outdirs , _ , _ = self . get_install_dir ( )
new = os . path . join ( prefix , outdirs [ 0 ] , fname )
result . update ( { old : new } )
mappings . update ( result )
return mappings
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return self . environment . get_shared_lib_dir ( ) , ' {libdir_shared} '
def determine_filenames ( self ) :
"""
See https : / / github . com / mesonbuild / meson / pull / 417 for details .
First we determine the filename template ( self . filename_tpl ) , then we
set the output filename ( self . filename ) .
The template is needed while creating aliases ( self . get_aliases ) ,
which are needed while generating . so shared libraries for Linux .
Besides this , there ' s also the import library name, which is only used
on Windows since on that platform the linker uses a separate library
called the " import library " during linking instead of the shared
library ( DLL ) . The toolchain will output an import library in one of
two formats : GCC or Visual Studio .
When we ' re building with Visual Studio, the import library that will be
generated by the toolchain is self . vs_import_filename , and with
MinGW / GCC , it ' s self.gcc_import_filename. self.import_filename will
always contain the import library name this target will generate .
"""
prefix = ' '
suffix = ' '
create_debug_file = False
self . filename_tpl = self . basic_filename_tpl
# NOTE: manual prefix/suffix override is currently only tested for C/C++
# C# and Mono
if ' cs ' in self . compilers :
prefix = ' '
suffix = ' dll '
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
create_debug_file = True
# C, C++, Swift, Vala
# Only Windows uses a separate import library for linking
# For all other targets/platforms import_filename stays None
elif self . environment . machines [ self . for_machine ] . is_windows ( ) :
suffix = ' dll '
self . vs_import_filename = ' {} {} .lib ' . format ( self . prefix if self . prefix is not None else ' ' , self . name )
self . gcc_import_filename = ' {} {} .dll.a ' . format ( self . prefix if self . prefix is not None else ' lib ' , self . name )
if self . uses_rust ( ) :
# Shared library is of the form foo.dll
prefix = ' '
# Import library is called foo.dll.lib
self . import_filename = f ' { self . name } .dll.lib '
# .pdb file is only created when debug symbols are enabled
create_debug_file = self . environment . coredata . get_option ( OptionKey ( " debug " ) )
elif self . get_using_msvc ( ) :
# Shared library is of the form foo.dll
prefix = ' '
# Import library is called foo.lib
self . import_filename = self . vs_import_filename
# .pdb file is only created when debug symbols are enabled
create_debug_file = self . environment . coredata . get_option ( OptionKey ( " debug " ) )
# Assume GCC-compatible naming
else :
# Shared library is of the form libfoo.dll
prefix = ' lib '
# Import library is called libfoo.dll.a
self . import_filename = self . gcc_import_filename
# Shared library has the soversion if it is defined
if self . soversion :
self . filename_tpl = ' {0.prefix} {0.name} - {0.soversion} . {0.suffix} '
else :
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
elif self . environment . machines [ self . for_machine ] . is_cygwin ( ) :
suffix = ' dll '
self . gcc_import_filename = ' {} {} .dll.a ' . format ( self . prefix if self . prefix is not None else ' lib ' , self . name )
# Shared library is of the form cygfoo.dll
# (ld --dll-search-prefix=cyg is the default)
prefix = ' cyg '
# Import library is called libfoo.dll.a
self . import_filename = self . gcc_import_filename
if self . soversion :
self . filename_tpl = ' {0.prefix} {0.name} - {0.soversion} . {0.suffix} '
else :
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
elif self . environment . machines [ self . for_machine ] . is_darwin ( ) :
prefix = ' lib '
suffix = ' dylib '
# On macOS, the filename can only contain the major version
if self . soversion :
# libfoo.X.dylib
self . filename_tpl = ' {0.prefix} {0.name} . {0.soversion} . {0.suffix} '
else :
# libfoo.dylib
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
elif self . environment . machines [ self . for_machine ] . is_android ( ) :
prefix = ' lib '
suffix = ' so '
# Android doesn't support shared_library versioning
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
else :
prefix = ' lib '
suffix = ' so '
if self . ltversion :
# libfoo.so.X[.Y[.Z]] (.Y and .Z are optional)
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} . {0.ltversion} '
elif self . soversion :
# libfoo.so.X
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} . {0.soversion} '
else :
# No versioning, libfoo.so
self . filename_tpl = ' {0.prefix} {0.name} . {0.suffix} '
if self . prefix is None :
self . prefix = prefix
if self . suffix is None :
self . suffix = suffix
self . filename = self . filename_tpl . format ( self )
# There may have been more outputs added by the time we get here, so
# only replace the first entry
self . outputs [ 0 ] = self . filename
if create_debug_file :
self . debug_filename = os . path . splitext ( self . filename ) [ 0 ] + ' .pdb '
@staticmethod
def _validate_darwin_versions ( darwin_versions ) :
try :
if isinstance ( darwin_versions , int ) :
darwin_versions = str ( darwin_versions )
if isinstance ( darwin_versions , str ) :
darwin_versions = 2 * [ darwin_versions ]
if not isinstance ( darwin_versions , list ) :
raise InvalidArguments ( ' Shared library darwin_versions: must be a string, integer, '
f ' or a list, not { darwin_versions !r} ' )
if len ( darwin_versions ) > 2 :
raise InvalidArguments ( ' Shared library darwin_versions: list must contain 2 or fewer elements ' )
if len ( darwin_versions ) == 1 :
darwin_versions = 2 * darwin_versions
for i , v in enumerate ( darwin_versions [ : ] ) :
if isinstance ( v , int ) :
v = str ( v )
if not isinstance ( v , str ) :
raise InvalidArguments ( ' Shared library darwin_versions: list elements '
f ' must be strings or integers, not { v !r} ' )
if not re . fullmatch ( r ' [0-9]+( \ .[0-9]+) { 0,2} ' , v ) :
raise InvalidArguments ( ' Shared library darwin_versions: must be X.Y.Z where '
' X, Y, Z are numbers, and Y and Z are optional ' )
parts = v . split ( ' . ' )
if len ( parts ) in { 1 , 2 , 3 } and int ( parts [ 0 ] ) > 65535 :
raise InvalidArguments ( ' Shared library darwin_versions: must be X.Y.Z '
' where X is [0, 65535] and Y, Z are optional ' )
if len ( parts ) in { 2 , 3 } and int ( parts [ 1 ] ) > 255 :
raise InvalidArguments ( ' Shared library darwin_versions: must be X.Y.Z '
' where Y is [0, 255] and Y, Z are optional ' )
if len ( parts ) == 3 and int ( parts [ 2 ] ) > 255 :
raise InvalidArguments ( ' Shared library darwin_versions: must be X.Y.Z '
' where Z is [0, 255] and Y, Z are optional ' )
darwin_versions [ i ] = v
except ValueError :
raise InvalidArguments ( ' Shared library darwin_versions: value is invalid ' )
return darwin_versions
def process_kwargs ( self , kwargs ) :
super ( ) . process_kwargs ( kwargs )
if not self . environment . machines [ self . for_machine ] . is_android ( ) :
# Shared library version
if ' version ' in kwargs :
self . ltversion = kwargs [ ' version ' ]
if not isinstance ( self . ltversion , str ) :
raise InvalidArguments ( ' Shared library version needs to be a string, not ' + type ( self . ltversion ) . __name__ )
if not re . fullmatch ( r ' [0-9]+( \ .[0-9]+) { 0,2} ' , self . ltversion ) :
raise InvalidArguments ( f ' Invalid Shared library version " { self . ltversion } " . Must be of the form X.Y.Z where all three are numbers. Y and Z are optional. ' )
# Try to extract/deduce the soversion
if ' soversion ' in kwargs :
self . soversion = kwargs [ ' soversion ' ]
if isinstance ( self . soversion , int ) :
self . soversion = str ( self . soversion )
if not isinstance ( self . soversion , str ) :
raise InvalidArguments ( ' Shared library soversion is not a string or integer. ' )
elif self . ltversion :
# library version is defined, get the soversion from that
# We replicate what Autotools does here and take the first
# number of the version by default.
self . soversion = self . ltversion . split ( ' . ' ) [ 0 ]
# macOS, iOS and tvOS dylib compatibility_version and current_version
if ' darwin_versions ' in kwargs :
self . darwin_versions = self . _validate_darwin_versions ( kwargs [ ' darwin_versions ' ] )
elif self . soversion :
# If unspecified, pick the soversion
self . darwin_versions = 2 * [ self . soversion ]
# Visual Studio module-definitions file
if ' vs_module_defs ' in kwargs :
path = kwargs [ ' vs_module_defs ' ]
if isinstance ( path , str ) :
if os . path . isabs ( path ) :
self . vs_module_defs = File . from_absolute_file ( path )
else :
self . vs_module_defs = File . from_source_file ( self . environment . source_dir , self . subdir , path )
elif isinstance ( path , File ) :
# When passing a generated file.
self . vs_module_defs = path
elif hasattr ( path , ' get_filename ' ) :
# When passing output of a Custom Target
self . vs_module_defs = File . from_built_file ( path . subdir , path . get_filename ( ) )
else :
raise InvalidArguments (
' Shared library vs_module_defs must be either a string, '
' a file object or a Custom Target ' )
self . process_link_depends ( path )
if ' rust_crate_type ' in kwargs :
rust_crate_type = kwargs [ ' rust_crate_type ' ]
if isinstance ( rust_crate_type , str ) :
self . rust_crate_type = rust_crate_type
else :
raise InvalidArguments ( f ' Invalid rust_crate_type " { rust_crate_type } " : must be a string. ' )
if rust_crate_type == ' proc-macro ' :
FeatureNew . single_use ( ' Rust crate type " proc-macro " ' , ' 0.62.0 ' , self . subproject )
def get_import_filename ( self ) - > T . Optional [ str ] :
"""
The name of the import library that will be outputted by the compiler
Returns None if there is no import library required for this platform
"""
return self . import_filename
def get_debug_filename ( self ) - > T . Optional [ str ] :
"""
The name of debuginfo file that will be created by the compiler
Returns None if the build won ' t create any debuginfo file
"""
return self . debug_filename
def get_import_filenameslist ( self ) :
if self . import_filename :
return [ self . vs_import_filename , self . gcc_import_filename ]
return [ ]
def get_all_link_deps ( self ) :
return [ self ] + self . get_transitive_link_deps ( )
def get_aliases ( self ) - > T . List [ T . Tuple [ str , str , str ] ] :
"""
If the versioned library name is libfoo . so .0 .100 .0 , aliases are :
* libfoo . so .0 ( soversion ) - > libfoo . so .0 .100 .0
* libfoo . so ( unversioned ; for linking ) - > libfoo . so .0
Same for dylib :
* libfoo . dylib ( unversioned ; for linking ) - > libfoo .0 . dylib
"""
aliases : T . List [ T . Tuple [ str , str , str ] ] = [ ]
# Aliases are only useful with .so and .dylib libraries. Also if
# there's no self.soversion (no versioning), we don't need aliases.
if self . suffix not in ( ' so ' , ' dylib ' ) or not self . soversion :
return aliases
# With .so libraries, the minor and micro versions are also in the
# filename. If ltversion != soversion we create an soversion alias:
# libfoo.so.0 -> libfoo.so.0.100.0
# Where libfoo.so.0.100.0 is the actual library
if self . suffix == ' so ' and self . ltversion and self . ltversion != self . soversion :
alias_tpl = self . filename_tpl . replace ( ' ltversion ' , ' soversion ' )
ltversion_filename = alias_tpl . format ( self )
tag = self . install_tag [ 0 ] or ' runtime '
aliases . append ( ( ltversion_filename , self . filename , tag ) )
# libfoo.so.0/libfoo.0.dylib is the actual library
else :
ltversion_filename = self . filename
# Unversioned alias:
# libfoo.so -> libfoo.so.0
# libfoo.dylib -> libfoo.0.dylib
tag = self . install_tag [ 0 ] or ' devel '
aliases . append ( ( self . basic_filename_tpl . format ( self ) , ltversion_filename , tag ) )
return aliases
def type_suffix ( self ) :
return " @sha "
def is_linkable_target ( self ) :
return True
# A shared library that is meant to be used with dlopen rather than linking
# into something else.
class SharedModule ( SharedLibrary ) :
known_kwargs = known_shmod_kwargs
typename = ' shared module '
def __init__ (
self ,
name : str ,
subdir : str ,
subproject : SubProject ,
for_machine : MachineChoice ,
sources : T . List [ ' SourceOutputs ' ] ,
structured_sources : T . Optional [ StructuredSources ] ,
objects : T . List [ ObjectTypes ] ,
environment : environment . Environment ,
compilers : T . Dict [ str , ' Compiler ' ] ,
kwargs ) :
if ' version ' in kwargs :
raise MesonException ( ' Shared modules must not specify the version kwarg. ' )
if ' soversion ' in kwargs :
raise MesonException ( ' Shared modules must not specify the soversion kwarg. ' )
super ( ) . __init__ ( name , subdir , subproject , for_machine , sources ,
structured_sources , objects , environment , compilers , kwargs )
# We need to set the soname in cases where build files link the module
# to build targets, see: https://github.com/mesonbuild/meson/issues/9492
self . force_soname = False
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return self . environment . get_shared_module_dir ( ) , ' {moduledir_shared} '
class BothLibraries ( SecondLevelHolder ) :
def __init__ ( self , shared : SharedLibrary , static : StaticLibrary ) - > None :
self . _preferred_library = ' shared '
self . shared = shared
self . static = static
self . subproject = self . shared . subproject
def __repr__ ( self ) - > str :
return f ' <BothLibraries: static= { repr ( self . static ) } ; shared= { repr ( self . shared ) } > '
def get_default_object ( self ) - > BuildTarget :
if self . _preferred_library == ' shared ' :
return self . shared
elif self . _preferred_library == ' static ' :
return self . static
raise MesonBugException ( f ' self._preferred_library == " { self . _preferred_library } " is neither " shared " nor " static " . ' )
class CommandBase :
depend_files : T . List [ File ]
dependencies : T . List [ T . Union [ BuildTarget , ' CustomTarget ' ] ]
subproject : str
def flatten_command ( self , cmd : T . Sequence [ T . Union [ str , File , programs . ExternalProgram , BuildTargetTypes ] ] ) - > \
T . List [ T . Union [ str , File , BuildTarget , ' CustomTarget ' ] ] :
cmd = listify ( cmd )
final_cmd : T . List [ T . Union [ str , File , BuildTarget , ' CustomTarget ' ] ] = [ ]
for c in cmd :
if isinstance ( c , str ) :
final_cmd . append ( c )
elif isinstance ( c , File ) :
self . depend_files . append ( c )
final_cmd . append ( c )
elif isinstance ( c , programs . ExternalProgram ) :
if not c . found ( ) :
raise InvalidArguments ( ' Tried to use not-found external program in " command " ' )
path = c . get_path ( )
if os . path . isabs ( path ) :
# Can only add a dependency on an external program which we
# know the absolute path of
self . depend_files . append ( File . from_absolute_file ( path ) )
final_cmd + = c . get_command ( )
elif isinstance ( c , ( BuildTarget , CustomTarget ) ) :
self . dependencies . append ( c )
final_cmd . append ( c )
elif isinstance ( c , CustomTargetIndex ) :
FeatureNew . single_use ( ' CustomTargetIndex for command argument ' , ' 0.60 ' , self . subproject )
self . dependencies . append ( c . target )
final_cmd + = self . flatten_command ( File . from_built_file ( c . get_subdir ( ) , c . get_filename ( ) ) )
elif isinstance ( c , list ) :
final_cmd + = self . flatten_command ( c )
else :
raise InvalidArguments ( f ' Argument { c !r} in " command " is invalid ' )
return final_cmd
class CustomTarget ( Target , CommandBase ) :
typename = ' custom '
def __init__ ( self ,
name : T . Optional [ str ] ,
subdir : str ,
subproject : str ,
environment : environment . Environment ,
command : T . Sequence [ T . Union [
str , BuildTargetTypes , GeneratedList ,
programs . ExternalProgram , File ] ] ,
sources : T . Sequence [ T . Union [
str , File , BuildTargetTypes , ExtractedObjects ,
GeneratedList , programs . ExternalProgram ] ] ,
outputs : T . List [ str ] ,
* ,
build_always_stale : bool = False ,
build_by_default : T . Optional [ bool ] = None ,
capture : bool = False ,
console : bool = False ,
depend_files : T . Optional [ T . Sequence [ FileOrString ] ] = None ,
extra_depends : T . Optional [ T . Sequence [ T . Union [ str , SourceOutputs ] ] ] = None ,
depfile : T . Optional [ str ] = None ,
env : T . Optional [ EnvironmentVariables ] = None ,
feed : bool = False ,
install : bool = False ,
install_dir : T . Optional [ T . List [ T . Union [ str , Literal [ False ] ] ] ] = None ,
install_mode : T . Optional [ FileMode ] = None ,
simplify install_tag handling according to the accepted API
There are two problems here: a typing problem, and an algorithm problem.
We expect it to always be passed to CustomTarget() as a list, but we ran
list() on it, which became horribly mangled if you violated the types
and passed a string instead. This caused weird*er* errors and didn't
even do anything. We want to do all validation in the interpreter,
anyway, and make the build level dumb.
Meanwhile we type it as accepting a T.Sequence, which technically
permits... a string, actually. This isn't intentional; the point of
using T.Sequence is out of a misguided idea that APIs are supposed to be
"technically correct" by allowing "anything that fulfills an interface",
which is a flawed concept because we aren't using interfaces here, and
also because "technically string fulfills the same interface as a list,
if we're talking sequences".
Basically:
- mypy is broken by design, because it typechecks "python", not "what we
wish python to be"
- we do not actually need to graciously permit passing tuples instead of
lists
As far as historic implementations of this logic go, we have formerly:
- originally, typeslistified anything
- switched to accepting list from the interpreter, redundantly ran list()
on the list we got, and mishandling API violations passing a string
(commit 11f96380351a88059ec55f1070fdebc1b1033117)
- switched to accepting anything, stringlistifying it if it was not
`None`, mishandling `[None]`, and invoking list(x) on a brand new list
from stringlistify (commit 157d43883515507f42618b065a64fb26501734a0)
- stopped stringlistify, just accept T.List[str | None] and re-cast to
list, violates typing because we use/handle plain None too
(commit a8521fef70ef76fb742d80aceb2e9ed634bd6a70)
- break typing by declaring we accept a simple string, which still
results in mishandling by converting 'foo' -> ['f', 'o', 'o']
(commit ac576530c43734495815f22456596772a8f6a8cc)
All of this. ALL of it. Is because we tried to be fancy and say we
accept T.Tuple; the only version of this logic that has ever worked
correctly is the original untyped do-all-validation-in-the-build-phase
typeslistified version.
Let's just call it what it is. We want a list | None, and we handle it too.
3 years ago
install_tag : T . Optional [ T . List [ T . Optional [ str ] ] ] = None ,
absolute_paths : bool = False ,
backend : T . Optional [ ' Backend ' ] = None ,
) :
# TODO expose keyword arg to make MachineChoice.HOST configurable
super ( ) . __init__ ( name , subdir , subproject , False , MachineChoice . HOST , environment ,
install , build_always_stale )
self . sources = list ( sources )
self . outputs = substitute_values (
outputs , get_filenames_templates_dict (
get_sources_string_names ( sources , backend ) ,
[ ] ) )
self . build_by_default = build_by_default if build_by_default is not None else install
self . capture = capture
self . console = console
self . depend_files = list ( depend_files or [ ] )
self . dependencies : T . List [ T . Union [ CustomTarget , BuildTarget ] ] = [ ]
# must be after depend_files and dependencies
self . command = self . flatten_command ( command )
self . depfile = depfile
self . env = env or EnvironmentVariables ( )
self . extra_depends = list ( extra_depends or [ ] )
self . feed = feed
self . install_dir = list ( install_dir or [ ] )
self . install_mode = install_mode
self . install_tag = _process_install_tag ( install_tag , len ( self . outputs ) )
self . name = name if name else self . outputs [ 0 ]
# Whether to use absolute paths for all files on the commandline
self . absolute_paths = absolute_paths
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return None , None
def __repr__ ( self ) :
repr_str = " < {0} {1} : {2} > "
return repr_str . format ( self . __class__ . __name__ , self . get_id ( ) , self . command )
def get_target_dependencies ( self ) - > T . List [ T . Union [ SourceOutputs , str ] ] :
deps : T . List [ T . Union [ SourceOutputs , str ] ] = [ ]
deps . extend ( self . dependencies )
deps . extend ( self . extra_depends )
for c in self . sources :
if isinstance ( c , CustomTargetIndex ) :
deps . append ( c . target )
elif not isinstance ( c , programs . ExternalProgram ) :
deps . append ( c )
return deps
def get_transitive_build_target_deps ( self ) - > T . Set [ T . Union [ BuildTarget , ' CustomTarget ' ] ] :
'''
Recursively fetch the build targets that this custom target depends on ,
whether through ` command : ` , ` depends : ` , or ` sources : ` The recursion is
only performed on custom targets .
This is useful for setting PATH on Windows for finding required DLLs .
F . ex , if you have a python script that loads a C module that links to
other DLLs in your project .
'''
bdeps : T . Set [ T . Union [ BuildTarget , ' CustomTarget ' ] ] = set ( )
deps = self . get_target_dependencies ( )
for d in deps :
if isinstance ( d , BuildTarget ) :
bdeps . add ( d )
elif isinstance ( d , CustomTarget ) :
bdeps . update ( d . get_transitive_build_target_deps ( ) )
return bdeps
def get_dependencies ( self ) :
return self . dependencies
def should_install ( self ) - > bool :
return self . install
def get_custom_install_dir ( self ) - > T . List [ T . Union [ str , Literal [ False ] ] ] :
return self . install_dir
def get_custom_install_mode ( self ) - > T . Optional [ ' FileMode ' ] :
return self . install_mode
def get_outputs ( self ) - > T . List [ str ] :
return self . outputs
def get_filename ( self ) - > str :
return self . outputs [ 0 ]
def get_sources ( self ) - > T . List [ T . Union [ str , File , BuildTarget , GeneratedTypes , ExtractedObjects , programs . ExternalProgram ] ] :
return self . sources
def get_generated_lists ( self ) - > T . List [ GeneratedList ] :
genlists : T . List [ GeneratedList ] = [ ]
for c in self . sources :
if isinstance ( c , GeneratedList ) :
genlists . append ( c )
return genlists
def get_generated_sources ( self ) - > T . List [ GeneratedList ] :
return self . get_generated_lists ( )
def get_dep_outname ( self , infilenames ) :
if self . depfile is None :
raise InvalidArguments ( ' Tried to get depfile name for custom_target that does not have depfile defined. ' )
if infilenames :
plainname = os . path . basename ( infilenames [ 0 ] )
basename = os . path . splitext ( plainname ) [ 0 ]
return self . depfile . replace ( ' @BASENAME@ ' , basename ) . replace ( ' @PLAINNAME@ ' , plainname )
else :
if ' @BASENAME@ ' in self . depfile or ' @PLAINNAME@ ' in self . depfile :
raise InvalidArguments ( ' Substitution in depfile for custom_target that does not have an input file. ' )
return self . depfile
def is_linkable_output ( self , output : str ) - > bool :
if output . endswith ( ( ' .a ' , ' .dll ' , ' .lib ' , ' .so ' , ' .dylib ' ) ) :
return True
# libfoo.so.X soname
if re . search ( r ' \ .so( \ . \ d+)*$ ' , output ) :
return True
return False
def is_linkable_target ( self ) - > bool :
if len ( self . outputs ) != 1 :
return False
return self . is_linkable_output ( self . outputs [ 0 ] )
def links_dynamically ( self ) - > bool :
""" Whether this target links dynamically or statically
Does not assert the target is linkable , just that it is not shared
: return : True if is dynamically linked , otherwise False
"""
suf = os . path . splitext ( self . outputs [ 0 ] ) [ - 1 ]
return suf not in { ' .a ' , ' .lib ' }
def get_link_deps_mapping ( self , prefix : str ) - > T . Mapping [ str , str ] :
return { }
def get_link_dep_subdirs ( self ) - > T . AbstractSet [ str ] :
return OrderedSet ( )
def get_all_link_deps ( self ) :
return [ ]
def is_internal ( self ) - > bool :
'''
Returns True if this is a not installed static library .
'''
if len ( self . outputs ) != 1 :
return False
return CustomTargetIndex ( self , self . outputs [ 0 ] ) . is_internal ( )
def extract_all_objects_recurse ( self ) - > T . List [ T . Union [ str , ' ExtractedObjects ' ] ] :
return self . get_outputs ( )
def type_suffix ( self ) :
return " @cus "
def __getitem__ ( self , index : int ) - > ' CustomTargetIndex ' :
return CustomTargetIndex ( self , self . outputs [ index ] )
def __setitem__ ( self , index , value ) :
raise NotImplementedError
def __delitem__ ( self , index ) :
raise NotImplementedError
def __iter__ ( self ) :
for i in self . outputs :
yield CustomTargetIndex ( self , i )
def __len__ ( self ) - > int :
return len ( self . outputs )
class CompileTarget ( BuildTarget ) :
'''
Target that only compile sources without linking them together .
It can be used as preprocessor , or transpiler .
'''
typename = ' compile '
def __init__ ( self ,
name : str ,
subdir : str ,
subproject : str ,
environment : environment . Environment ,
sources : T . List [ ' SourceOutputs ' ] ,
output_templ : str ,
compiler : Compiler ,
backend : Backend ,
compile_args : T . List [ str ] ,
include_directories : T . List [ IncludeDirs ] ,
dependencies : T . List [ dependencies . Dependency ] ) :
compilers = { compiler . get_language ( ) : compiler }
kwargs = {
' build_by_default ' : False ,
f ' { compiler . language } _args ' : compile_args ,
' include_directories ' : include_directories ,
' dependencies ' : dependencies ,
}
super ( ) . __init__ ( name , subdir , subproject , compiler . for_machine ,
sources , None , [ ] , environment , compilers , kwargs )
self . filename = name
self . compiler = compiler
self . output_templ = output_templ
self . outputs = [ ]
self . sources_map : T . Dict [ File , str ] = { }
for f in self . sources :
self . _add_output ( f )
for gensrc in self . generated :
for s in gensrc . get_outputs ( ) :
rel_src = backend . get_target_generated_dir ( self , gensrc , s )
self . _add_output ( File . from_built_relative ( rel_src ) )
def type_suffix ( self ) - > str :
return " @compile "
@property
def is_unity ( self ) - > bool :
return False
def _add_output ( self , f : File ) - > None :
plainname = os . path . basename ( f . fname )
basename = os . path . splitext ( plainname ) [ 0 ]
o = self . output_templ . replace ( ' @BASENAME@ ' , basename ) . replace ( ' @PLAINNAME@ ' , plainname )
self . outputs . append ( o )
self . sources_map [ f ] = o
class RunTarget ( Target , CommandBase ) :
typename = ' run '
def __init__ ( self , name : str ,
command : T . Sequence [ T . Union [ str , File , BuildTargetTypes , programs . ExternalProgram ] ] ,
dependencies : T . Sequence [ Target ] ,
subdir : str ,
subproject : str ,
environment : environment . Environment ,
env : T . Optional [ ' EnvironmentVariables ' ] = None ,
default_env : bool = True ) :
# These don't produce output artifacts
super ( ) . __init__ ( name , subdir , subproject , False , MachineChoice . BUILD , environment )
self . dependencies = dependencies
self . depend_files = [ ]
self . command = self . flatten_command ( command )
self . absolute_paths = False
self . env = env
self . default_env = default_env
def __repr__ ( self ) - > str :
repr_str = " < {0} {1} : {2} > "
return repr_str . format ( self . __class__ . __name__ , self . get_id ( ) , self . command [ 0 ] )
def get_dependencies ( self ) - > T . List [ T . Union [ BuildTarget , ' CustomTarget ' ] ] :
return self . dependencies
def get_generated_sources ( self ) - > T . List [ ' GeneratedTypes ' ] :
return [ ]
def get_sources ( self ) - > T . List [ File ] :
return [ ]
def should_install ( self ) - > bool :
return False
def get_filename ( self ) - > str :
return self . name
def get_outputs ( self ) - > T . List [ str ] :
if isinstance ( self . name , str ) :
return [ self . name ]
elif isinstance ( self . name , list ) :
return self . name
else :
raise RuntimeError ( ' RunTarget: self.name is neither a list nor a string. This is a bug ' )
def type_suffix ( self ) - > str :
return " @run "
class AliasTarget ( RunTarget ) :
typename = ' alias '
def __init__ ( self , name : str , dependencies : T . Sequence [ ' Target ' ] ,
subdir : str , subproject : str , environment : environment . Environment ) :
super ( ) . __init__ ( name , [ ] , dependencies , subdir , subproject , environment )
def __repr__ ( self ) :
repr_str = " < {0} {1} > "
return repr_str . format ( self . __class__ . __name__ , self . get_id ( ) )
class Jar ( BuildTarget ) :
known_kwargs = known_jar_kwargs
typename = ' jar '
def __init__ ( self , name : str , subdir : str , subproject : str , for_machine : MachineChoice ,
sources : T . List [ SourceOutputs ] , structured_sources : T . Optional [ ' StructuredSources ' ] ,
objects , environment : environment . Environment , compilers : T . Dict [ str , ' Compiler ' ] ,
kwargs ) :
super ( ) . __init__ ( name , subdir , subproject , for_machine , sources , structured_sources , objects ,
environment , compilers , kwargs )
for s in self . sources :
if not s . endswith ( ' .java ' ) :
raise InvalidArguments ( f ' Jar source { s } is not a java file. ' )
for t in self . link_targets :
if not isinstance ( t , Jar ) :
raise InvalidArguments ( f ' Link target { t } is not a jar target. ' )
if self . structured_sources :
raise InvalidArguments ( ' structured sources are not supported in Java targets. ' )
self . filename = self . name + ' .jar '
self . outputs = [ self . filename ]
self . java_args = kwargs . get ( ' java_args ' , [ ] )
self . java_resources : T . Optional [ StructuredSources ] = kwargs . get ( ' java_resources ' , None )
def get_main_class ( self ) :
return self . main_class
def type_suffix ( self ) :
return " @jar "
def get_java_args ( self ) :
return self . java_args
def get_java_resources ( self ) - > T . Optional [ StructuredSources ] :
return self . java_resources
def validate_install ( self ) :
# All jar targets are installable.
pass
def is_linkable_target ( self ) :
return True
def get_classpath_args ( self ) :
cp_paths = [ os . path . join ( l . get_subdir ( ) , l . get_filename ( ) ) for l in self . link_targets ]
cp_string = os . pathsep . join ( cp_paths )
if cp_string :
return [ ' -cp ' , os . pathsep . join ( cp_paths ) ]
return [ ]
def get_default_install_dir ( self ) - > T . Tuple [ str , str ] :
return self . environment . get_jar_dir ( ) , ' {jardir} '
@dataclass ( eq = False )
class CustomTargetIndex ( HoldableObject ) :
""" A special opaque object returned by indexing a CustomTarget. This object
exists in Meson , but acts as a proxy in the backends , making targets depend
on the CustomTarget it ' s derived from, but only adding one source file to
the sources .
"""
typename : T . ClassVar [ str ] = ' custom '
target : T . Union [ CustomTarget , CompileTarget ]
output : str
def __post_init__ ( self ) - > None :
self . for_machine = self . target . for_machine
@property
def name ( self ) - > str :
return f ' { self . target . name } [ { self . output } ] '
def __repr__ ( self ) :
return ' <CustomTargetIndex: {!r} [ {} ]> ' . format ( self . target , self . output )
def get_outputs ( self ) - > T . List [ str ] :
return [ self . output ]
def get_subdir ( self ) - > str :
return self . target . get_subdir ( )
def get_filename ( self ) - > str :
return self . output
def get_id ( self ) - > str :
return self . target . get_id ( )
def get_all_link_deps ( self ) :
return self . target . get_all_link_deps ( )
def get_link_deps_mapping ( self , prefix : str ) - > T . Mapping [ str , str ] :
return self . target . get_link_deps_mapping ( prefix )
def get_link_dep_subdirs ( self ) - > T . AbstractSet [ str ] :
return self . target . get_link_dep_subdirs ( )
def is_linkable_target ( self ) - > bool :
return self . target . is_linkable_output ( self . output )
def links_dynamically ( self ) - > bool :
""" Whether this target links dynamically or statically
Does not assert the target is linkable , just that it is not shared
: return : True if is dynamically linked , otherwise False
"""
suf = os . path . splitext ( self . output ) [ - 1 ]
return suf not in { ' .a ' , ' .lib ' }
def should_install ( self ) - > bool :
return self . target . should_install ( )
def is_internal ( self ) - > bool :
'''
Returns True if this is a not installed static library
'''
suf = os . path . splitext ( self . output ) [ - 1 ]
return suf in { ' .a ' , ' .lib ' } and not self . should_install ( )
def extract_all_objects_recurse ( self ) - > T . List [ T . Union [ str , ' ExtractedObjects ' ] ] :
return self . target . extract_all_objects_recurse ( )
def get_custom_install_dir ( self ) - > T . List [ T . Union [ str , Literal [ False ] ] ] :
return self . target . get_custom_install_dir ( )
class ConfigurationData ( HoldableObject ) :
def __init__ ( self , initial_values : T . Optional [ T . Union [
T . Dict [ str , T . Tuple [ T . Union [ str , int , bool ] , T . Optional [ str ] ] ] ,
T . Dict [ str , T . Union [ str , int , bool ] ] ]
] = None ) :
super ( ) . __init__ ( )
self . values : T . Dict [ str , T . Tuple [ T . Union [ str , int , bool ] , T . Optional [ str ] ] ] = \
{ k : v if isinstance ( v , tuple ) else ( v , None ) for k , v in initial_values . items ( ) } if initial_values else { }
self . used : bool = False
def __repr__ ( self ) - > str :
return repr ( self . values )
def __contains__ ( self , value : str ) - > bool :
return value in self . values
def __bool__ ( self ) - > bool :
return bool ( self . values )
def get ( self , name : str ) - > T . Tuple [ T . Union [ str , int , bool ] , T . Optional [ str ] ] :
return self . values [ name ] # (val, desc)
def keys ( self ) - > T . Iterator [ str ] :
return self . values . keys ( )
# A bit poorly named, but this represents plain data files to copy
# during install.
@dataclass ( eq = False )
class Data ( HoldableObject ) :
sources : T . List [ File ]
install_dir : str
install_dir_name : str
install_mode : ' FileMode '
subproject : str
rename : T . List [ str ] = None
install_tag : T . Optional [ str ] = None
data_type : str = None
def __post_init__ ( self ) - > None :
if self . rename is None :
self . rename = [ os . path . basename ( f . fname ) for f in self . sources ]
@dataclass ( eq = False )
class SymlinkData ( HoldableObject ) :
target : str
name : str
install_dir : str
subproject : str
install_tag : T . Optional [ str ] = None
def __post_init__ ( self ) - > None :
if self . name != os . path . basename ( self . name ) :
raise InvalidArguments ( f ' Link name is " { self . name } " , but link names cannot contain path separators. '
' The dir part should be in install_dir. ' )
@dataclass ( eq = False )
class TestSetup :
exe_wrapper : T . List [ str ]
gdb : bool
timeout_multiplier : int
env : EnvironmentVariables
exclude_suites : T . List [ str ]
def get_sources_string_names ( sources , backend ) :
'''
For the specified list of @sources which can be strings , Files , or targets ,
get all the output basenames .
'''
names = [ ]
for s in sources :
if isinstance ( s , str ) :
names . append ( s )
elif isinstance ( s , ( BuildTarget , CustomTarget , CustomTargetIndex , GeneratedList ) ) :
names + = s . get_outputs ( )
elif isinstance ( s , ExtractedObjects ) :
names + = backend . determine_ext_objs ( s )
elif isinstance ( s , File ) :
names . append ( s . fname )
else :
raise AssertionError ( f ' Unknown source type: { s !r} ' )
return names
def load ( build_dir : str ) - > Build :
filename = os . path . join ( build_dir , ' meson-private ' , ' build.dat ' )
try :
b = pickle_load ( filename , ' Build data ' , Build )
# We excluded coredata when saving Build object, load it separately
b . environment . coredata = coredata . load ( build_dir )
return b
except FileNotFoundError :
raise MesonException ( f ' No such build data file as { filename !r} . ' )
def save ( obj : Build , filename : str ) - > None :
# Exclude coredata because we pickle it separately already
cdata = obj . environment . coredata
obj . environment . coredata = None
try :
with open ( filename , ' wb ' ) as f :
pickle . dump ( obj , f )
finally :
obj . environment . coredata = cdata