def build(self):
with tools.vcvars(self.settings) if self._use_nmake else tools.no_op():
env_vars = {"PERL": self._perl}
if self._full_version < "1.1.0":
cflags = " ".join(self._get_env_build().vars_dict["CFLAGS"])
env_vars["CC"] = "%s %s" % (self._cc, cflags)
if self.settings.compiler == "apple-clang":
xcrun = tools.XCRun(self.settings)
env_vars["CROSS_SDK"] = os.path.basename(xcrun.sdk_path)
env_vars["CROSS_TOP"] = os.path.dirname(
os.path.dirname(xcrun.sdk_path))
with tools.environment_append(env_vars):
if self._full_version >= "1.1.0":
if self.settings.os in ["tvOS", "watchOS"]:
tools.patch(patch_file=os.path.join(
"patches", "1.1.1-tvos-watchos.patch"),
base_path=self._source_subfolder)
self._create_targets()
else:
if self.settings.os == "Macos":
tools.patch(patch_file=os.path.join(
"patches", "1.0.2u-darwin-arm64.patch"),
base_path=self._source_subfolder)
self._patch_configure()
self._patch_makefile_org()
with self._make_context():
self._make()
def get_toolset_version_and_exe(self):
compiler_version = str(self.settings.compiler.version)
compiler = str(self.settings.compiler)
if self.settings.compiler == "Visual Studio":
cversion = self.settings.compiler.version
_msvc_version = "14.1" if cversion == "15" else "%s.0" % cversion
return "msvc", _msvc_version, ""
elif compiler == "gcc" and compiler_version[0] >= "5":
# For GCC >= v5 we only need the major otherwise Boost doesn't find the compiler
# The NOT windows check is necessary to exclude MinGW:
if not tools.which("g++-%s" % compiler_version[0]):
# In fedora 24, 25 the gcc is 6, but there is no g++-6 and the detection is 6.3.1
# so b2 fails because 6 != 6.3.1. Specify the exe to avoid the smart detection
executable = tools.which("g++")
else:
executable = ""
return compiler, compiler_version[0], executable
elif str(self.settings.compiler) in ["clang", "gcc"]:
# For GCC < v5 and Clang we need to provide the entire version string
return compiler, compiler_version, ""
elif self.settings.compiler == "apple-clang":
if self.settings.os == "iOS":
cc = tools.XCRun(self.settings, tools.apple_sdk_name(self.settings)).cc
return "darwin", self.bjam_darwin_toolchain_version(), cc
else:
return "clang", compiler_version, ""
elif self.settings.compiler == "sun-cc":
return "sunpro", compiler_version, ""
else:
return compiler, compiler_version, ""
def _configure_autotools(self):
if self._autotools:
return self._autotools
self._autotools = AutoToolsBuildEnvironment(
self, win_bash=tools.os_info.is_windows)
# Need to override environment or configure will fail despite that flex
# is actually available.
args = ["LEX=flex"]
if self.options.shared:
args.extend(["--disable-static", "--enable-shared"])
else:
args.extend(["--disable-shared", "--enable-static"])
# No idea why this is necessary, but if you don't set CC this way, then
# configure complains that it can't find gmp.
if (tools.cross_building(self.settings)
and self.settings.compiler == "apple-clang"):
xcr = tools.XCRun(self.settings)
target = tools.to_apple_arch(self.settings.arch) + "-apple-darwin"
min_ios = ""
if self.settings.os == "iOS":
min_ios = "-miphoneos-version-min={}".format(
self.settings.os.version)
args.append("CC={} -isysroot {} -target {} {}".format(
xcr.cc, xcr.sdk_path, target, min_ios))
self._autotools.configure(args=args)
return self._autotools
def build(self):
cmake = CMake(self, generator="Xcode")
cmake_system_name = {
"Macos": "Darwin",
"iOS": "iOS",
"tvOS": "tvOS"
}[str(self.settings.os)]
archs = {
"Macos": "x86_64",
"iOS": "arm64;x86_64",
"tvOS": "arm64;x86_64",
}[str(self.settings.os)]
xcrun = tools.XCRun(self.settings)
cmake.definitions.update({
'CMAKE_OSX_SYSROOT':
xcrun.sdk_path,
'CMAKE_OSX_ARCHITECTURES':
archs,
'CMAKE_OSX_DEPLOYMENT_TARGET':
self.settings.os.version,
'CMAKE_SYSTEM_NAME':
cmake_system_name,
'CMAKE_IOS_INSTALL_COMBINED':
True,
'CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH':
False,
})
cmake.configure(source_folder="src")
cmake.build()
cmake.install()
def _ar(self):
if "AR" in os.environ:
return os.environ["AR"]
if tools.is_apple_os(
self.settings.os) and self.settings.compiler == "apple-clang":
return tools.XCRun(self.settings).ar
return None
def _ranlib(self):
if "RANLIB" in os.environ:
return os.environ["RANLIB"]
if tools.is_apple_os(
self.settings.os) and self.settings.compiler == "apple-clang":
return tools.XCRun(self.settings).ranlib
return None
def ios_build(self):
config_options_string = self._get_flags()
command = "./Configure iphoneos-cross %s" % config_options_string
xcrun = tools.XCRun(self.settings)
cc = xcrun.find("clang")
cc += " -arch %s" % tools.to_apple_arch(self.arch)
if not str(self.arch).startswith("arm"):
cc += " -DOPENSSL_NO_ASM"
try:
cc += " -mios-version-min=%s" % self.settings.os.version
self.output.info("iOS deployment target: %s" %
self.settings.os.version)
except:
pass
cc += " -fembed-bitcode"
os.environ["CROSS_SDK"] = os.path.basename(xcrun.sdk_path)
os.environ["CROSS_TOP"] = os.path.dirname(
os.path.dirname(xcrun.sdk_path))
command = 'CC="%s" %s' % (cc, command)
self.run_in_src(command)
self._patch_install_name()
self.output.warn("----------MAKE OPENSSL %s-------------" %
self.version)
self.run_in_src("make")
def _cxx(self):
if "CXX" in os.environ:
return os.environ["CXX"]
if tools.is_apple_os(
self.settings.os) and self.settings.compiler == "apple-clang":
return tools.XCRun(self.settings).cxx
return None
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 _build_context(self):
if self.settings.compiler == "apple-clang":
env_build = {
"CC": tools.XCRun(self.settings).cc,
"CXX": tools.XCRun(self.settings).cxx
}
if hasattr(self, "settings_build"):
# there is no CFLAGS_FOR_BUILD/CXXFLAGS_FOR_BUILD
xcrun = tools.XCRun(self.settings_build)
flags = " -Wno-implicit-function-declaration -isysroot {} -arch {}".format(
xcrun.sdk_path,
tools.to_apple_arch(self.settings_build.arch))
env_build["CC_FOR_BUILD"] = xcrun.cc + flags
env_build["CXX_FOR_BUILD"] = xcrun.cxx + flags
with tools.environment_append(env_build):
yield
else:
yield
def create_user_config_jam(self, folder):
"""To help locating the zlib and bzip2 deps"""
self.output.warn("Patching user-config.jam")
compiler_command = self._cxx
contents = ""
if self.zip_bzip2_requires_needed:
contents = "\nusing zlib : 1.2.11 : <include>%s <search>%s <name>%s ;" % (
self.deps_cpp_info["zlib"].include_paths[0].replace('\\', '/'),
self.deps_cpp_info["zlib"].lib_paths[0].replace('\\', '/'),
self.deps_cpp_info["zlib"].libs[0])
contents += "\nusing bzip2 : 1.0.6 : <include>%s <search>%s <name>%s ;" % (
self.deps_cpp_info["bzip2"].include_paths[0].replace('\\', '/'),
self.deps_cpp_info["bzip2"].lib_paths[0].replace('\\', '/'),
self.deps_cpp_info["bzip2"].libs[0])
if not self.options.without_python:
# https://www.boost.org/doc/libs/1_69_0/libs/python/doc/html/building/configuring_boost_build.html
contents += "\nusing python : {version} : {executable} : {includes} : {libraries} ;"\
.format(version=self._python_version,
executable=self._python_executable,
includes=self._python_includes,
libraries=self._python_libraries)
toolset, version, exe = self.get_toolset_version_and_exe()
exe = compiler_command or exe # Prioritize CXX
# Specify here the toolset with the binary if present if don't empty parameter : :
contents += '\nusing "%s" : "%s" : ' % (toolset, version)
contents += ' "%s"' % exe.replace("\\", "/")
if tools.is_apple_os(self.settings.os):
contents += " -isysroot %s" % tools.XCRun(self.settings).sdk_path
if self.settings.get_safe("arch"):
contents += " -arch %s" % tools.to_apple_arch(self.settings.arch)
contents += " : \n"
if self._ar:
contents += '<archiver>"%s" ' % tools.which(self._ar).replace("\\", "/")
if self._ranlib:
contents += '<ranlib>"%s" ' % tools.which(self._ranlib).replace("\\", "/")
if "CXXFLAGS" in os.environ:
contents += '<cxxflags>"%s" ' % os.environ["CXXFLAGS"]
if "CFLAGS" in os.environ:
contents += '<cflags>"%s" ' % os.environ["CFLAGS"]
if "LDFLAGS" in os.environ:
contents += '<linkflags>"%s" ' % os.environ["LDFLAGS"]
if "ASFLAGS" in os.environ:
contents += '<asmflags>"%s" ' % os.environ["ASFLAGS"]
contents += " ;"
self.output.warn(contents)
filename = "%s/user-config.jam" % folder
tools.save(filename, contents)
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 _cc(self):
if "CC" in os.environ:
return os.environ["CC"]
if self.settings.compiler == "apple-clang":
return tools.XCRun(self.settings).find("clang")
elif self.settings.compiler == "clang":
return "clang"
elif self.settings.compiler == "gcc":
return "gcc"
return "cc"
def build(self):
with tools.vcvars(self) if self._use_nmake else tools.no_op():
env_vars = {"PERL": self._perl}
if self.settings.compiler == "apple-clang":
xcrun = tools.XCRun(self.settings)
env_vars["CROSS_SDK"] = os.path.basename(xcrun.sdk_path)
env_vars["CROSS_TOP"] = os.path.dirname(os.path.dirname(xcrun.sdk_path))
with tools.environment_append(env_vars):
self._create_targets()
with self._make_context():
self._make()
def _cxx(self):
if "CXX" in os.environ:
return os.environ["CXX"]
if tools.is_apple_os(self.settings.os) and self.settings.compiler == "apple-clang":
return tools.XCRun(self.settings).cxx
compiler_version = str(self.settings.compiler.version)
major = compiler_version.split(".")[0]
if self.settings.compiler == "gcc":
return tools.which("g++-%s" % compiler_version) or tools.which("g++-%s" % major) or tools.which("g++") or ""
if self.settings.compiler == "clang":
return tools.which("clang++-%s" % compiler_version) or tools.which("clang++-%s" % major) or tools.which("clang++") or ""
return ""
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 build(self):
with tools.vcvars(self.settings) if self._use_nmake else tools.no_op():
env_vars = {"PERL": self._perl}
if self.settings.compiler == "apple-clang":
xcrun = tools.XCRun(self.settings)
env_vars["CROSS_SDK"] = os.path.basename(xcrun.sdk_path)
env_vars["CROSS_TOP"] = os.path.dirname(os.path.dirname(xcrun.sdk_path))
with tools.environment_append(env_vars):
if self.settings.os in ["tvOS", "watchOS"]:
tools.patch(patch_file=os.path.join("patches", "1.1.1-tvos-watchos.patch"),
base_path=self._source_subfolder)
self._create_targets()
with self._make_context():
self._make()
def build(self):
with tools.vcvars(self.settings) if self.settings.compiler == "Visual Studio" else tools.no_op():
env_vars = {"PERL": self._perl}
if self._full_version < "1.1.0":
cflags = " ".join(self._get_env_build().flags)
env_vars["CC"] = "%s %s" % (self._cc, cflags)
if self.settings.compiler == "apple-clang":
xcrun = tools.XCRun(self.settings)
env_vars["CROSS_SDK"] = os.path.basename(xcrun.sdk_path)
env_vars["CROSS_TOP"] = os.path.dirname(os.path.dirname(xcrun.sdk_path))
with tools.environment_append(env_vars):
if self._full_version >= "1.1.0":
self._create_targets()
else:
self._patch_makefile_org()
self._make()
def _configure_cmake(self):
if self.settings.os == "iOS":
with open('toolchain.cmake', 'w') as toolchain_cmake:
if self.settings.arch == "armv8":
arch = "arm64"
sdk = "iphoneos"
elif self.settings.arch == "x86_64":
arch = "x86_64"
sdk = "iphonesimulator"
sysroot = tools.XCRun(self.settings).sdk_path
toolchain_cmake.write('set(CMAKE_C_COMPILER /usr/bin/clang CACHE STRING "" FORCE)\n')
toolchain_cmake.write('set(CMAKE_CXX_COMPILER /usr/bin/clang++ CACHE STRING "" FORCE)\n')
toolchain_cmake.write('set(CMAKE_C_COMPILER_WORKS YES)\n')
toolchain_cmake.write('set(CMAKE_CXX_COMPILER_WORKS YES)\n')
toolchain_cmake.write('set(CMAKE_XCODE_EFFECTIVE_PLATFORMS "-%s" CACHE STRING "" FORCE)\n' % sdk)
toolchain_cmake.write('set(CMAKE_OSX_ARCHITECTURES "%s" CACHE STRING "" FORCE)\n' % arch)
toolchain_cmake.write('set(CMAKE_OSX_SYSROOT "%s" CACHE STRING "" FORCE)\n' % sysroot)
os.environ['CONAN_CMAKE_TOOLCHAIN_FILE'] = os.path.join(os.getcwd(), 'toolchain.cmake')
cmake = CMake(self, set_cmake_flags=True)
cmake.definitions["BUILD_TESTS"] = False
cmake.definitions["BUILD_SAMPLES"] = False
cmake.definitions["WERROR"] = False
cmake.definitions["CPPREST_EXCLUDE_WEBSOCKETS"] = self.options.exclude_websockets
cmake.definitions["CPPREST_EXCLUDE_COMPRESSION"] = self.options.exclude_compression
cmake.definitions["CPPREST_VERSION"] = self.version
cmake.definitions["OPENSSL_ROOT_DIR"] = self.deps_cpp_info['openssl'].rootpath
cmake.definitions["OPENSSL_USE_STATIC_LIBS"] = not self.options['openssl'].shared
cmake.definitions["BOOST_ROOT"] = self.deps_cpp_info["boost"].rootpath
cmake.definitions["BOOST_INCLUDEDIR"] = self.deps_cpp_info["boost"].include_paths[0]
cmake.definitions["BOOST_LIBRARYDIR"] = self.deps_cpp_info["boost"].lib_paths[0]
cmake.definitions["Boost_NO_SYSTEM_PATHS"] = True
cmake.definitions["Boost_ADDITIONAL_VERSIONS"] = "1.69.0"
cmake.definitions["Boost_USE_DEBUG_LIBS"] = self.settings.build_type == "Debug"
cmake.definitions["Boost_USE_RELEASE_LIBS"] = self.settings.build_type != "Debug"
cmake.definitions["Boost_USE_STATIC_LIBS"] = not self.options["boost"].shared
if self.settings.get_safe("compiler.runtime"):
cmake.definitions["OPENSSL_MSVC_STATIC_RT"] = 'MT' in str(self.settings.compiler.runtime)
cmake.definitions["Boost_USE_STATIC_RUNTIME"] = 'MT' in str(self.settings.compiler.runtime)
cmake.definitions["Boost_USE_DEBUG_RUNTIME"] = 'd' in str(self.settings.compiler.runtime)
if self.settings.os == "iOS":
cmake.definitions["IOS"] = True
elif self.settings.os == "Android":
cmake.definitions["ANDROID"] = True
cmake.definitions["CONAN_LIBCXX"] = ''
cmake.configure(build_folder=self._build_subfolder)
return cmake
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(self):
cmake = CMake(self, generator="Xcode")
cmake_system_name = {
"Macos": "Darwin",
"iOS": "iOS",
"tvOS": "tvOS",
}[str(self.settings.os)] # workaround for already documented #4550
archs = {
"Macos": "x86_64",
"iOS": "arm64;x86_64",
"tvOS": "arm64;x86_64",
}[str(self.settings.os)]
xcrun = tools.XCRun(self.settings)
cmake.definitions.update({
'CMAKE_OSX_SYSROOT':
xcrun.sdk_path,
'CMAKE_OSX_ARCHITECTURES':
archs,
'CMAKE_OSX_DEPLOYMENT_TARGET':
self.settings.os.version,
'CMAKE_SYSTEM_NAME':
cmake_system_name,
'CMAKE_IOS_INSTALL_COMBINED':
True,
'CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH':
False,
})
cmake.configure(source_folder="src")
cmake.build()
cmake.install()
# Explicit way:
# self.run('cmake %s/hello %s'
# % (self.source_folder, cmake.command_line))
# self.run("cmake --build . %s" % cmake.build_config)
self.run("otool -L %s/lib/hello.framework/hello" % self.build_folder)
self.run("otool -L %s/hello.framework/hello" % self.package_folder)
self.run(f"lipo -info {self.build_folder}/lib/hello.framework/hello")
self.run(f"lipo -info {self.package_folder}/hello.framework/hello")
self.run(
f"otool -arch arm64 -l {self.package_folder}/hello.framework/hello | grep -A4 'VERSION_MIN\|LC_BUILD_VERSION' || true"
)
self.run(
f"otool -arch x86_64 -l {self.package_folder}/hello.framework/hello | grep -A4 'VERSION_MIN\|LC_BUILD_VERSION' || true"
)
def build(self):
for patch in self.conan_data.get("patches", {}).get(self.version, []):
tools.patch(**patch)
with tools.vcvars(self.settings) if self._use_nmake else tools.no_op():
env_vars = {"PERL": self._perl}
if self._full_version < "1.1.0":
cflags = " ".join(self._get_env_build().vars_dict["CFLAGS"])
env_vars["CC"] = "%s %s" % (self._cc, cflags)
if self.settings.compiler == "apple-clang":
xcrun = tools.XCRun(self.settings)
env_vars["CROSS_SDK"] = os.path.basename(xcrun.sdk_path)
env_vars["CROSS_TOP"] = os.path.dirname(os.path.dirname(xcrun.sdk_path))
with tools.environment_append(env_vars):
if self._full_version > "1.1.0":
self._create_targets()
else:
self._patch_configure()
self._patch_makefile_org()
with self._make_context():
self._make()
def _configure_autotools(self):
if self._autotools:
return self._autotools
self._autotools = AutoToolsBuildEnvironment(self)
pkgversion = 'conan GCC %s' % self.version
bugurl = self.url + '/issues'
libdir = "%s/lib/gcc/%s" % (self.package_folder, self.version)
args = [
"--enable-languages=c,c++",
"--disable-nls",
"--disable-multilib",
"--disable-bootstrap",
"--with-system-zlib",
"--with-gmp=%s" % self.deps_cpp_info['gmp'].rootpath,
'--with-mpc=%s' % self.deps_cpp_info["mpc"].rootpath,
"--with-mpfr=%s" % self.deps_cpp_info["mpfr"].rootpath,
"--without-isl",
"--libdir=%s" % libdir,
'--with-pkgversion=%s' % pkgversion,
"--program-suffix=-%s" % self.version,
"--with-bugurl=%s" % bugurl
]
if self.settings.os == "Macos":
xcrun = tools.XCRun(self.settings)
args.extend([
'--with-native-system-header-dir=/usr/include',
"--with-sysroot={}".format(xcrun.sdk_path)
])
self._autotools.libs = [] # otherwise causes config.log to fail finding -lmpc
if self.settings.compiler in ["clang", "apple-clang"]:
# xgcc: error: unrecognized command-line option -stdlib=libc++
if self.settings.compiler.libcxx == "libc++":
self._autotools.cxx_flags.remove("-stdlib=libc++")
elif self.settings.compiler.libcxx in ["libstdc++", "libstdc++11"]:
self._autotools.cxx_flags.remove("-stdlib=libstdc++")
self._autotools.configure(args=args, configure_dir=self._source_subfolder)
return self._autotools
def _create_user_config_jam(self, folder):
"""To help locating the zlib and bzip2 deps"""
self.output.warn("Patching user-config.jam")
compiler_command = self._cxx
contents = ""
if self._zip_bzip2_requires_needed:
def create_library_config(name):
includedir = self.deps_cpp_info[name].include_paths[0].replace('\\', '/')
libdir = self.deps_cpp_info[name].lib_paths[0].replace('\\', '/')
lib = self.deps_cpp_info[name].libs[0]
version = self.deps_cpp_info[name].version
return "\nusing {name} : {version} : " \
"<include>{includedir} " \
"<search>{libdir} " \
"<name>{lib} ;".format(name=name,
version=version,
includedir=includedir,
libdir=libdir,
lib=lib)
contents = ""
if self.options.zlib:
contents += create_library_config("zlib")
if self.options.bzip2:
contents += create_library_config("bzip2")
if self.options.lzma:
contents += create_library_config("lzma")
if self.options.zstd:
contents += create_library_config("zstd")
if not self.options.without_python:
# https://www.boost.org/doc/libs/1_70_0/libs/python/doc/html/building/configuring_boost_build.html
contents += '\nusing python : {version} : "{executable}" : "{includes}" : "{libraries}" ;'\
.format(version=self._python_version,
executable=self._python_executable,
includes=self._python_includes,
libraries=self._python_libraries)
toolset, version, exe = self._toolset_version_and_exe
exe = compiler_command or exe # Prioritize CXX
# Specify here the toolset with the binary if present if don't empty parameter : :
contents += '\nusing "%s" : "%s" : ' % (toolset, version)
contents += ' %s' % exe.replace("\\", "/")
if tools.is_apple_os(self.settings.os):
if self.settings.compiler == "apple-clang":
contents += " -isysroot %s" % tools.XCRun(self.settings).sdk_path
if self.settings.get_safe("arch"):
contents += " -arch %s" % tools.to_apple_arch(self.settings.arch)
contents += " : \n"
if self._ar:
contents += '<archiver>"%s" ' % tools.which(self._ar).replace("\\", "/")
if self._ranlib:
contents += '<ranlib>"%s" ' % tools.which(self._ranlib).replace("\\", "/")
if "CXXFLAGS" in os.environ:
contents += '<cxxflags>"%s" ' % os.environ["CXXFLAGS"]
if "CFLAGS" in os.environ:
contents += '<cflags>"%s" ' % os.environ["CFLAGS"]
if "LDFLAGS" in os.environ:
contents += '<linkflags>"%s" ' % os.environ["LDFLAGS"]
if "ASFLAGS" in os.environ:
contents += '<asmflags>"%s" ' % os.environ["ASFLAGS"]
contents += " ;"
self.output.warn(contents)
filename = "%s/user-config.jam" % folder
tools.save(filename, contents)
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 _tool(self, env_name, apple_name):
if env_name in os.environ:
return os.environ[env_name]
if self.settings.compiler == "apple-clang":
return getattr(tools.XCRun(self.settings), apple_name)
return None
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 _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 _xcrun_sdk_version(self, sdk_name):
"""returns devault SDK version for specified SDK name which can be returnd
by `self.xcrun_sdk_name()`"""
return tools.XCRun(self.settings, sdk_name).sdk_version
def bjam_darwin_root(self, sdk_name):
return os.path.join(tools.XCRun(self.settings, sdk_name).sdk_platform_path, 'Developer')
