MesonToolchain¶

Important

This class will generate files that are only compatible with Meson versions >= 0.55.0

The MesonToolchain is the toolchain generator for Meson and it can be used in the generate() method as follows:

from conan import ConanFile
from conan.tools.meson import MesonToolchain

class App(ConanFile):
    settings = "os", "arch", "compiler", "build_type"
    requires = "hello/0.1"
    options = {"shared": [True, False]}
    default_options = {"shared": False}

    def generate(self):
        tc = MesonToolchain(self)
        tc.preprocessor_definitions["MYDEFINE"] = "MYDEF_VALUE"
        tc.generate()

Important

When your recipe has dependencies MesonToolchain only works with the PkgConfigDeps generator. Please, do not use other generators, as they can have overlapping definitions that can conflict.

Generated files¶

The MesonToolchain generates the following files after a conan install (or when building the package in the cache) with the information provided in the generate() method as well as information translated from the current settings, conf, etc.:

conan_meson_native.ini: if doing a native build.
conan_meson_cross.ini: if doing a cross-build (conan.tools.build).

conan_meson_native.ini¶

This file contains the definitions of all the Meson properties related to the Conan options and settings for the current package, platform, etc. This includes but is not limited to the following:

Detection of default_library from Conan settings.
- Based on existence/value of an option named shared.
Detection of buildtype from Conan settings.
Definition of the C++ standard as necessary.
The Visual Studio runtime (b_vscrt), obtained from Conan input settings.

conan_meson_cross.ini¶

This file contains the same information as the previous conan_meson_native.ini, but with additional information to describe host, target, and build machines (such as the processor architecture).

Check out the meson documentation for more details on native and cross files:

Default directories¶

MesonToolchain manages some of the directories used by Meson. These are variables declared under the [project options] section of the files conan_meson_native.ini and conan_meson_cross.ini (see more information about Meson directories):

bindir: value coming from self.cpp.package.bindirs. Defaulted to None. sbindir: value coming from self.cpp.package.bindirs. Defaulted to None. libexecdir: value coming from self.cpp.package.bindirs. Defaulted to None. datadir: value coming from self.cpp.package.resdirs. Defaulted to None. localedir: value coming from self.cpp.package.resdirs. Defaulted to None. mandir: value coming from self.cpp.package.resdirs. Defaulted to None. infodir: value coming from self.cpp.package.resdirs. Defaulted to None. includedir: value coming from self.cpp.package.includedirs. Defaulted to None. libdir: value coming from self.cpp.package.libdirs. Defaulted to None.

Notice that it needs a layout to be able to initialize those self.cpp.package.xxxxx variables. For instance:

from conan import ConanFile
from conan.tools.meson import MesonToolchain
class App(ConanFile):
    settings = "os", "arch", "compiler", "build_type"
    def layout(self):
        self.folders.build = "build"
        self.cpp.package.resdirs = ["res"]
    def generate(self):
        tc = MesonToolchain(self)
        self.output.info(tc.project_options["datadir"])  # Will print '["res"]'
        tc.generate()

Note

All of them are saved only if they have any value. If the values are``None``, they won’t be mentioned in [project options] section.

Customization¶

Attributes¶

project_options¶

This attribute allows defining Meson project options:

def generate(self):
    tc = MesonToolchain(self)
    tc.project_options["MYVAR"] = "MyValue"
    tc.generate()

This is translated to:

One project options definition for MYVAR in conan_meson_native.ini or conan_meson_cross.ini file.

The wrap_mode: nofallback is defined by default as a project option, to make sure that dependencies are found in Conan packages. It is possible to change or remove it with:

def generate(self):
    tc = MesonToolchain(self)
    tc.project_options.pop("wrap_mode")
    tc.generate()

Note that in this case, Meson might be able to find dependencies in “wraps”, it is the responsibility of the user to check the behavior and make sure about the dependencies origin.

subproject_options¶

This attribute allows defining Meson subproject options:

def generate(self):
    tc = MesonToolchain(self)
    tc.subproject_options["SUBPROJECT"] = [{'MYVAR': 'MyValue'}]
    tc.generate()

This is translated to:

One subproject SUBPROJECT and option definition for MYVAR in the conan_meson_native.ini or conan_meson_cross.ini file.

Note that in contrast to project_options, subproject_options is a dictionary of lists of dictionaries. This is because Meson allows multiple subprojects, and each subproject can have multiple options.

preprocessor_definitions¶

This attribute allows defining compiler preprocessor definitions, for multiple configurations (Debug, Release, etc).

def generate(self):
    tc = MesonToolchain(self)
    tc.preprocessor_definitions["MYDEF"] = "MyValue"
    tc.generate()

This is translated to:

One preprocessor definition for MYDEF in conan_meson_native.ini or conan_meson_cross.ini file.

conf¶

