def __init__(self, conanfile, backend=None, build_type=None):
"""
:param conanfile: Conanfile instance (or settings for retro compatibility)
:param backend: Generator name to use or none to autodetect.
Possible values: ninja,vs,vs2010,vs2015,vs2017,xcode
:param build_type: Overrides default build type comming from settings
"""
self._conanfile = conanfile
self._settings = conanfile.settings
self._os = self._ss("os")
self._compiler = self._ss("compiler")
self._compiler_version = self._ss("compiler.version")
self._build_type = self._ss("build_type")
self.backend = backend or "ninja" # Other backends are poorly supported, not default other.
self.options = dict()
if self._conanfile.package_folder:
self.options['prefix'] = self._conanfile.package_folder
self.options['libdir'] = DEFAULT_LIB
self.options['bindir'] = DEFAULT_BIN
self.options['sbindir'] = DEFAULT_BIN
self.options['libexecdir'] = DEFAULT_BIN
self.options['includedir'] = DEFAULT_INCLUDE
# C++ standard
cppstd = cppstd_from_settings(self._conanfile.settings)
cppstd_conan2meson = {
None: 'none',
'98': 'c++03',
'gnu98': 'gnu++03',
'11': 'c++11',
'gnu11': 'gnu++11',
'14': 'c++14',
'gnu14': 'gnu++14',
'17': 'c++17',
'gnu17': 'gnu++17',
'20': 'c++1z',
'gnu20': 'gnu++1z'
}
self.options['cpp_std'] = cppstd_conan2meson[cppstd]
# shared
shared = self._so("shared")
self.options[
'default_library'] = "shared" if shared is None or shared else "static"
# fpic
if self._os and "Windows" not in self._os:
fpic = self._so("fPIC")
if fpic is not None:
shared = self._so("shared")
self.options['b_staticpic'] = "true" if (
fpic or shared) else "false"
self.build_dir = None
if build_type and build_type != self._build_type:
# Call the setter to warn and update the definitions if needed
self.build_type = build_type
def vs_std_cpp(settings):
cppstd = cppstd_from_settings(settings)
if settings.get_safe("compiler") == "Visual Studio" and cppstd:
flag = cppstd_flag(settings.get_safe("compiler"),
settings.get_safe("compiler.version"), cppstd)
return flag
return None
def _toolchain_content(self):
sections = []
sections.append("def configure(conf):")
sections.append(" if not conf.env.CXXFLAGS:")
sections.append(" conf.env.CXXFLAGS = []")
sections.append(" if not conf.env.LINKFLAGS:")
sections.append(" conf.env.LINKFLAGS = []")
if "Visual Studio" in self._compiler:
# first we set the options for the compiler, then load
if self._compiler_version:
sections.append(" conf.env.MSVC_VERSION = '{}.0'".format(
self._compiler_version))
try:
sections.append(" conf.env.MSVC_TARGETS = '{}'".format(
self._arch_conan2waf[self._arch]))
except KeyError:
raise ConanException("Architecture '%s' not supported" %
self._arch)
sections.append(" conf.env.CXXFLAGS.append('/{}')".format(
self._compiler_runtime))
sections.append(" conf.env.CXXFLAGS.extend(['/EHsc'])")
if self._build_type == "Debug":
sections.append(" conf.env.CXXFLAGS.extend(['/Zi', '/FS'])")
sections.append(" conf.env.LINKFLAGS.extend(['/DEBUG'])")
elif self._build_type == "Release":
sections.append(
" conf.env.CXXFLAGS.extend(['/O2', '/Ob1', '/DNDEBUG'])"
)
else:
sections.append(" conf.env.CC_VERSION = {}".format(
self._gcc_ver_conan2waf(self._compiler_version)))
cxxf = self._libcxx_flags(compiler=self._compiler,
libcxx=self._compiler_libcxx)
cppstd = cppstd_from_settings(self._conanfile.settings)
cxxf.append(
cppstd_flag(
self._conanfile.settings.get_safe("compiler"),
self._conanfile.settings.get_safe("compiler.version"),
cppstd))
for flag in cxxf:
sections.append(
" conf.env.CXXFLAGS.append('{}')".format(flag))
if self._compiler_cppstd:
cppstdf = cppstd_flag(self._compiler, self._compiler_version,
self._compiler_cppstd)
sections.append(
" conf.env.CXXFLAGS.append('{}')".format(cppstdf))
if self._build_type == "Debug":
sections.append(" conf.env.CXXFLAGS.extend(['-g'])")
elif self._build_type == "Release":
sections.append(" conf.env.CXXFLAGS.extend(['-O3'])")
return "\n".join(sections)
def _cppstd_flag(self):
if conan_version >= Version("1.24"):
return tools.cppstd_flag(self._settings)
else:
from conans.client.build.cppstd_flags import cppstd_flag, cppstd_from_settings
compiler = self._settings.get_safe("compiler")
compiler_version = self._settings.get_safe("compiler.version")
cppstd = cppstd_from_settings(self._settings)
return cppstd_flag(compiler, compiler_version, cppstd)
def __init__(self, conanfile):
self._conanfile = conanfile
self._build_type = self._conanfile.settings.get_safe("build_type")
self._base_compiler = self._conanfile.settings.get_safe("compiler.base") or \
self._conanfile.settings.get_safe("compiler")
self._vscrt = self._conanfile.settings.get_safe("compiler.base.runtime") or \
self._conanfile.settings.get_safe("compiler.runtime")
self._cppstd = cppstd_from_settings(self._conanfile.settings)
self._shared = self._conanfile.options.get_safe("shared")
self._fpic = self._conanfile.options.get_safe("fPIC")
self._build_env = VirtualBuildEnv(self._conanfile).environment()
self.definitions = dict()
self.preprocessor_definitions = dict()
def from_build_env(name):
return self._to_meson_value(self._build_env.get(name, None))
self.c = from_build_env("CC")
self.cpp = from_build_env("CXX")
self.c_ld = from_build_env("CC_LD") or from_build_env("LD")
self.cpp_ld = from_build_env("CXX_LD") or from_build_env("LD")
self.ar = from_build_env("AR")
self.strip = from_build_env("STRIP")
self.as_ = from_build_env("AS")
self.windres = from_build_env("WINDRES")
self.pkgconfig = from_build_env("PKG_CONFIG")
# https://mesonbuild.com/Builtin-options.html#core-options
# Do not adjust "debug" if already adjusted "buildtype"
self.buildtype = self._to_meson_build_type(
self._build_type) if self._build_type else None
self.default_library = self._to_meson_shared(self._shared) \
if self._shared is not None else None
# https://mesonbuild.com/Builtin-options.html#base-options
self.b_vscrt = self._to_meson_vscrt(self._vscrt)
self.b_staticpic = self._to_meson_value(self._fpic) \
if (self._shared is False and self._fpic is not None) else None
self.b_ndebug = self._to_meson_value(
self._ndebug) if self._build_type else None
# https://mesonbuild.com/Builtin-options.html#compiler-options
self.cpp_std = self._to_meson_cppstd(
self._cppstd) if self._cppstd else None
self.c_args = self._to_meson_value(
self._env_array('CPPFLAGS') + self._env_array('CFLAGS'))
self.c_link_args = self._to_meson_value(self._env_array('LDFLAGS'))
self.cpp_args = self._to_meson_value(
self._env_array('CPPFLAGS') + self._env_array('CXXFLAGS'))
self.cpp_link_args = self._to_meson_value(self._env_array('LDFLAGS'))
self.pkg_config_path = "'%s'" % self._conanfile.generators_folder
check_using_build_profile(self._conanfile)
def __init__(self, conanfile, env=os.environ):
self._conanfile = conanfile
self._build_type = self._conanfile.settings.get_safe("build_type")
self._base_compiler = self._conanfile.settings.get_safe("compiler.base") or \
self._conanfile.settings.get_safe("compiler")
self._vscrt = self._conanfile.settings.get_safe("compiler.base.runtime") or \
self._conanfile.settings.get_safe("compiler.runtime")
self._cppstd = cppstd_from_settings(self._conanfile.settings)
self._shared = self._conanfile.options.get_safe("shared")
self._fpic = self._conanfile.options.get_safe("fPIC")
self.definitions = dict()
self._env = env
def content(self):
"""With compiler_args you can invoke your compiler:
$ gcc main.c @conanbuildinfo.args -o main
$ clang main.c @conanbuildinfo.args -o main
$ cl /EHsc main.c @conanbuildinfo.args
"""
flags = []
flags.extend(format_defines(self._deps_build_info.defines))
flags.extend(format_include_paths(self._deps_build_info.include_paths,
compiler=self.compiler))
flags.extend(self._deps_build_info.cxxflags)
flags.extend(self._deps_build_info.cflags)
arch_flag = architecture_flag(arch=self.conanfile.settings.get_safe("arch"),
os=self.conanfile.settings.get_safe("os"),
compiler=self.compiler)
if arch_flag:
flags.append(arch_flag)
build_type = self.conanfile.settings.get_safe("build_type")
btfs = build_type_flags(compiler=self.compiler, build_type=build_type,
vs_toolset=self.conanfile.settings.get_safe("compiler.toolset"))
if btfs:
flags.extend(btfs)
btd = build_type_define(build_type=build_type)
if btd:
flags.extend(format_defines([btd]))
if self.compiler == "Visual Studio":
runtime = visual_runtime(self.conanfile.settings.get_safe("compiler.runtime"))
if runtime:
flags.append(runtime)
# Necessary in the "cl" invocation before specify the rest of linker flags
flags.append(visual_linker_option_separator)
the_os = (self.conanfile.settings.get_safe("os_build") or
self.conanfile.settings.get_safe("os"))
flags.extend(rpath_flags(the_os, self.compiler, self._deps_build_info.lib_paths))
flags.extend(format_library_paths(self._deps_build_info.lib_paths, compiler=self.compiler))
flags.extend(format_libraries(self._deps_build_info.libs, compiler=self.compiler))
flags.extend(self._deps_build_info.sharedlinkflags)
flags.extend(self._deps_build_info.exelinkflags)
flags.extend(self._libcxx_flags())
cppstd = cppstd_from_settings(self.conanfile.settings)
flags.append(cppstd_flag(self.conanfile.settings.get_safe("compiler"),
self.conanfile.settings.get_safe("compiler.version"),
cppstd))
sysrf = sysroot_flag(self._deps_build_info.sysroot, compiler=self.compiler)
if sysrf:
flags.append(sysrf)
return " ".join(flag for flag in flags if flag)
def __init__(self, conanfile, win_bash=False, include_rpath_flags=False):
"""
FIXME: include_rpath_flags CONAN 2.0 to default True? Could break many packages in center
"""
self._conanfile = conanfile
self._win_bash = win_bash
self._include_rpath_flags = include_rpath_flags
self.subsystem = OSInfo().detect_windows_subsystem(
) if self._win_bash else None
self._deps_cpp_info = conanfile.deps_cpp_info
self._os = conanfile.settings.get_safe("os")
self._os_version = conanfile.settings.get_safe("os.version")
self._os_sdk = conanfile.settings.get_safe("os.sdk")
self._os_subsystem = conanfile.settings.get_safe("os.subsystem")
self._arch = conanfile.settings.get_safe("arch")
self._os_target, self._arch_target = get_target_os_arch(conanfile)
self._build_type = conanfile.settings.get_safe("build_type")
self._compiler = conanfile.settings.get_safe("compiler")
conan_v2_error("compiler setting should be defined.",
not self._compiler)
self._compiler_version = conanfile.settings.get_safe(
"compiler.version")
self._compiler_runtime = conanfile.settings.get_safe(
"compiler.runtime")
self._libcxx = conanfile.settings.get_safe("compiler.libcxx")
self._cppstd = cppstd_from_settings(conanfile.settings)
# Set the generic objects before mapping to env vars to let the user
# alter some value
self.libs = list(self._deps_cpp_info.libs)
self.libs.extend(list(self._deps_cpp_info.system_libs))
self.include_paths = list(self._deps_cpp_info.include_paths)
self.library_paths = list(self._deps_cpp_info.lib_paths)
self.defines = self._configure_defines()
# Will go to CFLAGS and CXXFLAGS ["-m64" "-m32", "-g", "-s"]
self.flags = self._configure_flags()
# Only c++ flags [-stdlib, -library], will go to CXXFLAGS
self.cxx_flags = self._configure_cxx_flags()
# cpp standard
self.cppstd_flag = cppstd_flag(conanfile.settings)
# Not -L flags, ["-m64" "-m32"]
self.link_flags = self._configure_link_flags() # TEST!
# Precalculate -fPIC
self.fpic = self._configure_fpic()
# Precalculate build, host, target triplets
self.build, self.host, self.target = self._get_host_build_target_flags(
)
def _get_cpp_standard_vars(self):
cppstd = cppstd_from_settings(self._conanfile.settings)
if not cppstd:
return {}
definitions = {}
if cppstd.startswith("gnu"):
definitions["CONAN_CMAKE_CXX_STANDARD"] = cppstd[3:]
definitions["CONAN_CMAKE_CXX_EXTENSIONS"] = "ON"
else:
definitions["CONAN_CMAKE_CXX_STANDARD"] = cppstd
definitions["CONAN_CMAKE_CXX_EXTENSIONS"] = "OFF"
definitions["CONAN_STD_CXX_FLAG"] = cppstd_flag(self._conanfile.settings)
return definitions
def _get_cpp_standard_vars(self):
cppstd = cppstd_from_settings(self._conanfile.settings)
compiler = self._ss("compiler")
compiler_version = self._ss("compiler.version")
if not cppstd:
return {}
ret = {}
if cppstd.startswith("gnu"):
ret["CONAN_CMAKE_CXX_STANDARD"] = cppstd[3:]
ret["CONAN_CMAKE_CXX_EXTENSIONS"] = "ON"
else:
ret["CONAN_CMAKE_CXX_STANDARD"] = cppstd
ret["CONAN_CMAKE_CXX_EXTENSIONS"] = "OFF"
ret["CONAN_STD_CXX_FLAG"] = cppstd_flag(compiler, compiler_version, cppstd)
return ret
def __init__(self, conanfile):
self._conanfile = conanfile
self._set_libcxx = True
self._set_cppstd = True
self._set_arch = True
self._set_shared = True if conanfile.options.get_safe(
"shared") else False
self._set_fpic = True if conanfile.options.get_safe("fPIC") else False
self._compiler = conanfile.settings.get_safe("compiler")
self._compiler_version = conanfile.settings.get_safe(
"compiler.version")
self._compiler_runtime = conanfile.settings.get_safe(
"compiler.runtime")
self._libcxx = conanfile.settings.get_safe("compiler.libcxx")
# cpp standard
self._cppstd = cppstd_from_settings(conanfile.settings)
self._cppstd_flag = cppstd_flag(conanfile.settings)
# arch_build in compiler flag format
self._arch_flag = architecture_flag(self._conanfile.settings)
# build_type information in compiler flag format
self._build_type_flags = " ".join(
build_type_flags(self._conanfile.settings))
self._os_host = conanfile.settings.get_safe("os")
self._arch_host = conanfile.settings.get_safe("arch")
self._os_target, self._arch_target = get_target_os_arch(conanfile)
self._arch_build, self._os_build = self._get_build_os_arch()
self._build_type = conanfile.settings.get_safe("build_type")
# Precalculate build, host, target triplets
self._trip_build, self._trip_host, self._trip_target = self._get_host_build_target_flags(
)
self.definitions = {}
