def _build_zlib_autotools(self):
env_build = AutoToolsBuildEnvironment(self)
# configure passes CFLAGS to linker, should be LDFLAGS
tools.replace_in_file("../configure", "$LDSHARED $SFLAGS",
"$LDSHARED $LDFLAGS")
# same thing in Makefile.in, when building tests/example executables
tools.replace_in_file("../Makefile.in", "$(CC) $(CFLAGS) -o",
"$(CC) $(LDFLAGS) -o")
# we need to build only libraries without test example and minigzip
if self.options.shared:
make_target = "libz.%s.dylib" % self.version \
if tools.is_apple_os(self.settings.os) else "libz.so.%s" % self.version
else:
make_target = "libz.a"
if tools.is_apple_os(
self.settings.os) and self.settings.get_safe("os.version"):
target = tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version)
env_build.flags.append(target)
env = {}
if "clang" in str(self.settings.compiler) and tools.get_env(
"CC") is None and tools.get_env("CXX") is None:
env = {"CC": "clang", "CXX": "clang++"}
with tools.environment_append(env):
env_build.configure("../", build=False, host=False, target=False)
env_build.make(target=make_target)
def build(self):
for filename in glob.glob("patches/*.patch"):
self.output.info('applying patch "%s"' % filename)
tools.patch(base_path=self._source_subfolder, patch_file=filename)
if self._is_msvc:
run_configure_icu_file = os.path.join(self._source_subfolder,
'source', 'runConfigureICU')
flags = "-%s" % self.settings.compiler.runtime
if self.settings.get_safe("build_type") in [
'Debug', 'RelWithDebInfo'
] and Version(self.settings.compiler.version) >= "12":
flags += " -FS"
tools.replace_in_file(run_configure_icu_file, "-MDd", flags)
tools.replace_in_file(run_configure_icu_file, "-MD", flags)
self._workaround_icu_20545()
self._env_build = AutoToolsBuildEnvironment(self)
if not self.options.get_safe("shared"):
self._env_build.defines.append("U_STATIC_IMPLEMENTATION")
if tools.is_apple_os(self.settings.os):
self._env_build.defines.append("_DARWIN_C_SOURCE")
if self.settings.get_safe("os.version"):
self._env_build.flags.append(
tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version))
if "msys2" in self.deps_user_info:
self._env_build.vars["PYTHON"] = tools.unix_path(
os.path.join(self.deps_env_info["msys2"].MSYS_BIN, "python"),
tools.MSYS2)
build_dir = os.path.join(self.build_folder, self._source_subfolder,
'build')
os.mkdir(build_dir)
with tools.vcvars(self.settings) if self._is_msvc else tools.no_op():
with tools.environment_append(self._env_build.vars):
with tools.chdir(build_dir):
# workaround for https://unicode-org.atlassian.net/browse/ICU-20531
os.makedirs(os.path.join("data", "out", "tmp"))
self.run(self._build_config_cmd,
win_bash=tools.os_info.is_windows)
if self.options.get_safe("silent"):
silent = '--silent' if self.options.silent else 'VERBOSE=1'
else:
silent = '--silent'
command = "make {silent} -j {cpu_count}".format(
silent=silent, cpu_count=tools.cpu_count())
self.run(command, win_bash=tools.os_info.is_windows)
if self.options.get_safe("with_unit_tests"):
command = "make {silent} check".format(silent=silent)
self.run(command, win_bash=tools.os_info.is_windows)
command = "make {silent} install".format(silent=silent)
self.run(command, win_bash=tools.os_info.is_windows)
self._install_name_tool()
def _configure_autotools(self):
if not self._autotools:
args = []
cwd = os.getcwd()
win_bash = self._is_msvc or self._is_mingw_windows
self._autotools = AutoToolsBuildEnvironment(self, win_bash=win_bash)
if self._is_msvc:
args.extend(["CC={}/build-aux/compile cl -nologo".format(cwd),
"CFLAGS=-{}".format(self.settings.compiler.runtime),
"CXX={}/build-aux/compile cl -nologo".format(cwd),
"CXXFLAGS=-{}".format(self.settings.compiler.runtime),
"CPPFLAGS=-D_WIN32_WINNT=_WIN32_WINNT_WIN8",
"LD=link",
"NM=dumpbin -symbols",
"STRIP=:",
"AR={}/build-aux/ar-lib lib".format(cwd),
"RANLIB=:"])
elif self.settings.compiler == "gcc" and self.settings.os == "Windows":
self._autotools.link_flags.extend(["-static", "-static-libgcc"])
elif tools.is_apple_os(self.settings.os) and self.settings.get_safe("os.version"):
target = tools.apple_deployment_target_flag(self.settings.os, self.settings.os.version)
self._autotools.flags.append(target)
self._autotools.configure(args=args)
return self._autotools
def package_info(self):
darwin_arch = tools.to_apple_arch(self.settings.arch)
if self.settings.os == "watchOS" and self.settings.arch == "armv8":
darwin_arch = "arm64_32"
xcrun = tools.XCRun(self.settings)
sysroot = xcrun.sdk_path
self.cpp_info.sysroot = sysroot
common_flags = ["-isysroot%s" % sysroot]
if self.settings.get_safe("os.version"):
common_flags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
if not self.settings.os == "Macos" and self.options.bitcode:
if self.settings.build_type == "Debug":
bitcode_flag = "-fembed-bitcode-marker"
else:
bitcode_flag = "-fembed-bitcode"
common_flags.append(bitcode_flag)
# CMake issue, for details look https://github.com/conan-io/conan/issues/2378
cflags = copy.copy(common_flags)
cflags.extend(["-arch", darwin_arch])
self.cpp_info.cflags = cflags
link_flags = copy.copy(common_flags)
link_flags.append("-arch %s" % darwin_arch)
self.cpp_info.sharedlinkflags.extend(link_flags)
self.cpp_info.exelinkflags.extend(link_flags)
# Set flags in environment too, so that CMake Helper finds them
cflags_str = " ".join(cflags)
ldflags_str = " ".join(link_flags)
self.env_info.CC = xcrun.cc
self.env_info.CPP = "%s -E" % xcrun.cc
self.env_info.CXX = xcrun.cxx
self.env_info.AR = xcrun.ar
self.env_info.RANLIB = xcrun.ranlib
self.env_info.STRIP = xcrun.strip
self.env_info.CFLAGS = cflags_str
self.env_info.ASFLAGS = cflags_str
self.env_info.CPPFLAGS = cflags_str
self.env_info.CXXFLAGS = cflags_str
self.env_info.LDFLAGS = ldflags_str
self.env_info.CONAN_CMAKE_SYSTEM_NAME = self.cmake_system_name
if self.settings.get_safe("os.version"):
self.env_info.CONAN_CMAKE_OSX_DEPLOYMENT_TARGET = str(
self.settings.os.version)
self.env_info.CONAN_CMAKE_OSX_ARCHITECTURES = str(darwin_arch)
self.env_info.CONAN_CMAKE_SYSROOT = sysroot
self.env_info.CONAN_CMAKE_TOOLCHAIN_FILE = os.path.join(
self.package_folder, "darwin-toolchain.cmake")
def _configure_autotools(self):
if not self._autotools:
prefix = tools.unix_path(self.package_folder)
args = ['--disable-cli', '--prefix={}'.format(prefix)]
if self.options.shared:
args.append('--enable-shared')
else:
args.append('--enable-static')
if self.settings.os != 'Windows' and self.options.fPIC:
args.append('--enable-pic')
if self.settings.build_type == 'Debug':
args.append('--enable-debug')
args.append('--bit-depth=%s' % str(self.options.bit_depth))
if tools.cross_building(self.settings):
if self.settings.os == "Android":
# the as of ndk does not work well for building libx264
self._override_env["AS"] = os.environ["CC"]
ndk_root = tools.unix_path(os.environ["NDK_ROOT"])
arch = {
'armv7': 'arm',
'armv8': 'aarch64',
'x86': 'i686',
'x86_64': 'x86_64'
}.get(str(self.settings.arch))
abi = 'androideabi' if self.settings.arch == 'armv7' else 'android'
cross_prefix = "%s/bin/%s-linux-%s-" % (ndk_root, arch,
abi)
args.append('--cross-prefix=%s' % cross_prefix)
if self._is_msvc:
self._override_env['CC'] = 'cl'
self._autotools = AutoToolsBuildEnvironment(
self, win_bash=tools.os_info.is_windows)
if self._is_msvc:
self._autotools.flags.append(
'-%s' % str(self.settings.compiler.runtime))
# cannot open program database ... if multiple CL.EXE write to the same .PDB file, please use /FS
self._autotools.flags.append('-FS')
if tools.is_apple_os(
self.settings.os) and self.settings.get_safe("os.version"):
self._autotools.flags.append(
tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version))
build_canonical_name = None
host_canonical_name = None
if self.settings.compiler == "Visual Studio":
# autotools does not know about the msvc canonical name(s)
build_canonical_name = False
host_canonical_name = False
self._autotools.configure(args=args,
vars=self._override_env,
configure_dir=self._source_subfolder,
build=build_canonical_name,
host=host_canonical_name)
return self._autotools
def _get_env_build(self):
if not self._env_build:
self._env_build = AutoToolsBuildEnvironment(self)
if self.settings.compiler == "apple-clang":
self._env_build.flags.append("-arch %s" % tools.to_apple_arch(self.settings.arch))
self._env_build.flags.append("-isysroot %s" % tools.XCRun(self.settings).sdk_path)
if self.settings.get_safe("os.version"):
self._env_build.flags.append(tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
return self._env_build
def _get_env_build(self):
if not self._env_build:
self._env_build = AutoToolsBuildEnvironment(self)
if self.settings.compiler == "apple-clang":
# add flags only if not already specified, avoid breaking Catalyst which needs very special flags
flags = " ".join(self._env_build.flags)
if "-arch" not in flags:
self._env_build.flags.append("-arch %s" % tools.to_apple_arch(self.settings.arch))
if "-isysroot" not in flags:
self._env_build.flags.append("-isysroot %s" % tools.XCRun(self.settings).sdk_path)
if self.settings.get_safe("os.version") and "-version-min=" not in flags and "-target" not in flags:
self._env_build.flags.append(tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
return self._env_build
def _configure_autotools(self):
if self._env_build:
return self._env_build
self._env_build = AutoToolsBuildEnvironment(self)
if not self.options.shared:
self._env_build.defines.append("U_STATIC_IMPLEMENTATION")
if tools.is_apple_os(self.settings.os):
self._env_build.defines.append("_DARWIN_C_SOURCE")
if self.settings.get_safe("os.version"):
self._env_build.flags.append(tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
if "msys2" in self.deps_user_info:
self._env_build.vars["PYTHON"] = tools.unix_path(os.path.join(self.deps_env_info["msys2"].MSYS_BIN, "python"), tools.MSYS2)
return self._env_build
def _build_autotools(self):
env_build = AutoToolsBuildEnvironment(self)
if not self.options.shared:
env_build.defines.append("U_STATIC_IMPLEMENTATION")
if tools.is_apple_os(self.settings.os) and self.settings.get_safe("os.version"):
env_build.flags.append(tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
with tools.environment_append(env_build.vars):
if self.settings.os == 'Linux':
self.cfg['platform'] = 'Linux/gcc' if str(self.settings.compiler).startswith('gcc') else 'Linux'
elif self.settings.os == 'Macos':
self.cfg['platform'] = 'MacOSX'
if self.settings.os == 'Windows':
self.cfg['platform'] = 'MinGW'
if self.settings.arch == 'x86':
MINGW_CHOST = 'i686-w64-mingw32'
else:
MINGW_CHOST = 'x86_64-w64-mingw32'
self.cfg['host'] = '--build={MINGW_CHOST} ' \
'--host={MINGW_CHOST} '.format(MINGW_CHOST=MINGW_CHOST)
os.mkdir(self.cfg['build_dir'])
config_cmd = self.build_config_cmd()
# with tools.environment_append(env_build.vars):
self.run("cd {builddir} && bash -c '{config_cmd}'".format(builddir=self.cfg['build_dir'],
config_cmd=config_cmd))
os.system("cd {builddir} && make {silent} -j {cpus_var}".format(builddir=self.cfg['build_dir'],
cpus_var=tools.cpu_count(),
silent=self.cfg['silent']))
if self.options.with_unit_tests:
os.system("cd {builddir} && make {silent} check".format(builddir=self.cfg['build_dir'],
silent=self.cfg['silent']))
os.system("cd {builddir} && make {silent} install".format(builddir=self.cfg['build_dir'],
silent=self.cfg['silent']))
if self.settings.os == 'Macos':
with tools.chdir('output/lib'):
for dylib in glob.glob('*icu*.{0}.dylib'.format(self.version)):
self.run('install_name_tool -id {0} {1}'.format(
os.path.basename(dylib), dylib))
def package_info(self):
darwin_arch = tools.to_apple_arch(self.settings.arch)
xcrun = tools.XCRun(self.settings)
sysroot = xcrun.sdk_path
self.cpp_info.sysroot = sysroot
common_flags = ["-isysroot%s" % sysroot]
if self.settings.get_safe("os.version"):
common_flags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
if not self.settings.os == "Macos" and self.options.bitcode:
if self.settings.build_type == "Debug":
bitcode_flag = "-fembed-bitcode-marker"
else:
bitcode_flag = "-fembed-bitcode"
common_flags.append(bitcode_flag)
# CMake issue, for details look https://github.com/conan-io/conan/issues/2378
cflags = copy.copy(common_flags)
cflags.extend(["-arch", darwin_arch])
self.cpp_info.cflags = cflags
link_flags = copy.copy(common_flags)
link_flags.append("-arch %s" % darwin_arch)
self.cpp_info.sharedlinkflags.extend(link_flags)
self.cpp_info.exelinkflags.extend(link_flags)
# Set flags in environment too, so that CMake Helper finds them
cflags_str = " ".join(cflags)
ldflags_str = " ".join(link_flags)
self.env_info.CC = xcrun.cc
self.env_info.CXX = xcrun.cxx
self.env_info.AR = xcrun.ar
self.env_info.RANLIB = xcrun.ranlib
self.env_info.STRIP = xcrun.strip
self.env_info.CFLAGS = cflags_str
self.env_info.CXXFLAGS = cflags_str
self.env_info.LDFLAGS = ldflags_str
def _build_autotools(self):
env_build = AutoToolsBuildEnvironment(self)
if not self.options.shared:
env_build.defines.append("U_STATIC_IMPLEMENTATION")
if tools.is_apple_os(
self.settings.os) and self.settings.get_safe("os.version"):
env_build.flags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
with tools.environment_append(env_build.vars):
if self.settings.os == 'Linux':
self.cfg['platform'] = 'Linux/gcc' if str(
self.settings.compiler).startswith('gcc') else 'Linux'
elif self.settings.os == 'Macos':
self.cfg['platform'] = 'MacOSX'
if self.settings.os == 'Windows':
self.cfg['platform'] = 'MinGW'
if self.settings.arch == 'x86':
MINGW_CHOST = 'i686-w64-mingw32'
else:
MINGW_CHOST = 'x86_64-w64-mingw32'
self.cfg['host'] = '--build={MINGW_CHOST} ' \
'--host={MINGW_CHOST} '.format(MINGW_CHOST=MINGW_CHOST)
os.mkdir(self.cfg['build_dir'])
config_cmd = self.build_config_cmd()
# with tools.environment_append(env_build.vars):
#Run only make to generate build folder for Cross compiling
self.run("cd {builddir} && bash -c '{config_cmd}'".format(
builddir=self.cfg['build_dir'], config_cmd=config_cmd))
os.system("cd {builddir} && make {silent} -j {cpus_var}".format(
builddir=self.cfg['build_dir'],
cpus_var=tools.cpu_count(),
silent=self.cfg['silent']))
def _configure_autotools_vars(self):
autotools_vars = self._autotools.vars
# tweaks for mingw
if self._is_mingw:
autotools_vars["RCFLAGS"] = "-O COFF"
if self.settings.arch == "x86":
autotools_vars["RCFLAGS"] += " --target=pe-i386"
else:
autotools_vars["RCFLAGS"] += " --target=pe-x86-64"
del autotools_vars["LIBS"]
self.output.info("Autotools env vars: " + repr(autotools_vars))
if tools.cross_building(self.settings):
if self.settings.os == "iOS":
iphoneos = tools.apple_sdk_name(self.settings)
ios_dev_target = str(self.settings.os.version).split(".")[0]
env_cppflags = tools.get_env("CPPFLAGS", "")
socket_flags = " -DHAVE_SOCKET -DHAVE_FCNTL_O_NONBLOCK"
if self.settings.arch in ["x86", "x86_64"]:
autotools_vars[
"CPPFLAGS"] = "-D__IPHONE_OS_VERSION_MIN_REQUIRED={}0000 {} {}".format(
ios_dev_target, socket_flags, env_cppflags)
elif self.settings.arch in ["armv7", "armv7s", "armv8"]:
autotools_vars["CPPFLAGS"] = "{} {}".format(
socket_flags, env_cppflags)
else:
raise ConanInvalidConfiguration(
"Unsuported iOS arch {}".format(self.settings.arch))
cc = tools.XCRun(self.settings, iphoneos).cc
sysroot = "-isysroot {}".format(
tools.XCRun(self.settings, iphoneos).sdk_path)
if self.settings.arch == "armv8":
configure_arch = "arm64"
configure_host = "arm" #unused, autodetected
else:
configure_arch = self.settings.arch
configure_host = self.settings.arch #unused, autodetected
arch_flag = "-arch {}".format(configure_arch)
ios_min_version = tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version)
extra_flag = "-Werror=partial-availability"
# if we debug, maybe add a -gdwarf-2 , but why would we want that?
autotools_vars["CC"] = cc
autotools_vars["IPHONEOS_DEPLOYMENT_TARGET"] = ios_dev_target
env_cflags = tools.get_env("CFLAGS", "")
autotools_vars["CFLAGS"] = "{} {} {} {}".format(
sysroot, arch_flag, ios_min_version, env_cflags)
if self.options.with_openssl:
openssl_path = self.deps_cpp_info["openssl"].rootpath
openssl_libdir = self.deps_cpp_info["openssl"].libdirs[0]
autotools_vars["LDFLAGS"] = "{} {} -L{}/{}".format(
arch_flag, sysroot, openssl_path, openssl_libdir)
elif self.options.with_wolfssl:
wolfssl_path = self.deps_cpp_info["wolfssl"].rootpath
wolfssl_libdir = self.deps_cpp_info["wolfssl"].libdirs[0]
autotools_vars["LDFLAGS"] = "{} {} -L{}/{}".format(
arch_flag, sysroot, wolfssl_path, wolfssl_libdir)
else:
autotools_vars["LDFLAGS"] = "{} {}".format(
arch_flag, sysroot)
elif self.settings.os == "Android":
# nothing do to at the moment, this seems to just work
pass
return autotools_vars
def _build_flags(self):
flags = self._build_cross_flags
# https://www.boost.org/doc/libs/1_70_0/libs/context/doc/html/context/architectures.html
if self._b2_os:
flags.append("target-os=%s" % self._b2_os)
if self._b2_architecture:
flags.append("architecture=%s" % self._b2_architecture)
if self._b2_address_model:
flags.append("address-model=%s" % self._b2_address_model)
if self._b2_binary_format:
flags.append("binary-format=%s" % self._b2_binary_format)
if self._b2_abi:
flags.append("abi=%s" % self._b2_abi)
if self.options.layout is not "b2-default":
flags.append("--layout=%s" % self.options.layout)
flags.append("--user-config=%s" %
os.path.join(self._boost_build_dir, 'user-config.jam'))
flags.append("-sNO_ZLIB=%s" % ("0" if self.options.zlib else "1"))
flags.append("-sNO_BZIP2=%s" % ("0" if self.options.bzip2 else "1"))
flags.append("-sNO_LZMA=%s" % ("0" if self.options.lzma else "1"))
flags.append("-sNO_ZSTD=%s" % ("0" if self.options.zstd else "1"))
if self.options.i18n_backend == 'icu':
flags.append("-sICU_PATH={}".format(
self.deps_cpp_info["icu"].rootpath))
flags.append("boost.locale.iconv=off boost.locale.icu=on")
elif self.options.i18n_backend == 'iconv':
flags.append("boost.locale.iconv=on boost.locale.icu=off")
else:
flags.append("boost.locale.iconv=off boost.locale.icu=off")
flags.append("--disable-icu --disable-iconvv")
def add_defines(option, library):
if option:
for define in self.deps_cpp_info[library].defines:
flags.append("define=%s" % define)
if self._zip_bzip2_requires_needed:
add_defines(self.options.zlib, "zlib")
add_defines(self.options.bzip2, "bzip2")
add_defines(self.options.lzma, "xz_utils")
add_defines(self.options.zstd, "zstd")
if self._is_msvc and self.settings.compiler.runtime:
flags.append("runtime-link=%s" % ("static" if "MT" in str(
self.settings.compiler.runtime) else "shared"))
# For details https://boostorg.github.io/build/manual/master/index.html
flags.append(
"threading=%s" %
("single" if not self.options.multithreading else "multi"))
flags.append("link=%s" %
("static" if not self.options.shared else "shared"))
if self.settings.build_type == "Debug":
flags.append("variant=debug")
else:
flags.append("variant=release")
for libname in lib_list:
if getattr(self.options, "without_%s" % libname):
flags.append("--without-%s" % libname)
flags.append("toolset=%s" % self._toolset)
if self.settings.get_safe("compiler.cppstd"):
flags.append("cxxflags=%s" % cppstd_flag(self.settings))
# CXX FLAGS
cxx_flags = []
# fPIC DEFINITION
if self.settings.os != "Windows":
if self.options.fPIC:
cxx_flags.append("-fPIC")
if self.settings.build_type == "RelWithDebInfo":
if self.settings.compiler == "gcc" or "clang" in str(
self.settings.compiler):
cxx_flags.append("-g")
elif self.settings.compiler == "Visual Studio":
cxx_flags.append("/Z7")
# Standalone toolchain fails when declare the std lib
if self.settings.os != "Android" and self.settings.os != "Emscripten":
try:
if self._gnu_cxx11_abi:
flags.append("define=_GLIBCXX_USE_CXX11_ABI=%s" %
self._gnu_cxx11_abi)
if "clang" in str(self.settings.compiler):
if str(self.settings.compiler.libcxx) == "libc++":
cxx_flags.append("-stdlib=libc++")
flags.append('linkflags="-stdlib=libc++"')
else:
cxx_flags.append("-stdlib=libstdc++")
except:
pass
if self.options.error_code_header_only:
flags.append("define=BOOST_ERROR_CODE_HEADER_ONLY=1")
if self.options.system_no_deprecated:
flags.append("define=BOOST_SYSTEM_NO_DEPRECATED=1")
if self.options.asio_no_deprecated:
flags.append("define=BOOST_ASIO_NO_DEPRECATED=1")
if self.options.filesystem_no_deprecated:
flags.append("define=BOOST_FILESYSTEM_NO_DEPRECATED=1")
if self.options.segmented_stacks:
flags.extend([
"segmented-stacks=on", "define=BOOST_USE_SEGMENTED_STACKS=1",
"define=BOOST_USE_UCONTEXT=1"
])
flags.append("pch=on" if self.options.pch else "pch=off")
if tools.is_apple_os(self.settings.os):
if self.settings.get_safe("os.version"):
cxx_flags.append(
tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version))
if self.settings.os == "iOS":
if self.options.multithreading:
cxx_flags.append("-DBOOST_AC_USE_PTHREADS")
cxx_flags.append("-DBOOST_SP_USE_PTHREADS")
cxx_flags.append("-fvisibility=hidden")
cxx_flags.append("-fvisibility-inlines-hidden")
cxx_flags.append("-fembed-bitcode")
cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else ""
flags.append(cxx_flags)
if self.options.extra_b2_flags:
flags.append(str(self.options.extra_b2_flags))
flags.extend([
"install",
"--prefix=%s" % self.package_folder,
"-j%s" % tools.cpu_count(), "--abbreviate-paths"
])
if self.options.debug_level:
flags.append("-d%d" % self.options.debug_level)
return flags
def _configure_autotools(self):
if self._autotools:
return self._autotools
self._autotools = AutoToolsBuildEnvironment(
self, win_bash=tools.os_info.is_windows)
self._autotools.libs = []
opt_enable_disable = lambda what, v: "--{}-{}".format(
"enable" if v else "disable", what)
args = [
"--pkg-config-flags=--static",
"--disable-doc",
"--disable-programs",
opt_enable_disable("cross-compile", tools.cross_building(self)),
# Libraries
opt_enable_disable("shared", self.options.shared),
opt_enable_disable("static", not self.options.shared),
opt_enable_disable("pic", self.options.get_safe("fPIC", True)),
opt_enable_disable("postproc", self.options.postproc),
# Dependencies
opt_enable_disable("bzlib", self.options.with_bzip2),
opt_enable_disable("zlib", self.options.with_zlib),
opt_enable_disable("lzma", self.options.with_lzma),
opt_enable_disable("iconv", self.options.with_libiconv),
opt_enable_disable("libopenjpeg", self.options.with_openjpeg),
opt_enable_disable("libopenh264", self.options.with_openh264),
opt_enable_disable("libvorbis", self.options.with_vorbis),
opt_enable_disable("libopus", self.options.with_opus),
opt_enable_disable("libzmq", self.options.with_zeromq),
opt_enable_disable("sdl2", self.options.with_sdl),
opt_enable_disable("libx264", self.options.with_libx264),
opt_enable_disable("libx265", self.options.with_libx265),
opt_enable_disable("libvpx", self.options.with_libvpx),
opt_enable_disable("libmp3lame", self.options.with_libmp3lame),
opt_enable_disable("libfdk-aac", self.options.with_libfdk_aac),
opt_enable_disable("libwebp", self.options.with_libwebp),
opt_enable_disable("openssl", self.options.with_ssl == "openssl"),
opt_enable_disable("alsa", self.options.get_safe("with_libalsa")),
opt_enable_disable("libpulse",
self.options.get_safe("with_pulse")),
opt_enable_disable("vaapi", self.options.get_safe("with_vaapi")),
opt_enable_disable("vdpau", self.options.get_safe("with_vdpau")),
opt_enable_disable("libxcb", self.options.get_safe("with_xcb")),
opt_enable_disable("libxcb-shm",
self.options.get_safe("with_xcb")),
opt_enable_disable("libxcb-shape",
self.options.get_safe("with_xcb")),
opt_enable_disable("libxcb-xfixes",
self.options.get_safe("with_xcb")),
opt_enable_disable("appkit", self.options.get_safe("with_appkit")),
opt_enable_disable("avfoundation",
self.options.get_safe("with_avfoundation")),
opt_enable_disable("coreimage",
self.options.get_safe("with_coreimage")),
opt_enable_disable("audiotoolbox",
self.options.get_safe("with_audiotoolbox")),
opt_enable_disable("videotoolbox",
self.options.get_safe("with_videotoolbox")),
opt_enable_disable("securetransport",
self.options.with_ssl == "securetransport"),
"--disable-cuda", # FIXME: CUDA support
"--disable-cuvid", # FIXME: CUVID support
# Licenses
opt_enable_disable("nonfree", self.options.with_libfdk_aac),
opt_enable_disable(
"gpl", self.options.with_libx264 or self.options.with_libx265
or self.options.postproc)
]
args.append("--arch={}".format(self._target_arch))
if self.settings.build_type == "Debug":
args.extend([
"--disable-optimizations",
"--disable-mmx",
"--disable-stripping",
"--enable-debug",
])
# since ffmpeg"s build system ignores CC and CXX
if tools.get_env("AS"):
args.append("--as={}".format(tools.get_env("AS")))
if tools.get_env("CC"):
args.append("--cc={}".format(tools.get_env("CC")))
if tools.get_env("CXX"):
args.append("--cxx={}".format(tools.get_env("CXX")))
extra_cflags = []
extra_ldflags = []
if tools.is_apple_os(self.settings.os) and self.settings.os.version:
extra_cflags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
extra_ldflags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
if self.settings.compiler == "Visual Studio":
args.append("--pkg-config={}".format(tools.get_env("PKG_CONFIG")))
args.append("--toolchain=msvc")
if tools.Version(str(self.settings.compiler.version)) <= 12:
# Visual Studio 2013 (and earlier) doesn't support "inline" keyword for C (only for C++)
self._autotools.defines.append("inline=__inline")
if tools.cross_building(self):
args.append("--target-os={}".format(self._target_os))
if tools.is_apple_os(self.settings.os):
xcrun = tools.XCRun(self.settings)
apple_arch = tools.to_apple_arch(str(self.settings.arch))
extra_cflags.extend([
"-arch {}".format(apple_arch),
"-isysroot {}".format(xcrun.sdk_path)
])
extra_ldflags.extend([
"-arch {}".format(apple_arch),
"-isysroot {}".format(xcrun.sdk_path)
])
args.append("--extra-cflags={}".format(" ".join(extra_cflags)))
args.append("--extra-ldflags={}".format(" ".join(extra_ldflags)))
self._autotools.configure(args=args,
configure_dir=self._source_subfolder,
build=False,
host=False,
target=False)
return self._autotools
def _configure_cmd(self):
if self.settings.compiler in ('clang', 'apple-clang'):
botan_compiler = 'clang'
elif self.settings.compiler == 'gcc':
botan_compiler = 'gcc'
else:
botan_compiler = 'msvc'
botan_abi_flags = []
botan_extra_cxx_flags = []
build_flags = []
if self._is_linux_clang_libcxx:
botan_abi_flags.extend(["-stdlib=libc++", "-lc++abi"])
if botan_compiler in ['clang', 'apple-clang', 'gcc']:
if self.settings.arch == "x86":
botan_abi_flags.append('-m32')
elif self.settings.arch == "x86_64":
botan_abi_flags.append('-m64')
if self.settings.os != "Windows" and self.options.fPIC:
botan_extra_cxx_flags.append('-fPIC')
if self.settings.os == "Macos" and self.settings.os.version:
macos_min_version = tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version)
macos_sdk_path = "-isysroot {}".format(
tools.XCRun(self.settings).sdk_path)
botan_extra_cxx_flags.extend([macos_min_version, macos_sdk_path])
# This is to work around botan's configure script that *replaces* its
# standard (platform dependent) flags in presence of an environment
# variable ${CXXFLAGS}. Most notably, this would build botan with
# disabled compiler optimizations.
environment_cxxflags = tools.get_env("CXXFLAGS")
if environment_cxxflags:
del os.environ["CXXFLAGS"]
botan_extra_cxx_flags.append(environment_cxxflags)
if self.options.enable_modules:
build_flags.append('--minimized-build')
build_flags.append('--enable-modules={}'.format(
self.options.enable_modules))
if self.options.amalgamation:
build_flags.append('--amalgamation')
if self.options.single_amalgamation:
build_flags.append('--single-amalgamation-file')
if self.options.system_cert_bundle:
build_flags.append('--system-cert-bundle={}'.format(
self.options.system_cert_bundle))
if self.options.bzip2:
build_flags.append('--with-bzip2')
build_flags.extend(self._dependency_build_flags("bzip2"))
if self.options.openssl:
build_flags.append('--with-openssl')
build_flags.extend(self._dependency_build_flags("OpenSSL"))
if self.options.quiet:
build_flags.append('--quiet')
if self.options.sqlite3:
build_flags.append('--with-sqlite3')
build_flags.extend(self._dependency_build_flags("sqlite3"))
if self.options.zlib:
build_flags.append('--with-zlib')
build_flags.extend(self._dependency_build_flags("zlib"))
if self.options.boost:
build_flags.append('--with-boost')
build_flags.extend(self._dependency_build_flags("boost"))
# required boost libraries are listed in Botan's src/utils/boost/info.txt
# under the <libs></libs> tag...
# Note that boost_system is actually a header-only library as of
# boost 1.69. We are linking this for compatibility with older boost
# versions...
boost_system = [
lib for lib in self.deps_cpp_info["boost"].libs
if "boost_system" in lib
]
if len(boost_system) != 1:
raise ConanException(
"did not find a comprehensive boost_system library name: "
+ str(boost_system))
boost_system_name = boost_system[
0] + ".lib" if self.settings.os == "Windows" else boost_system[
0]
build_flags.append(
'--boost-library-name={}'.format(boost_system_name))
if self.settings.build_type == 'RelWithDebInfo' or self.options.debug_info:
build_flags.append('--with-debug-info')
if str(self.settings.build_type).lower() == 'debug':
build_flags.append('--debug-mode')
build_targets = ["shared"] if self.options.shared else ["static"]
if self._is_mingw_windows:
build_flags.append('--without-stack-protector')
if self.settings.compiler == 'Visual Studio':
build_flags.append('--msvc-runtime=%s' %
str(self.settings.compiler.runtime))
call_python = 'python' if self.settings.os == 'Windows' else ''
prefix = tools.unix_path(
self.package_folder
) if self._is_mingw_windows else self.package_folder
botan_abi = ' '.join(botan_abi_flags) if botan_abi_flags else ' '
botan_cxx_extras = ' '.join(
botan_extra_cxx_flags) if botan_extra_cxx_flags else ' '
configure_cmd = ('{python_call} ./configure.py'
' --build-targets={targets}'
' --distribution-info="Conan"'
' --without-documentation'
' --cc-abi-flags="{abi}"'
' --extra-cxxflags="{cxxflags}"'
' --cc={compiler}'
' --cpu={cpu}'
' --prefix={prefix}'
' --os={os}'
' {build_flags}').format(
python_call=call_python,
targets=",".join(build_targets),
abi=botan_abi,
cxxflags=botan_cxx_extras,
compiler=botan_compiler,
cpu=self.settings.arch,
prefix=prefix,
os=self._botan_os,
build_flags=' '.join(build_flags))
return configure_cmd
def _build_flags(self):
flags = self._build_cross_flags
# https://www.boost.org/doc/libs/1_70_0/libs/context/doc/html/context/architectures.html
if self._b2_os:
flags.append("target-os=%s" % self._b2_os)
if self._b2_architecture:
flags.append("architecture=%s" % self._b2_architecture)
if self._b2_address_model:
flags.append("address-model=%s" % self._b2_address_model)
if self._b2_binary_format:
flags.append("binary-format=%s" % self._b2_binary_format)
if self._b2_abi:
flags.append("abi=%s" % self._b2_abi)
if self.options.layout is not "b2-default":
flags.append("--layout=%s" % self.options.layout)
flags.append("--user-config=%s" %
os.path.join(self._boost_build_dir, 'user-config.jam'))
def add_defines(library):
for define in self.deps_cpp_info[library].defines:
flags.append("define=%s" % define)
if self._zip_bzip2_requires_needed:
add_defines('zlib')
add_defines('bzip2')
if self._is_msvc and self.settings.compiler.runtime:
flags.append('runtime-link=%s' % ('static' if 'MT' in str(
self.settings.compiler.runtime) else 'shared'))
# For details https://boostorg.github.io/build/manual/master/index.html
flags.append(
"threading=%s" %
("single" if not self.options.multithreading else "multi"))
flags.append("visibility=%s" % self.options.visibility)
flags.append("link=%s" %
("static" if not self.options.shared else "shared"))
if self.settings.build_type == "Debug":
flags.append("variant=debug")
else:
flags.append("variant=release")
for libname in LIB_LIST:
if getattr(self.options, "without_%s" % libname):
flags.append("--without-%s" % libname)
# flags.append("toolset=%s" % self._toolset)
# CXX FLAGS
cxx_flags = []
if self.settings.get_safe("compiler.cppstd"):
cxx_flags.append(cppstd_flag(self.settings))
if self.options.multithreading and self.settings.os == 'Emscripten':
# NOTE: I tried to compile boost for emscripten and failed. Here are some notes:
# - source/source_subfolder/tools/build/src/tools/emscripten.jam needs a patch to fix SEARCHED_LIBS error:
# import generators;
# generators.override emscripten.searched-lib-generator : searched-lib-generator ;
# - tests, coroutines and fibers components don't work
# - we have to build shared libraries otherwise log won't link
# cxx_flags.append('-pthread')
# cxx_flags.append('-fexceptions')
pass
# fPIC DEFINITION
if self.settings.os != "Windows":
if self.options.fPIC:
cxx_flags.append("-fPIC")
if self.settings.build_type == "RelWithDebInfo":
if self.settings.compiler == "gcc" or "clang" in str(
self.settings.compiler):
cxx_flags.append("-g")
elif self.settings.compiler == "Visual Studio":
cxx_flags.append("/Z7")
# Standalone toolchain fails when declare the std lib
if self.settings.os not in ["Android", "Emscripten"]:
try:
if self._gnu_cxx11_abi:
flags.append("define=_GLIBCXX_USE_CXX11_ABI=%s" %
self._gnu_cxx11_abi)
if "clang" in str(self.settings.compiler):
if str(self.settings.compiler.libcxx) == "libc++":
cxx_flags.append("-stdlib=libc++")
flags.append('linkflags="-stdlib=libc++"')
else:
cxx_flags.append("-stdlib=libstdc++")
except:
pass
if self.options.error_code_header_only:
flags.append("define=BOOST_ERROR_CODE_HEADER_ONLY=1")
if self.options.system_no_deprecated:
flags.append("define=BOOST_SYSTEM_NO_DEPRECATED=1")
if self.options.asio_no_deprecated:
flags.append("define=BOOST_ASIO_NO_DEPRECATED=1")
if self.options.filesystem_no_deprecated:
flags.append("define=BOOST_FILESYSTEM_NO_DEPRECATED=1")
if self.options.segmented_stacks:
flags.extend([
"segmented-stacks=on", "define=BOOST_USE_SEGMENTED_STACKS=1",
"define=BOOST_USE_UCONTEXT=1"
])
if tools.is_apple_os(self.settings.os):
if self.settings.get_safe("os.version"):
sdk = self.settings.get_safe('os.sdk')
subsystem = self.settings.get_safe('os.subsystem')
cxx_flags.append(
tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version, sdk,
subsystem, self.settings.arch))
if self.settings.os == "iOS":
# One of the *_USE_PTHREADS flags causes iOS applications to crash when using boost::log
# if self.options.multithreading:
# cxx_flags.append("-DBOOST_AC_USE_PTHREADS")
# cxx_flags.append("-DBOOST_SP_USE_PTHREADS")
# Bitcode flag will be added automatically in darwin-toolchain
# cxx_flags.append("-fembed-bitcode")
pass
cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else ""
flags.append(cxx_flags)
if self.options.extra_b2_flags:
flags.append(str(self.options.extra_b2_flags))
flags.extend([
"install",
"--prefix=%s" % self.package_folder,
"-j%s" % tools.cpu_count(), "--abbreviate-paths"
])
if self.options.debug_level:
flags.append("-d%d" % self.options.debug_level)
return flags
def build(self):
for filename in glob.glob("patches/*.patch"):
self.output.info('applying patch "%s"' % filename)
tools.patch(base_path=self._source_subfolder, patch_file=filename)
if self._is_msvc:
run_configure_icu_file = os.path.join(self._source_subfolder, 'source', 'runConfigureICU')
flags = "-%s" % self.settings.compiler.runtime
if self.settings.get_safe("build_type") == 'Debug':
flags += " -FS"
tools.replace_in_file(run_configure_icu_file, "-MDd", flags)
tools.replace_in_file(run_configure_icu_file, "-MD", flags)
# self._replace_pythonpath() # ICU 64.1
# self._workaround_icu_20545()
# self.output.info('******************************************************************')
# conans.client.build.compiler_flags.libcxx_define = libcxx_define_replacement
# self.output.info('******************************************************************')
self._env_build = KnuthAutoToolsBuildEnvironment(self)
# self.output.info('******************************************************************')
# conans.client.build.compiler_flags.libcxx_define = libcxx_define_replacement
# self.output.info('******************************************************************')
# self.output.info(self.settings.compiler)
# self.output.info(self.settings.compiler.libcxx)
# abif = conans.client.build.compiler_flags.libcxx_define(self.settings.compiler, self.settings.compiler.libcxx)
# self.output.info('------------------------------------------------------------------')
# self.output.info(abif)
self.output.info('------------------------------------------------------------------')
self.output.info(self._env_build.cxx_flags)
self.output.info('------------------------------------------------------------------')
# if self.options.get_safe("glibcxx_supports_cxx11_abi"):
# self.output.info(self.options.glibcxx_supports_cxx11_abi)
# if self.options.glibcxx_supports_cxx11_abi:
# # self._env_build.cxx_flags.append('-D_GLIBCXX_USE_CXX11_ABI=1')
# self._env_build.cxx_flags.insert(0, '-D_GLIBCXX_USE_CXX11_ABI=1')
# else:
# # self._env_build.cxx_flags.append('-D_GLIBCXX_USE_CXX11_ABI=0')
# self._env_build.cxx_flags.insert(0, '-D_GLIBCXX_USE_CXX11_ABI=0')
# # if float(str(self.settings.compiler.version)) >= 5:
# # cxx11_abi_str = '-D_GLIBCXX_USE_CXX11_ABI=1'
# # else:
# # cxx11_abi_str = '-D_GLIBCXX_USE_CXX11_ABI=0'
# self.output.info('------------------------------------------------------------------')
# self.output.info(self._env_build.cxx_flags)
# self.output.info('------------------------------------------------------------------')
if not self.options.get_safe("shared"):
self._env_build.defines.append("U_STATIC_IMPLEMENTATION")
if tools.is_apple_os(self._the_os):
self._env_build.defines.append("_DARWIN_C_SOURCE")
if self.settings.get_safe("os.version"):
self._env_build.flags.append(tools.apple_deployment_target_flag(self._the_os,
self.settings.os.version))
build_dir = os.path.join(self.build_folder, self._source_subfolder, 'build')
os.mkdir(build_dir)
with tools.vcvars(self.settings) if self._is_msvc else tools.no_op():
with tools.environment_append(self._env_build.vars):
with tools.chdir(build_dir):
# workaround for https://unicode-org.atlassian.net/browse/ICU-20531
os.makedirs(os.path.join("data", "out", "tmp"))
self.run(self._build_config_cmd, win_bash=tools.os_info.is_windows)
if self._silent:
silent = '--silent' if self._silent else 'VERBOSE=1'
else:
silent = '--silent'
command = "make {silent} -j {cpu_count}".format(silent=silent,
cpu_count=tools.cpu_count())
self.run(command, win_bash=tools.os_info.is_windows)
if self.options.get_safe("tests"):
command = "make {silent} check".format(silent=silent)
self.run(command, win_bash=tools.os_info.is_windows)
command = "make {silent} install".format(silent=silent)
self.run(command, win_bash=tools.os_info.is_windows)
self._install_name_tool()
self.output.info('------------------------------------------------------------------')
self.output.info(self._env_build.cxx_flags)
self.output.info('------------------------------------------------------------------')
def _configure_cmd(self):
if self.settings.compiler in ('clang', 'apple-clang'):
botan_compiler = 'clang'
elif self.settings.compiler == 'gcc':
botan_compiler = 'gcc'
else:
botan_compiler = 'msvc'
botan_abi_flags = []
botan_extra_cxx_flags = []
build_flags = []
if self._is_linux_clang_libcxx:
botan_abi_flags.extend(['-stdlib=libc++', '-lc++abi'])
if botan_compiler in ['clang', 'apple-clang', 'gcc']:
if self.settings.arch == 'x86':
botan_abi_flags.append('-m32')
elif self.settings.arch == 'x86_64':
botan_abi_flags.append('-m64')
if self.options.get_safe('fPIC', True):
botan_extra_cxx_flags.append('-fPIC')
if tools.is_apple_os(self.settings.os):
if self.settings.get_safe('os.version'):
# Required, see https://github.com/conan-io/conan-center-index/pull/3456
macos_min_version = tools.apple_deployment_target_flag(
self.settings.os, self.settings.get_safe('os.version'),
self.settings.get_safe('os.sdk'),
self.settings.get_safe('os.subsystem'),
self.settings.get_safe('arch'))
botan_extra_cxx_flags.append(macos_min_version)
macos_sdk_path = '-isysroot {}'.format(
tools.XCRun(self.settings).sdk_path)
botan_extra_cxx_flags.append(macos_sdk_path)
# This is to work around botan's configure script that *replaces* its
# standard (platform dependent) flags in presence of an environment
# variable ${CXXFLAGS}. Most notably, this would build botan with
# disabled compiler optimizations.
environment_cxxflags = tools.get_env('CXXFLAGS')
if environment_cxxflags:
del os.environ['CXXFLAGS']
botan_extra_cxx_flags.append(environment_cxxflags)
if self.options.enable_modules:
build_flags.append('--minimized-build')
build_flags.append('--enable-modules={}'.format(
self.options.enable_modules))
if self.options.amalgamation:
build_flags.append('--amalgamation')
if self.options.get_safe('single_amalgamation'):
build_flags.append('--single-amalgamation-file')
if self.options.system_cert_bundle:
build_flags.append('--system-cert-bundle={}'.format(
self.options.system_cert_bundle))
if self.options.with_bzip2:
build_flags.append('--with-bzip2')
build_flags.extend(self._dependency_build_flags('bzip2'))
if self.options.with_openssl:
build_flags.append('--with-openssl')
build_flags.extend(self._dependency_build_flags('openssl'))
if self.options.with_sqlite3:
build_flags.append('--with-sqlite3')
build_flags.extend(self._dependency_build_flags('sqlite3'))
if self.options.with_zlib:
build_flags.append('--with-zlib')
build_flags.extend(self._dependency_build_flags('zlib'))
if self.options.with_boost:
build_flags.append('--with-boost')
build_flags.extend(self._dependency_build_flags('boost'))
if self.options.module_policy:
build_flags.append('--module-policy={}'.format(
self.options.module_policy))
if self.settings.build_type == 'RelWithDebInfo':
build_flags.append('--with-debug-info')
if self._is_x86:
if not self.options.with_sse2:
build_flags.append('--disable-sse2')
if not self.options.with_ssse3:
build_flags.append('--disable-ssse3')
if not self.options.with_sse4_1:
build_flags.append('--disable-sse4.1')
if not self.options.with_sse4_2:
build_flags.append('--disable-sse4.2')
if not self.options.with_avx2:
build_flags.append('--disable-avx2')
if not self.options.with_bmi2:
build_flags.append('--disable-bmi2')
if not self.options.with_rdrand:
build_flags.append('--disable-rdrand')
if not self.options.with_rdseed:
build_flags.append('--disable-rdseed')
if not self.options.with_aes_ni:
build_flags.append('--disable-aes-ni')
if not self.options.with_sha_ni:
build_flags.append('--disable-sha-ni')
if self._is_ppc:
if not self.options.with_powercrypto:
build_flags.append('--disable-powercrypto')
if not self.options.with_altivec:
build_flags.append('--disable-altivec')
if self._is_arm:
if not self.options.with_neon:
build_flags.append('--disable-neon')
if not self.options.with_armv8crypto:
build_flags.append('--disable-armv8crypto')
if str(self.settings.build_type).lower() == 'debug':
build_flags.append('--debug-mode')
build_targets = ['shared'] if self.options.shared else ['static']
if self._is_mingw_windows:
build_flags.append('--without-stack-protector')
if self.settings.compiler == 'Visual Studio':
build_flags.append('--msvc-runtime=%s' %
str(self.settings.compiler.runtime))
build_flags.append('--without-pkg-config')
call_python = 'python' if self.settings.os == 'Windows' else ''
prefix = tools.unix_path(
self.package_folder
) if self._is_mingw_windows else self.package_folder
botan_abi = ' '.join(botan_abi_flags) if botan_abi_flags else ' '
botan_cxx_extras = ' '.join(
botan_extra_cxx_flags) if botan_extra_cxx_flags else ' '
configure_cmd = ('{python_call} ./configure.py'
' --build-targets={targets}'
' --distribution-info="Conan"'
' --without-documentation'
' --cc-abi-flags="{abi}"'
' --extra-cxxflags="{cxxflags}"'
' --cc={compiler}'
' --cpu={cpu}'
' --prefix={prefix}'
' --os={os}'
' {build_flags}').format(
python_call=call_python,
targets=','.join(build_targets),
abi=botan_abi,
cxxflags=botan_cxx_extras,
compiler=botan_compiler,
cpu=self.settings.arch,
prefix=prefix,
os=self._botan_os,
build_flags=' '.join(build_flags))
return configure_cmd
def _configure_autotools(self):
if self._autotools:
return self._autotools
self._autotools = AutoToolsBuildEnvironment(
self, win_bash=tools.os_info.is_windows)
self._autotools.libs = []
def opt_enable_disable(what, v):
return "--{}-{}".format("enable" if v else "disable", what)
def opt_append_disable_if_set(args, what, v):
if v:
args.append("--disable-{}".format(what))
args = [
"--pkg-config-flags=--static",
"--disable-doc",
opt_enable_disable("cross-compile", tools.cross_building(self)),
opt_enable_disable("asm", self.options.with_asm),
# Libraries
opt_enable_disable("shared", self.options.shared),
opt_enable_disable("static", not self.options.shared),
opt_enable_disable("pic", self.options.get_safe("fPIC", True)),
# Components
opt_enable_disable("avdevice", self.options.avdevice),
opt_enable_disable("avcodec", self.options.avcodec),
opt_enable_disable("avformat", self.options.avformat),
opt_enable_disable("swresample", self.options.swresample),
opt_enable_disable("swscale", self.options.swscale),
opt_enable_disable("postproc", self.options.postproc),
opt_enable_disable("avfilter", self.options.avfilter),
# Dependencies
opt_enable_disable("bzlib", self.options.with_bzip2),
opt_enable_disable("zlib", self.options.with_zlib),
opt_enable_disable("lzma", self.options.with_lzma),
opt_enable_disable("iconv", self.options.with_libiconv),
opt_enable_disable("libopenjpeg", self.options.with_openjpeg),
opt_enable_disable("libopenh264", self.options.with_openh264),
opt_enable_disable("libvorbis", self.options.with_vorbis),
opt_enable_disable("libopus", self.options.with_opus),
opt_enable_disable("libzmq", self.options.with_zeromq),
opt_enable_disable("sdl2", self.options.with_sdl),
opt_enable_disable("libx264", self.options.with_libx264),
opt_enable_disable("libx265", self.options.with_libx265),
opt_enable_disable("libvpx", self.options.with_libvpx),
opt_enable_disable("libmp3lame", self.options.with_libmp3lame),
opt_enable_disable("libfdk-aac", self.options.with_libfdk_aac),
opt_enable_disable("libwebp", self.options.with_libwebp),
opt_enable_disable("openssl", self.options.with_ssl == "openssl"),
opt_enable_disable("alsa", self.options.get_safe("with_libalsa")),
opt_enable_disable("libpulse",
self.options.get_safe("with_pulse")),
opt_enable_disable("vaapi", self.options.get_safe("with_vaapi")),
opt_enable_disable("vdpau", self.options.get_safe("with_vdpau")),
opt_enable_disable("libxcb", self.options.get_safe("with_xcb")),
opt_enable_disable("libxcb-shm",
self.options.get_safe("with_xcb")),
opt_enable_disable("libxcb-shape",
self.options.get_safe("with_xcb")),
opt_enable_disable("libxcb-xfixes",
self.options.get_safe("with_xcb")),
opt_enable_disable("appkit", self.options.get_safe("with_appkit")),
opt_enable_disable("avfoundation",
self.options.get_safe("with_avfoundation")),
opt_enable_disable("coreimage",
self.options.get_safe("with_coreimage")),
opt_enable_disable("audiotoolbox",
self.options.get_safe("with_audiotoolbox")),
opt_enable_disable("videotoolbox",
self.options.get_safe("with_videotoolbox")),
opt_enable_disable("securetransport",
self.options.with_ssl == "securetransport"),
"--disable-cuda", # FIXME: CUDA support
"--disable-cuvid", # FIXME: CUVID support
# Licenses
opt_enable_disable(
"nonfree", self.options.with_libfdk_aac
or (self.options.with_ssl and
(self.options.with_libx264 or self.options.with_libx265
or self.options.postproc))),
opt_enable_disable(
"gpl", self.options.with_libx264 or self.options.with_libx265
or self.options.postproc)
]
# Individual Component Options
opt_append_disable_if_set(args, "everything",
self.options.disable_everything)
opt_append_disable_if_set(args, "encoders",
self.options.disable_all_encoders)
opt_append_disable_if_set(args, "decoders",
self.options.disable_all_decoders)
opt_append_disable_if_set(
args, "hwaccels", self.options.disable_all_hardware_accelerators)
opt_append_disable_if_set(args, "muxers",
self.options.disable_all_muxers)
opt_append_disable_if_set(args, "demuxers",
self.options.disable_all_demuxers)
opt_append_disable_if_set(args, "parsers",
self.options.disable_all_parsers)
opt_append_disable_if_set(args, "bsfs",
self.options.disable_all_bitstream_filters)
opt_append_disable_if_set(args, "protocols",
self.options.disable_all_protocols)
opt_append_disable_if_set(args, "devices",
self.options.disable_all_devices)
opt_append_disable_if_set(args, "indevs",
self.options.disable_all_input_devices)
opt_append_disable_if_set(args, "outdevs",
self.options.disable_all_output_devices)
opt_append_disable_if_set(args, "filters",
self.options.disable_all_filters)
args.extend(
self._split_and_format_options_string(
"enable-encoder", self.options.enable_encoders))
args.extend(
self._split_and_format_options_string(
"disable-encoder", self.options.disable_encoders))
args.extend(
self._split_and_format_options_string(
"enable-decoder", self.options.enable_decoders))
args.extend(
self._split_and_format_options_string(
"disable-decoder", self.options.disable_decoders))
args.extend(
self._split_and_format_options_string(
"enable-hwaccel", self.options.enable_hardware_accelerators))
args.extend(
self._split_and_format_options_string(
"disable-hwaccel", self.options.disable_hardware_accelerators))
args.extend(
self._split_and_format_options_string("enable-muxer",
self.options.enable_muxers))
args.extend(
self._split_and_format_options_string("disable-muxer",
self.options.disable_muxers))
args.extend(
self._split_and_format_options_string(
"enable-demuxer", self.options.enable_demuxers))
args.extend(
self._split_and_format_options_string(
"disable-demuxer", self.options.disable_demuxers))
args.extend(
self._split_and_format_options_string("enable-parser",
self.options.enable_parsers))
args.extend(
self._split_and_format_options_string(
"disable-parser", self.options.disable_parsers))
args.extend(
self._split_and_format_options_string(
"enable-bsf", self.options.enable_bitstream_filters))
args.extend(
self._split_and_format_options_string(
"disable-bsf", self.options.disable_bitstream_filters))
args.extend(
self._split_and_format_options_string(
"enable-protocol", self.options.enable_protocols))
args.extend(
self._split_and_format_options_string(
"disable-protocol", self.options.disable_protocols))
args.extend(
self._split_and_format_options_string(
"enable-indev", self.options.enable_input_devices))
args.extend(
self._split_and_format_options_string(
"disable-indev", self.options.disable_input_devices))
args.extend(
self._split_and_format_options_string(
"enable-outdev", self.options.enable_output_devices))
args.extend(
self._split_and_format_options_string(
"disable-outdev", self.options.disable_output_devices))
args.extend(
self._split_and_format_options_string("enable-filter",
self.options.enable_filters))
args.extend(
self._split_and_format_options_string(
"disable-filter", self.options.disable_filters))
if self._version_supports_vulkan():
args.append(
opt_enable_disable("vulkan",
self.options.get_safe("with_vulkan")))
if tools.is_apple_os(self.settings.os):
# relocatable shared libs
args.append("--install-name-dir=@rpath")
args.append("--arch={}".format(self._target_arch))
if self.settings.build_type == "Debug":
args.extend([
"--disable-optimizations",
"--disable-mmx",
"--disable-stripping",
"--enable-debug",
])
if not self.options.with_programs:
args.append("--disable-programs")
# since ffmpeg"s build system ignores CC and CXX
if tools.get_env("AS"):
args.append("--as={}".format(tools.get_env("AS")))
if tools.get_env("CC"):
args.append("--cc={}".format(tools.get_env("CC")))
if tools.get_env("CXX"):
args.append("--cxx={}".format(tools.get_env("CXX")))
extra_cflags = []
extra_ldflags = []
if tools.is_apple_os(self.settings.os) and self.settings.os.version:
extra_cflags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
extra_ldflags.append(
tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
if self._is_msvc:
args.append("--pkg-config={}".format(tools.get_env("PKG_CONFIG")))
args.append("--toolchain=msvc")
if self.settings.compiler == "Visual Studio" and tools.Version(
self.settings.compiler.version) <= "12":
# Visual Studio 2013 (and earlier) doesn't support "inline" keyword for C (only for C++)
self._autotools.defines.append("inline=__inline")
if tools.cross_building(self):
if self._target_os == "emscripten":
args.append("--target-os=none")
else:
args.append("--target-os={}".format(self._target_os))
if tools.is_apple_os(self.settings.os):
xcrun = tools.XCRun(self.settings)
apple_arch = tools.to_apple_arch(str(self.settings.arch))
extra_cflags.extend([
"-arch {}".format(apple_arch),
"-isysroot {}".format(xcrun.sdk_path)
])
extra_ldflags.extend([
"-arch {}".format(apple_arch),
"-isysroot {}".format(xcrun.sdk_path)
])
args.append("--extra-cflags={}".format(" ".join(extra_cflags)))
args.append("--extra-ldflags={}".format(" ".join(extra_ldflags)))
self._autotools.configure(args=args,
configure_dir=self._source_subfolder,
build=False,
host=False,
target=False)
return self._autotools
def get_build_flags(self):
if tools.cross_building(self.settings):
flags = self.get_build_cross_flags()
else:
flags = []
# https://www.boost.org/doc/libs/1_69_0/libs/context/doc/html/context/architectures.html
if self._b2_os:
flags.append("target-os=%s" % self._b2_os)
if self._b2_architecture:
flags.append("architecture=%s" % self._b2_architecture)
if self._b2_address_model:
flags.append("address-model=%s" % self._b2_address_model)
if self._b2_binary_format:
flags.append("binary-format=%s" % self._b2_binary_format)
if self._b2_abi:
flags.append("abi=%s" % self._b2_abi)
flags.append("-sBOOST_BUILD_PATH=%s" % self._boost_build_dir)
if self.settings.compiler == "gcc":
flags.append("--layout=system")
if self._is_msvc and self.settings.compiler.runtime:
flags.append("runtime-link=%s" % ("static" if "MT" in str(
self.settings.compiler.runtime) else "shared"))
flags.append("threading=multi")
flags.append("link=%s" %
("static" if not self.options.shared else "shared"))
if self.settings.build_type == "Debug":
flags.append("variant=debug")
else:
flags.append("variant=release")
for libname in lib_list:
if getattr(self.options, "without_%s" % libname):
flags.append("--without-%s" % libname)
toolset, _, _ = self.get_toolset_version_and_exe()
flags.append("toolset=%s" % toolset)
if self.settings.cppstd:
flags.append(
"cxxflags=%s" %
cppstd_flag(self.settings.get_safe("compiler"),
self.settings.get_safe("compiler.version"),
self.settings.get_safe("cppstd")))
# CXX FLAGS
cxx_flags = []
# fPIC DEFINITION
if self.settings.os != "Windows":
if self.options.fPIC:
cxx_flags.append("-fPIC")
# Standalone toolchain fails when declare the std lib
if self.settings.os != "Android":
try:
if str(self.settings.compiler.libcxx) == "libstdc++":
flags.append("define=_GLIBCXX_USE_CXX11_ABI=0")
elif str(self.settings.compiler.libcxx) == "libstdc++11":
flags.append("define=_GLIBCXX_USE_CXX11_ABI=1")
if "clang" in str(self.settings.compiler):
if str(self.settings.compiler.libcxx) == "libc++":
cxx_flags.append("-stdlib=libc++")
flags.append('linkflags="-stdlib=libc++"')
else:
cxx_flags.append("-stdlib=libstdc++")
except:
pass
if self.options.error_code_header_only:
flags.append("define=BOOST_ERROR_CODE_HEADER_ONLY=1")
if self.options.system_no_deprecated:
flags.append("define=BOOST_SYSTEM_NO_DEPRECATED=1")
if self.options.asio_no_deprecated:
flags.append("define=BOOST_ASIO_NO_DEPRECATED=1")
if tools.is_apple_os(self.settings.os):
if self.settings.get_safe("os.version"):
cxx_flags.append(
tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version))
if self.settings.os == "iOS":
cxx_flags.append("-DBOOST_AC_USE_PTHREADS")
cxx_flags.append("-DBOOST_SP_USE_PTHREADS")
cxx_flags.append("-fvisibility=hidden")
cxx_flags.append("-fvisibility-inlines-hidden")
cxx_flags.append("-fembed-bitcode")
cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else ""
flags.append(cxx_flags)
return flags
def _build_zlib(self):
with tools.chdir(self._source_subfolder):
for filename in ['zconf.h', 'zconf.h.cmakein', 'zconf.h.in']:
tools.replace_in_file(
filename,
'#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */',
'#if defined(HAVE_UNISTD_H) && (1-HAVE_UNISTD_H-1 != 0)')
tools.replace_in_file(
filename,
'#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */',
'#if defined(HAVE_STDARG_H) && (1-HAVE_STDARG_H-1 != 0)')
tools.mkdir("_build")
with tools.chdir("_build"):
if not tools.os_info.is_windows:
env_build = AutoToolsBuildEnvironment(self)
if tools.is_apple_os(
self.settings.os) and self.settings.get_safe(
"os.version"):
env_build.flags.append(
tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version))
if self.settings.os == "Macos":
old_str = '-install_name $libdir/$SHAREDLIBM'
new_str = '-install_name $SHAREDLIBM'
tools.replace_in_file("../configure", old_str, new_str)
# https://github.com/madler/zlib/issues/268
tools.replace_in_file(
'../gzguts.h',
'#if defined(_WIN32) || defined(__CYGWIN__)',
'#if defined(_WIN32) || defined(__MINGW32__)')
if self.settings.os == "Windows": # Cross building to Linux
tools.replace_in_file(
"../configure",
'LDSHAREDLIBC="${LDSHAREDLIBC--lc}"',
'LDSHAREDLIBC=""')
# Zlib configure doesnt allow this parameters
if self.settings.os == "iOS":
tools.replace_in_file(
"../gzguts.h", '#ifdef _LARGEFILE64_SOURCE',
'#include <unistd.h>\n\n#ifdef _LARGEFILE64_SOURCE'
)
# configure passes CFLAGS to linker, should be LDFLAGS
tools.replace_in_file("../configure", "$LDSHARED $SFLAGS",
"$LDSHARED $LDFLAGS")
# same thing in Makefile.in, when building tests/example executables
tools.replace_in_file("../Makefile.in",
"$(CC) $(CFLAGS) -o",
"$(CC) $(LDFLAGS) -o")
env_build_vars = env_build.vars
if tools.is_apple_os(self.settings.os):
# force macOS ranlib because ranlib from binutils produced malformed ar archives
env_build_vars['RANLIB'] = tools.XCRun(
self.settings).ranlib
if self.settings.os == "Windows" and tools.os_info.is_linux:
# we need to build only libraries without test example and minigzip
if self.options.shared:
make_target = "zlib1.dll"
else:
make_target = "libz.a"
# Let our profile to declare what is needed.
tools.replace_in_file("../win32/Makefile.gcc",
'LDFLAGS = $(LOC)', '')
tools.replace_in_file("../win32/Makefile.gcc",
'AS = $(CC)', '')
tools.replace_in_file("../win32/Makefile.gcc",
'AR = $(PREFIX)ar', '')
tools.replace_in_file("../win32/Makefile.gcc",
'CC = $(PREFIX)gcc', '')
tools.replace_in_file("../win32/Makefile.gcc",
'RC = $(PREFIX)windres', '')
self.run("cd .. && make -f win32/Makefile.gcc %s" %
make_target)
else:
# we need to build only libraries without test example and minigzip
if self.options.shared:
if self.settings.os == "Macos":
make_target = "libz.%s.dylib" % self.version
else:
make_target = "libz.so.%s" % self.version
else:
make_target = "libz.a"
env_build.configure("../",
build=False,
host=False,
target=False,
vars=env_build_vars)
env_build.make(target=make_target)
else:
cmake = CMake(self)
cmake.configure(build_dir=".")
# we need to build only libraries without test example/example64 and minigzip/minigzip64
if self.options.shared:
make_target = "zlib"
else:
make_target = "zlibstatic"
cmake.build(build_dir=".", target=make_target)
def get_build_flags(self):
if tools.cross_building(self.settings):
flags = self.get_build_cross_flags()
else:
flags = []
# https://www.boost.org/doc/libs/1_70_0/libs/context/doc/html/context/architectures.html
if self._b2_os:
flags.append("target-os=%s" % self._b2_os)
if self._b2_architecture:
flags.append("architecture=%s" % self._b2_architecture)
if self._b2_address_model:
flags.append("address-model=%s" % self._b2_address_model)
if self._b2_binary_format:
flags.append("binary-format=%s" % self._b2_binary_format)
if self._b2_abi:
flags.append("abi=%s" % self._b2_abi)
flags.append("--layout=%s" % self.options.layout)
flags.append("-sBOOST_BUILD_PATH=%s" % self._boost_build_dir)
flags.append("-sNO_ZLIB=%s" % ("0" if self.options.zlib else "1"))
flags.append("-sNO_BZIP2=%s" % ("0" if self.options.bzip2 else "1"))
flags.append("-sNO_LZMA=%s" % ("0" if self.options.lzma else "1"))
flags.append("-sNO_ZSTD=%s" % ("0" if self.options.zstd else "1"))
def add_defines(option, library):
if option:
for define in self.deps_cpp_info[library].defines:
flags.append("define=%s" % define)
if self.zip_bzip2_requires_needed:
add_defines(self.options.zlib, "zlib")
add_defines(self.options.bzip2, "bzip2")
add_defines(self.options.lzma, "lzma")
add_defines(self.options.zstd, "zstd")
if self._is_msvc and self.settings.compiler.runtime:
flags.append("runtime-link=%s" % ("static" if "MT" in str(self.settings.compiler.runtime) else "shared"))
flags.append("threading=multi")
flags.append("link=%s" % ("static" if not self.options.shared else "shared"))
if self.settings.build_type == "Debug":
flags.append("variant=debug")
else:
flags.append("variant=release")
for libname in lib_list:
if getattr(self.options, "without_%s" % libname):
flags.append("--without-%s" % libname)
toolset, _, _ = self.get_toolset_version_and_exe()
flags.append("toolset=%s" % toolset)
if self.settings.get_safe("compiler.cppstd"):
flags.append("cxxflags=%s" % cppstd_flag(
self.settings.get_safe("compiler"),
self.settings.get_safe("compiler.version"),
self.settings.get_safe("compiler.cppstd")
)
)
# CXX FLAGS
cxx_flags = []
# fPIC DEFINITION
if self.settings.os != "Windows":
if self.options.fPIC:
cxx_flags.append("-fPIC")
# Standalone toolchain fails when declare the std lib
if self.settings.os != "Android":
try:
if self._gnu_cxx11_abi:
flags.append("define=_GLIBCXX_USE_CXX11_ABI=%s" % self._gnu_cxx11_abi)
if "clang" in str(self.settings.compiler):
if str(self.settings.compiler.libcxx) == "libc++":
cxx_flags.append("-stdlib=libc++")
flags.append('linkflags="-stdlib=libc++"')
else:
cxx_flags.append("-stdlib=libstdc++")
except:
pass
if self.options.error_code_header_only:
flags.append("define=BOOST_ERROR_CODE_HEADER_ONLY=1")
if self.options.system_no_deprecated:
flags.append("define=BOOST_SYSTEM_NO_DEPRECATED=1")
if self.options.asio_no_deprecated:
flags.append("define=BOOST_ASIO_NO_DEPRECATED=1")
if self.options.filesystem_no_deprecated:
flags.append("define=BOOST_FILESYSTEM_NO_DEPRECATED=1")
if self.options.segmented_stacks:
flags.extend(["segmented-stacks=on",
"define=BOOST_USE_SEGMENTED_STACKS=1",
"define=BOOST_USE_UCONTEXT=1"])
if tools.is_apple_os(self.settings.os):
if self.settings.get_safe("os.version"):
cxx_flags.append(tools.apple_deployment_target_flag(self.settings.os,
self.settings.os.version))
if self.settings.os == "iOS":
cxx_flags.append("-DBOOST_AC_USE_PTHREADS")
cxx_flags.append("-DBOOST_SP_USE_PTHREADS")
cxx_flags.append("-fvisibility=hidden")
cxx_flags.append("-fvisibility-inlines-hidden")
cxx_flags.append("-fembed-bitcode")
cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else ""
flags.append(cxx_flags)
if self.options.extra_b2_flags:
flags.append(str(self.options.extra_b2_flags))
return flags
def _configure_cmd(self):
if self.settings.compiler in ('clang', 'apple-clang'):
botan_compiler = 'clang'
elif self.settings.compiler == 'gcc':
botan_compiler = 'gcc'
else:
botan_compiler = 'msvc'
botan_abi_flags = []
botan_extra_cxx_flags = []
build_flags = []
if self._is_linux_clang_libcxx:
botan_abi_flags.extend(["-stdlib=libc++", "-lc++abi"])
if botan_compiler in ['clang', 'apple-clang', 'gcc']:
if self.settings.arch == "x86":
botan_abi_flags.append('-m32')
elif self.settings.arch == "x86_64":
botan_abi_flags.append('-m64')
if self.settings.os != "Windows" and self.options.fPIC:
botan_extra_cxx_flags.append('-fPIC')
if self.settings.os == "Macos" and self.settings.os.version:
macos_min_version = tools.apple_deployment_target_flag(
self.settings.os, self.settings.os.version)
macos_sdk_path = "-isysroot {}".format(
tools.XCRun(self.settings).sdk_path)
botan_extra_cxx_flags.extend([macos_min_version, macos_sdk_path])
# This is to work around botan's configure script that *replaces* its
# standard (platform dependent) flags in presence of an environment
# variable ${CXXFLAGS}. Most notably, this would build botan with
# disabled compiler optimizations.
environment_cxxflags = tools.get_env("CXXFLAGS")
if environment_cxxflags:
del os.environ["CXXFLAGS"]
botan_extra_cxx_flags.append(environment_cxxflags)
if self.options.enable_modules:
build_flags.append('--minimized-build')
build_flags.append('--enable-modules={}'.format(
self.options.enable_modules))
if self.options.amalgamation:
build_flags.append('--amalgamation')
if self.options.single_amalgamation:
build_flags.append('--single-amalgamation-file')
if self.options.system_cert_bundle:
build_flags.append('--system-cert-bundle={}'.format(
self.options.system_cert_bundle))
if self.options.with_bzip2:
build_flags.append('--with-bzip2')
build_flags.extend(self._dependency_build_flags("bzip2"))
if self.options.with_openssl:
build_flags.append('--with-openssl')
build_flags.extend(self._dependency_build_flags("OpenSSL"))
if self.options.with_sqlite3:
build_flags.append('--with-sqlite3')
build_flags.extend(self._dependency_build_flags("sqlite3"))
if self.options.with_zlib:
build_flags.append('--with-zlib')
build_flags.extend(self._dependency_build_flags("zlib"))
if self.options.with_boost:
build_flags.append('--with-boost')
build_flags.extend(self._dependency_build_flags("boost"))
if self.settings.build_type == 'RelWithDebInfo':
build_flags.append('--with-debug-info')
if str(self.settings.build_type).lower() == 'debug':
build_flags.append('--debug-mode')
build_targets = ["shared"] if self.options.shared else ["static"]
if self._is_mingw_windows:
build_flags.append('--without-stack-protector')
if self.settings.compiler == 'Visual Studio':
build_flags.append('--msvc-runtime=%s' %
str(self.settings.compiler.runtime))
build_flags.append('--without-pkg-config')
call_python = 'python' if self.settings.os == 'Windows' else ''
prefix = tools.unix_path(
self.package_folder
) if self._is_mingw_windows else self.package_folder
botan_abi = ' '.join(botan_abi_flags) if botan_abi_flags else ' '
botan_cxx_extras = ' '.join(
botan_extra_cxx_flags) if botan_extra_cxx_flags else ' '
configure_cmd = ('{python_call} ./configure.py'
' --build-targets={targets}'
' --distribution-info="Conan"'
' --without-documentation'
' --cc-abi-flags="{abi}"'
' --extra-cxxflags="{cxxflags}"'
' --cc={compiler}'
' --cpu={cpu}'
' --prefix={prefix}'
' --os={os}'
' {build_flags}').format(
python_call=call_python,
targets=",".join(build_targets),
abi=botan_abi,
cxxflags=botan_cxx_extras,
compiler=botan_compiler,
cpu=self.settings.arch,
prefix=prefix,
os=self._botan_os,
build_flags=' '.join(build_flags))
return configure_cmd