MesonToolchain is affected by these [conf] variables:

tools.meson.mesontoolchain:backend. the meson backend to use. Possible values: ninja, vs, vs2010, vs2015, vs2017, vs2019, xcode.
tools.apple:sdk_path argument for SDK path in case of Apple cross-compilation. It is used as value of the flag -isysroot.
tools.android:ndk_path argument for NDK path in case of Android cross-compilation. It is used to get some binaries like c, cpp and ar used in [binaries] section from conan_meson_cross.ini.
tools.build:cxxflags list of extra C++ flags that is used by cpp_args.
tools.build:cflags list of extra of pure C flags that is used by c_args.
tools.build:sharedlinkflags list of extra linker flags that is used by c_link_args and cpp_link_args.
tools.build:exelinkflags list of extra linker flags that is used by c_link_args and cpp_link_args.
tools.build:linker_scripts list of linker scripts, each of which will be prefixed with -T and passed to c_link_args and cpp_link_args. Only use this flag with linkers that supports specifying linker scripts with the -T flag, such as ld, gold, and lld.
tools.build:defines list of preprocessor definitions, each of which will be prefixed with -D and passed to cpp_args and c_args.
tools.build:compiler_executables dict-like Python object which specifies the compiler as key and the compiler executable path as value. Those keys will be mapped as follows:
tools.build:sysroot which accepts a path to the system root directory and sets the --sysroot flag that is used by c_args, cpp_args, c_link_args and cpp_link_args.
- c: will set c in [binaries] section from conan_meson_xxxx.ini.
- cpp: will set cpp in [binaries] section from conan_meson_xxxx.ini.
- objc: will set objc in [binaries] section from conan_meson_xxxx.ini.
- objcpp: will set objcpp in [binaries] section from conan_meson_xxxx.ini.

Using Proper Data Types for Conan Options in Meson¶

Always transform Conan options into valid Python data types before assigning them as Meson values:

options = {{"shared": [True, False], "fPIC": [True, False], "with_msg": ["ANY"]}}
default_options = {{"shared": False, "fPIC": True, "with_msg": "Hi everyone!"}}

def generate(self):
    tc = MesonToolchain(self)
    tc.project_options["DYNAMIC"] = bool(self.options.shared)  # shared is bool
    tc.project_options["GREETINGS"] = str(self.options.with_msg)  # with_msg is str
    tc.subproject_options["SUBPROJECT"] = [{'MYVAR': str(self.options.with_msg)}]  # with_msg is str
    tc.subproject_options["SUBPROJECT"].append({'MYVAR': bool(self.options.shared)})  # shared is bool
    tc.generate()

In contrast, directly assigning a Conan option as a Meson value is strongly discouraged:

options = {{"shared": [True, False], "fPIC": [True, False], "with_msg": ["ANY"]}}
default_options = {{"shared": False, "fPIC": True, "with_msg": "Hi everyone!"}}
# ...
def generate(self):
    tc = MesonToolchain(self)
    tc.project_options["DYNAMIC"] = self.options.shared  # == <PackageOption object>
    tc.project_options["GREETINGS"] = self.options.with_msg  # == <PackageOption object>
    tc.subproject_options["SUBPROJECT"] = [{'MYVAR': self.options.with_msg}]  # == <PackageOption object>
    tc.subproject_options["SUBPROJECT"].append({'MYVAR': self.options.shared})  # == <PackageOption object>
    tc.generate()

These are not boolean or string values but an internal Conan class representing such option values. If you assign these values directly, upon executing the generate() function, you should receive a warning in your console stating, WARN: deprecated: Please, do not use a Conan option value directly. This method is considered bad practice as it can result in unexpected errors during your project’s build process.

Cross-building for Apple and Android¶

The MesonToolchain generator adds all the flags required to cross-compile for Apple (MacOS M1, iOS, etc.) and Android.

Apple

It adds link flags -arch XXX, -isysroot [SDK_PATH] and the minimum deployment target flag, e.g., -mios-version-min=8.0 to the MesonToolchain c_args, c_link_args, cpp_args, and cpp_link_args attributes, given the Conan settings for any Apple OS (iOS, watchOS, etc.) and the tools.apple:sdk_path configuration value like it’s shown in this example of host profile:

ios_host_profile¶

[settings]
os = iOS
os.version = 10.0
os.sdk = iphoneos
arch = armv8
compiler = apple-clang
compiler.version = 12.0
compiler.libcxx = libc++

[conf]
tools.apple:sdk_path=/my/path/to/iPhoneOS.sdk

Android

It initializes the MesonToolchain c, cpp, and ar attributes, which are needed to cross-compile for Android, given the Conan settings for Android and the tools.android:ndk_path configuration value like it’s shown in this example of host profile:

android_host_profile¶

[settings]
os = Android
os.api_level = 21
arch = armv8

