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')