def applyCmakeSettingsForiOS(self, cmake): ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain cmake.definitions["DEPLOYMENT_TARGET"] = "10.0" variants = [] if self.settings.arch == "x86": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR" elif self.settings.arch == "x86_64": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR64" else: cmake.definitions["IOS_PLATFORM"] = "OS" # define all architectures for ios fat library if "arm" in self.settings.arch: variants = ["armv7", "armv7s", "armv8", "armv8.3"] # apply build config for all defined architectures if len(variants) > 0: archs = "" for i in range(0, len(variants)): if i == 0: archs = tools.to_apple_arch(variants[i]) else: archs += ";" + tools.to_apple_arch(variants[i]) cmake.definitions["ARCHS"] = archs else: cmake.definitions["ARCHS"] = tools.to_apple_arch( self.settings.arch)
def applyCmakeSettingsForiOS(self, cmake): ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain variants = [] tools.replace_in_file( "%s/libressl-%s/CMakeLists.txt" % (self.source_folder, self.version), "project (LibreSSL C ASM)", """project (LibreSSL C ASM) include_directories(BEFORE "ios/include") """) cmake.definitions["LIBRESSL_APPS"] = "OFF" cmake.definitions["LIBRESSL_TESTS"] = "OFF" if self.settings.arch == "x86" or self.settings.arch == "x86_64": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR" else: cmake.definitions["IOS_PLATFORM"] = "OS" # define all architectures for ios fat library if "arm" in self.settings.arch: variants = ["armv7", "armv7s", "armv8"] # apply build config for all defined architectures if len(variants) > 0: archs = "" for i in range(0, len(variants)): if i == 0: archs = tools.to_apple_arch(variants[i]) else: archs += ";" + tools.to_apple_arch(variants[i]) cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = archs else: cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch)
def build(self): cmake = CMake(self) cmake.verbose = True src_folder = "%s/protobuf-c-%s/build-cmake" % (self.source_folder, self.version) if self.settings.os == "Android": cmake.definitions[ "CMAKE_SYSTEM_VERSION"] = self.settings.os.api_level cmake.definitions["CMAKE_ANDROID_NDK"] = os.environ[ "ANDROID_NDK_PATH"] cmake.definitions[ "CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION"] = self.settings.compiler cmake.definitions[ "CMAKE_ANDROID_STL_TYPE"] = self.options.android_stl_type if self.settings.os == "iOS": ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain if self.settings.arch == "x86" or self.settings.arch == "x86_64": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR" else: cmake.definitions["IOS_PLATFORM"] = "OS" if self.settings.os == "Macos": cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch) cmake.configure(source_folder=src_folder) cmake.build() cmake.install() lib_dir = os.path.join(self.package_folder, "lib") if self.settings.os == "iOS": # delete shared artifacts for static builds and the static library for shared builds if self.options.shared == False: for f in os.listdir(lib_dir): if f.endswith(".a") and os.path.isfile( os.path.join(lib_dir, f)) and not os.path.islink( os.path.join(lib_dir, f)): self.run("xcrun ranlib %s" % os.path.join(lib_dir, f)) # thin the library (remove all other archs) self.run("lipo -extract %s %s -output %s" % (tools.to_apple_arch(self.settings.arch), os.path.join(lib_dir, f), os.path.join(lib_dir, f))) else: # thin the library (remove all other archs) for f in os.listdir(lib_dir): if f.endswith(".dylib") and os.path.isfile( os.path.join(lib_dir, f)) and not os.path.islink( os.path.join(lib_dir, f)): self.run("lipo -extract %s %s -output %s" % (tools.to_apple_arch(self.settings.arch), os.path.join(lib_dir, f), os.path.join(lib_dir, f)))
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 build(self): cmake = CMake(self) cmake.verbose = True cmake.definitions["NATS_BUILD_WITH_TLS"] = "ON" if self.settings.os == "Macos": cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch(self.settings.arch) library_folder = "%s/cnats-%s" % (self.source_folder, self.version) cmake.configure(source_folder=library_folder) cmake.build() cmake.install() lib_dir = os.path.join(self.package_folder,"lib") if self.settings.os == "Macos": # delete shared artifacts for static builds and the static library for shared builds if self.options.shared == False: for f in os.listdir(lib_dir): if f.endswith(".dylib"): os.remove(os.path.join(lib_dir,f)) elif f.endswith("libnats_static.a"): os.rename(os.path.join(lib_dir,f), os.path.join(lib_dir,"libnats.a")) else: for f in os.listdir(lib_dir): if f.endswith(".a"): os.remove(os.path.join(lib_dir,f))
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 applyCmakeSettingsForiOS(self, cmake): cmake.definitions["CMAKE_SYSTEM_NAME"] = "iOS" cmake.definitions["DEPLOYMENT_TARGET"] = "10.0" cmake.definitions["CMAKE_OSX_DEPLOYMENT_TARGET"] = "10.0" cmake.definitions["CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH"] = "NO" cmake.definitions["CMAKE_IOS_INSTALL_COMBINED"] = "YES" cmake.definitions["BUILD_TESTING"] = "OFF" cmake.definitions["BUILD_CURL_EXE"] = "OFF" cmake.definitions["CMAKE_USE_LIBSSH2"] = "OFF" #cmake.definitions["PICKY_COMPILER"] = "OFF" # CMAKE_TOOLCHAIN_FILE needs to be defined, so that the scripts of curl know that we are cross compiling cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = "" tools.replace_in_file( "%s/curl-%s/CMakeLists.txt" % (self.source_folder, self.version), "find_package(OpenSSL", "find_host_package(OpenSSL") self.addFindHostPackage() # define all architectures for ios fat library if "arm" in self.settings.arch: cmake.definitions[ "CMAKE_OSX_ARCHITECTURES"] = "armv7;armv7s;arm64;arm64e" else: cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch)
def ios_build(self, config_options_string): def find_sysroot(sdk_name): return tools.XCRun(self.settings, sdk_name).sdk_path def find_cc(settings, sdk_name=None): return tools.XCRun(settings, sdk_name).cc command = "./Configure iphoneos-cross %s" % config_options_string sdk = tools.apple_sdk_name(self.settings) sysroot = find_sysroot(sdk) cc = find_cc(self.settings, sdk) cc += " -arch %s" % tools.to_apple_arch(self.settings.arch) if not str(self.settings.arch).startswith("arm"): cc += " -DOPENSSL_NO_ASM" os.environ["CROSS_SDK"] = os.path.basename(sysroot) os.environ["CROSS_TOP"] = os.path.dirname(os.path.dirname(sysroot)) command = 'CC="%s" %s' % (cc, command) self.run_in_src(command) # REPLACE -install_name FOR FOLLOW THE CONAN RULES, # DYNLIBS IDS AND OTHER DYNLIB DEPS WITHOUT PATH, JUST THE LIBRARY NAME old_str = 'SHAREDFLAGS="$$SHAREDFLAGS -install_name $(INSTALLTOP)/$(LIBDIR)/$$SHLIB$' new_str = 'SHAREDFLAGS="$$SHAREDFLAGS -install_name $$SHLIB$' tools.replace_in_file("./%s/Makefile.shared" % self.subfolder, old_str, new_str) self.output.warn("----------MAKE OPENSSL %s-------------" % self.version) self.run_in_src("make")
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 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 build(self): cmake = CMake(self) library_folder = "json-%s" % self.version if self.settings.os == "Macos": cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch) cmake.configure(source_folder=library_folder) cmake.build() cmake.test()
def applyCmakeSettingsForiOS(self, cmake): cmake.definitions["CMAKE_SYSTEM_NAME"] = "iOS" cmake.definitions["DEPLOYMENT_TARGET"] = "10.0" cmake.definitions["CMAKE_OSX_DEPLOYMENT_TARGET"] = "10.0" cmake.definitions["CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH"] = "NO" cmake.definitions["CMAKE_IOS_INSTALL_COMBINED"] = "YES" cmake.definitions["DJINNI_WITH_OBJC"] = "ON" # define all architectures for ios fat library if "arm" in self.settings.arch: cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = "armv7;armv7s;arm64;arm64e" else: cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch(self.settings.arch)
def applyCmakeSettingsForiOS(self, cmake): ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain cmake.definitions["DEPLOYMENT_TARGET"] = "10.0" if self.settings.arch == "x86": cmake.definitions["PLATFORM"] = "SIMULATOR" elif self.settings.arch == "x86_64": cmake.definitions["PLATFORM"] = "SIMULATOR64" else: cmake.definitions["PLATFORM"] = "OS" cmake.definitions["ARCHS"] = tools.to_apple_arch(self.settings.arch)
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 applyCmakeSettingsForiOS(self, cmake): cmake.definitions["CMAKE_SYSTEM_NAME"] = "iOS" cmake.definitions["DEPLOYMENT_TARGET"] = "10.0" cmake.definitions["CMAKE_OSX_DEPLOYMENT_TARGET"] = "10.0" cmake.definitions["CMAKE_XCODE_ATTRIBUTE_ONLY_ACTIVE_ARCH"] = "NO" cmake.definitions["CMAKE_IOS_INSTALL_COMBINED"] = "YES" tools.replace_in_file( "%s/libressl-%s/CMakeLists.txt" % (self.source_folder, self.version), "project (LibreSSL C ASM)", """project (LibreSSL C ASM) include_directories(BEFORE "../ios/include") """) # on iOS SDK 13+ we have to remove some checks if tools.Version(self.settings.os.version) >= 13.0: tools.replace_in_file( "%s/libressl-%s/CMakeLists.txt" % (self.source_folder, self.version), "check_function_exists(reallocarray", "#check_function_exists(reallocarray") tools.replace_in_file( "%s/libressl-%s/CMakeLists.txt" % (self.source_folder, self.version), "check_function_exists(explicit_bzero", "#check_function_exists(explicit_bzero") tools.replace_in_file( "%s/libressl-%s/CMakeLists.txt" % (self.source_folder, self.version), "check_function_exists(syslog_r", "#check_function_exists(syslog_r") tools.replace_in_file( "%s/libressl-%s/CMakeLists.txt" % (self.source_folder, self.version), "check_function_exists(timingsafe_memcmp", "#check_function_exists(timingsafe_memcmp") cmake.definitions["LIBRESSL_APPS"] = "OFF" cmake.definitions["LIBRESSL_TESTS"] = "OFF" # define all architectures for ios fat library if "arm" in self.settings.arch: cmake.definitions[ "CMAKE_OSX_ARCHITECTURES"] = "armv7;armv7s;arm64;arm64e" else: cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch)
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 applyCmakeSettingsForiOS(self, cmake): ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain cmake.definitions["DEPLOYMENT_TARGET"] = "10.0" if self.settings.arch == "x86": cmake.definitions["PLATFORM"] = "SIMULATOR" elif self.settings.arch == "x86_64": cmake.definitions["PLATFORM"] = "SIMULATOR64" else: cmake.definitions["PLATFORM"] = "OS" # define all architectures for ios fat library if "arm" in self.settings.arch: cmake.definitions["ARCHS"] = "armv7;armv7s;arm64;arm64e" else: cmake.definitions["ARCHS"] = tools.to_apple_arch( self.settings.arch)
def build(self): cmake = CMake(self) cmake.verbose = True library_folder = "soci-%s/src" % self.version cmake.definitions["SOCI_TESTS"] = "OFF" cmake.definitions[ "SOCI_SHARED"] = "ON" if self.options.shared == True else "OFF" cmake.definitions[ "SOCI_STATIC"] = "OFF" if self.options.shared == True else "ON" if self.settings.os == "Android": cmake.definitions[ "CMAKE_SYSTEM_VERSION"] = self.settings.os.api_level cmake.definitions["CMAKE_ANDROID_NDK"] = os.environ[ "ANDROID_NDK_PATH"] cmake.definitions[ "CMAKE_ANDROID_NDK_TOOLCHAIN_VERSION"] = self.settings.compiler cmake.definitions[ "CMAKE_ANDROID_STL_TYPE"] = self.options.android_stl_type if self.settings.os == "iOS": ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain if self.settings.arch == "x86" or self.settings.arch == "x86_64": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR" else: cmake.definitions["IOS_PLATFORM"] = "OS" if self.settings.os == "Macos": cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch) cmake.configure(source_folder=library_folder) cmake.build() cmake.install() socimysqlheader = "%s/include/soci/mysql/soci-mysql.h" if self.version == "3.2.3" and os.path.isfile(socimysqlheader): tools.replace_in_file(socimysqlheader % (self.package_folder), '#include "soci-backend.h"', '#include "../soci-backend.h"')
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): library_folder = "%s/openldap-%s" % (self.source_folder, self.version) # autotools = AutoToolsBuildEnvironment(self) # env_build_vars = autotools.vars # build_host = None if self.settings.os == "iOS": if self.version == "2.4.46": self.run("cd %s; patch -p1 < %s/patches-ios/2.4.46.patch" % (library_folder, self.build_folder)) # define all architectures for ios fat library if "arm" in self.settings.arch: self.run("%s/openldap-ios.sh %s arm %s %s" % (self.build_folder, self.version, library_folder, self.settings.build_type)) else: self.run("%s/openldap-ios.sh %s %s %s %s" % (self.build_folder, self.version, tools.to_apple_arch(self.settings.arch), library_folder, self.settings.build_type))
def applyCmakeSettingsForiOS(self, cmake): ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain cmake.definitions["BUILD_TESTING"] = "OFF" cmake.definitions["BUILD_CURL_EXE"] = "OFF" cmake.definitions["CMAKE_USE_LIBSSH2"] = "OFF" #cmake.definitions["PICKY_COMPILER"] = "OFF" tools.replace_in_file("%s/curl-%s/CMakeLists.txt" % (self.source_folder, self.version), "find_package(OpenSSL", "find_host_package(OpenSSL") # define all architectures for ios fat library if "arm" in self.settings.arch: cmake.definitions["ARCHS"] = "armv7;armv7s;arm64;arm64e" else: cmake.definitions["ARCHS"] = tools.to_apple_arch(self.settings.arch) if self.settings.arch == "x86": cmake.definitions["PLATFORM"] = "SIMULATOR" elif self.settings.arch == "x86_64": cmake.definitions["PLATFORM"] = "SIMULATOR64" else: cmake.definitions["PLATFORM"] = "OS"
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 get_platform_arch(self): platform_arch = tools.to_apple_arch( self.options.get_safe("ezored_arch"), ) return platform_arch
def applyCmakeSettingsFormacOS(self, cmake): cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch)
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_68_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.settings.compiler == "gcc": flags.append("--layout=system") if self.settings.compiler == "Visual Studio" and self.settings.compiler.runtime: flags.append("runtime-link=%s" % ("static" if "MT" in str(self.settings.compiler.runtime) else "shared")) if self.settings.os == "Windows" and self.settings.compiler == "gcc": 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) if self.settings.cppstd: toolset, _, _ = self.get_toolset_version_and_exe() flags.append("toolset=%s" % toolset) 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.compiler != "Visual Studio": 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.settings.os == "iOS": arch = self.settings.get_safe('arch') 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.extend(["-arch", tools.to_apple_arch(arch)]) try: cxx_flags.append("-mios-version-min=%s" % self.settings.os.version) self.output.info("iOS deployment target: %s" % self.settings.os.version) except: pass flags.append("macosx-version=%s" % self.b2_macosx_version()) cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else "" flags.append(cxx_flags) return flags
def get_build_flags(self): if tools.cross_building(self.settings): flags = self.get_build_cross_flags() else: flags = [] if self.settings.arch == 'x86' and 'address-model=32' not in flags: flags.append('address-model=32') elif self.settings.arch == 'x86_64' and 'address-model=64' not in flags: flags.append('address-model=64') if self.settings.compiler == "gcc": flags.append("--layout=system") if self.settings.compiler == "Visual Studio" and self.settings.compiler.runtime: flags.append("runtime-link=%s" % ("static" if "MT" in str( self.settings.compiler.runtime) else "shared")) if self.settings.os == "Windows" and self.settings.compiler == "gcc": 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) # CXX FLAGS cxx_flags = [] # fPIC DEFINITION if self.settings.compiler != "Visual Studio": 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++") cxx_flags.append("-std=c++11") flags.append('linkflags="-stdlib=libc++"') else: cxx_flags.append("-stdlib=libstdc++") cxx_flags.append("-std=c++11") except: pass if self.settings.os == "iOS": arch = self.settings.get_safe('arch') 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.extend(["-arch", tools.to_apple_arch(arch)]) try: cxx_flags.append("-mios-version-min=%s" % self.settings.os.version) self.output.info("iOS deployment target: %s" % self.settings.os.version) except: pass flags.append("macosx-version=%s" % self.b2_macosx_version()) cxx_flags = 'cxxflags="%s"' % " ".join(cxx_flags) if cxx_flags else "" flags.append(cxx_flags) 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 = [] 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 build(self): cmake = CMake(self) library_folder = "%s/curl-%s" % (self.source_folder, self.version) cmake.verbose = True variants = [] if self.settings.os == "Android": android_toolchain = os.environ[ "ANDROID_NDK_PATH"] + "/build/cmake/android.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = android_toolchain cmake.definitions["ANDROID_NDK"] = os.environ["ANDROID_NDK_PATH"] cmake.definitions["ANDROID_ABI"] = tools.to_android_abi( self.settings.arch) cmake.definitions["ANDROID_STL"] = self.options.android_stl_type cmake.definitions[ "ANDROID_NATIVE_API_LEVEL"] = self.settings.os.api_level cmake.definitions["ANDROID_TOOLCHAIN"] = "clang" cmake.definitions["BUILD_TESTING"] = "OFF" cmake.definitions["BUILD_CURL_EXE"] = "OFF" tools.replace_in_file( "%s/curl-%s/CMakeLists.txt" % (self.source_folder, self.version), "find_package(OpenSSL", "find_host_package(OpenSSL") self.addFindHostPackage() if self.settings.os == "iOS": ios_toolchain = "cmake-modules/Toolchains/ios.toolchain.cmake" cmake.definitions["CMAKE_TOOLCHAIN_FILE"] = ios_toolchain cmake.definitions["BUILD_TESTING"] = "OFF" cmake.definitions["BUILD_CURL_EXE"] = "OFF" cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch) tools.replace_in_file( "%s/curl-%s/CMakeLists.txt" % (self.source_folder, self.version), "find_package(OpenSSL", "find_host_package(OpenSSL") # define all architectures for ios fat library if "arm" in self.settings.arch: variants = ["armv7", "armv7s", "armv8"] # apply build config for all defined architectures if len(variants) > 0: archs = "" for i in range(0, len(variants)): if i == 0: archs = tools.to_apple_arch(variants[i]) else: archs += ";" + tools.to_apple_arch(variants[i]) cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = archs if self.settings.arch == "x86": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR" elif self.settings.arch == "x86_64": cmake.definitions["IOS_PLATFORM"] = "SIMULATOR64" else: cmake.definitions["IOS_PLATFORM"] = "OS" if self.settings.os == "Macos": cmake.definitions["CMAKE_OSX_ARCHITECTURES"] = tools.to_apple_arch( self.settings.arch) cmake.definitions["CURL_DISABLE_LDAP"] = not self.options.with_ldap cmake.definitions[ "BUILD_SHARED_LIBS"] = "ON" if self.options.shared else "OFF" cmake.configure(source_folder=library_folder) cmake.build() cmake.install()
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