[conf]
tools.android:ndk_path=/my/path/to/NDK

Cross-building and native=true¶

New since Conan 2.3.0

When you are cross-building, sometimes you need to build a tool which is used to generate source files. For this you would want to build some targets with the system’s native compiler. Then, you need Conan to create both context files:

def generate(self):
    tc = MesonToolchain(self)
    tc.generate()
    # Forcing to create the native context too
    if cross_building(self):
        tc = MesonToolchain(self, native=True)
        tc.generate()

See also this reference from the Meson documentation for more information.

Objective-C arguments¶

In Apple OS’s there are also specific Objective-C/Objective-C++ arguments: objc, objcpp, objc_args, objc_link_args, objcpp_args, and objcpp_link_args, as public attributes of the MesonToolchain class, where the variables objc and objcpp are initialized as clang and clang++ respectively by default.

Reference¶

class MesonToolchain(conanfile, backend=None, native=False)¶

MesonToolchain generator

Parameters:

conanfile – < ConanFile object > The current recipe object. Always use self.
backend – str backend Meson variable value. By default, ninja.
native – bool Indicates whether you want Conan to create the conan_meson_native.ini in a cross-building context. Notice that it only makes sense if your project’s meson.build uses the native=true (see also https://mesonbuild.com/Cross-compilation.html#mixing-host-and-build-targets).

extra_cxxflags¶: List of extra CXX flags. Added to cpp_args

extra_cflags¶: List of extra C flags. Added to c_args

extra_ldflags¶: List of extra linker flags. Added to c_link_args and cpp_link_args

extra_defines¶: List of extra preprocessor definitions. Added to c_args and cpp_args with the format -D[FLAG_N].

properties¶: Dict-like object that defines Meson properties with key=value format

project_options¶: Dict-like object that defines Meson project options with key=value format

preprocessor_definitions¶: Dict-like object that defines Meson preprocessor definitions

subproject_options¶: Dict-like object that defines Meson subproject options.

pkg_config_path¶: Defines the Meson pkg_config_path variable

cross_build¶: Dict-like object with the build, host, and target as the Meson machine context

c¶: Sets the Meson c variable, defaulting to the CC build environment value. If provided as a blank-separated string, it will be transformed into a list. Otherwise, it remains a single string.

cpp¶: Sets the Meson cpp variable, defaulting to the CXX build environment value. If provided as a blank-separated string, it will be transformed into a list. Otherwise, it remains a single string.

ld¶: Sets the Meson ld variable, defaulting to the LD build environment value. If provided as a blank-separated string, it will be transformed into a list. Otherwise, it remains a single string.

c_ld¶: Defines the Meson c_ld variable. Defaulted to CC_LD environment value

cpp_ld¶: Defines the Meson cpp_ld variable. Defaulted to CXX_LD environment value

ar¶: Defines the Meson ar variable. Defaulted to AR build environment value

strip¶: Defines the Meson strip variable. Defaulted to STRIP build environment value

as_¶: Defines the Meson as variable. Defaulted to AS build environment value

windres¶: Defines the Meson windres variable. Defaulted to WINDRES build environment value

pkgconfig¶: Defines the Meson pkgconfig variable. Defaulted to PKG_CONFIG build environment value

c_args¶: Defines the Meson c_args variable. Defaulted to CFLAGS build environment value

c_link_args¶: Defines the Meson c_link_args variable. Defaulted to LDFLAGS build environment value

cpp_args¶: Defines the Meson cpp_args variable. Defaulted to CXXFLAGS build environment value

cpp_link_args¶: Defines the Meson cpp_link_args variable. Defaulted to LDFLAGS build environment value

apple_arch_flag¶: Apple arch flag as a list, e.g., ["-arch", "i386"]

apple_isysroot_flag¶: Apple sysroot flag as a list, e.g., ["-isysroot", "./Platforms/MacOSX.platform"]

apple_min_version_flag¶: Apple minimum binary version flag as a list, e.g., ["-mios-version-min", "10.8"]

objc¶: Defines the Meson objc variable. Defaulted to None, if if any Apple OS clang

objcpp¶: Defines the Meson objcpp variable. Defaulted to None, if if any Apple OS clang++

objc_args¶: Defines the Meson objc_args variable. Defaulted to OBJCFLAGS build environment value

objc_link_args¶: Defines the Meson objc_link_args variable. Defaulted to LDFLAGS build environment value

objcpp_args¶: Defines the Meson objcpp_args variable. Defaulted to OBJCXXFLAGS build environment value

objcpp_link_args¶: Defines the Meson objcpp_link_args variable. Defaulted to LDFLAGS build environment value

generate()¶: Creates a conan_meson_native.ini (if native builds) or a conan_meson_cross.ini (if cross builds) with the proper content. If Windows OS, it will be created a conanvcvars.bat as well.