def _configure_cmake(self): cmake = CMake(self) if tools.Version(self.version) < "1.1": cmake.definitions["ENABLE_ENCODERS"] = self.options.enable_encoders cmake.definitions["ENABLE_DECODERS"] = self.options.enable_decoders else: cmake.definitions["BUILD_WRITERS"] = self.options.enable_encoders cmake.definitions["BUILD_READERS"] = self.options.enable_decoders cmake.definitions["BUILD_EXAMPLES"] = False cmake.definitions["BUILD_BLACKBOX_TESTS"] = False if is_msvc(self): cmake.definitions["LINK_CPP_STATICALLY"] = "MT" in str( self.settings.compiler.runtime) cmake.configure(build_folder=self._build_subfolder) return cmake
def package(self): self.copy(pattern="COPYING", dst="licenses", src=self._source_subfolder) with tools.environment_append( VisualStudioBuildEnvironment(self).vars ) if is_msvc(self) else tools.no_op(): meson = self._configure_meson() meson.install() self._fix_library_names() tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) shutil.move( os.path.join(self.package_folder, "share"), os.path.join(self.package_folder, "res"), ) for pdb_file in glob.glob(os.path.join(self.package_folder, "bin", "*.pdb")): os.unlink(pdb_file)
def validate(self): if self.settings.os != "Windows": raise ConanInvalidConfiguration("Only os=Windows is supported") # if not is_msvc(self): # raise ConanInvalidConfiguration("Only the MSVC compiler is supported") if is_msvc(self) and not is_msvc_static_runtime(self): # Debug and/or dynamic runtime is undesired for a hooking library raise ConanInvalidConfiguration( "Only static runtime is supported (MT)") if self.settings.build_type != "Release": raise ConanInvalidConfiguration( "Detours only supports the Release build type") try: self.output.info(f"target process is {self._target_processor}") except KeyError: raise ConanInvalidConfiguration("Unsupported architecture")
def build(self): apply_conandata_patches(self) at = Autotools(self) build_script_folder = self._source_subfolder if is_msvc(self): self.conf["tools.gnu:make_program"] = "nmake" build_script_folder = os.path.join(build_script_folder, "win32") if "TMP" in os.environ: # workaround for TMP in CCI containing both forward and back slashes os.environ["TMP"] = os.environ["TMP"].replace("/", "\\") with tools.vcvars(self): at.configure(build_script_folder=build_script_folder) at.make()
def test_is_msvc(compiler, expected): settings = Settings({ "build_type": ["Release"], "compiler": { compiler: { "version": ["2022"] } }, "os": ["Windows"], "arch": ["x86_64"] }) conanfile = ConanFile(Mock(), None) conanfile.settings = "os", "compiler", "build_type", "arch" conanfile.initialize(settings, EnvValues()) conanfile.settings.compiler = compiler assert is_msvc(conanfile) == expected
def package_info(self): self.cpp_info.set_property("cmake_file_name", "minizip") self.cpp_info.set_property("cmake_target_name", "MINIZIP::minizip") self.cpp_info.set_property("pkg_config_name", "minizip") # TODO: back to global scope in conan v2 once cmake_find_package_* generators removed prefix = "lib" if is_msvc(self) or self._is_clang_cl else "" suffix = "" if tools.Version( self.version) < "3.0.5" or self.options.mz_compatibility else "-ng" self.cpp_info.components["minizip"].libs = [f"{prefix}minizip{suffix}"] if self.options.with_lzma: self.cpp_info.components["minizip"].defines.append("HAVE_LZMA") if tools.is_apple_os( self.settings.os) and self.options.get_safe("with_libcomp"): self.cpp_info.components["minizip"].defines.append("HAVE_LIBCOMP") if self.options.with_bzip2: self.cpp_info.components["minizip"].defines.append("HAVE_BZIP2") # TODO: to remove in conan v2 once cmake_find_package_* generators removed self.cpp_info.filenames["cmake_find_package"] = "minizip" self.cpp_info.filenames["cmake_find_package_multi"] = "minizip" self.cpp_info.names["cmake_find_package"] = "MINIZIP" self.cpp_info.names["cmake_find_package_multi"] = "MINIZIP" self.cpp_info.names["pkg_config"] = "minizip" self.cpp_info.components["minizip"].names[ "cmake_find_package"] = "minizip" self.cpp_info.components["minizip"].names[ "cmake_find_package_multi"] = "minizip" self.cpp_info.components["minizip"].set_property( "cmake_target_name", "MINIZIP::minizip") self.cpp_info.components["minizip"].set_property( "pkg_config_name", "minizip") if self.options.get_safe("with_zlib"): self.cpp_info.components["minizip"].requires.append("zlib::zlib") if self.options.with_bzip2: self.cpp_info.components["minizip"].requires.append("bzip2::bzip2") if self.options.with_lzma: self.cpp_info.components["minizip"].requires.append( "xz_utils::xz_utils") if self.options.with_zstd: self.cpp_info.components["minizip"].requires.append("zstd::zstd") if self.options.with_openssl: self.cpp_info.components["minizip"].requires.append( "openssl::openssl") if self.settings.os != "Windows" and self.options.with_iconv: self.cpp_info.components["minizip"].requires.append( "libiconv::libiconv")
def validate(self): if hasattr(self, 'settings_build') and tools.cross_building( self, skip_x64_x86=True): raise ConanInvalidConfiguration("Cross-building not implemented") if tools.Version( self.version) >= "2.69.0" and not self.options.with_pcre: raise ConanInvalidConfiguration( "option glib:with_pcre must be True for glib >= 2.69.0") if self.settings.os == "Windows" and not self.options.shared and tools.Version( self.version) < "2.71.1": raise ConanInvalidConfiguration( "glib < 2.71.1 can not be built as static library on Windows. " "see https://gitlab.gnome.org/GNOME/glib/-/issues/692") if tools.Version(self.version) < "2.67.0" and not is_msvc( self) and not self.options.with_elf: raise ConanInvalidConfiguration( "libelf dependency can't be disabled in glib < 2.67.0")
def package(self): self.copy("LICENSE.TXT", dst="licenses", src=self._source_subfolder) if is_msvc(self): with self._msvc_build_environment(): self.run("nmake -f makefile.vc devinstall {}".format(" ".join( self._nmake_args))) tools.remove_files_by_mask( os.path.join(self.package_folder, "lib"), "*.pdb") else: with self._autotools_build_environment(): autotools = self._configure_autotools() autotools.install() tools.rmdir(os.path.join(self.package_folder, "lib", "gdalplugins")) tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) tools.remove_files_by_mask( os.path.join(self.package_folder, "lib"), "*.la")
def package(self): self.copy("COPYING", dst="licenses", src=self._source_subfolder) with self._build_context(): autotools = self._configure_autotools() autotools.install() tools.rmdir(os.path.join(self.package_folder, "share")) tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.la") tools.remove_files_by_mask( os.path.join(self.package_folder, "include", "gsl"), "*.c") os.unlink(os.path.join(self.package_folder, "bin", "gsl-config")) if is_msvc(self) and self.options.shared: pjoin = lambda p: os.path.join(self.package_folder, "lib", p) rename(self, pjoin("gsl.dll.lib"), pjoin("gsl.lib")) rename(self, pjoin("gslcblas.dll.lib"), pjoin("gslcblas.lib"))
def _configure_cmake(self): cmake = CMake(self) cmake.definitions[ "SFML_DEPENDENCIES_INSTALL_PREFIX"] = self.package_folder cmake.definitions["SFML_MISC_INSTALL_PREFIX"] = os.path.join( self.package_folder, "licenses").replace("\\", "/") cmake.definitions["SFML_BUILD_WINDOW"] = self.options.window cmake.definitions["SFML_BUILD_GRAPHICS"] = self.options.graphics cmake.definitions["SFML_BUILD_NETWORK"] = self.options.network cmake.definitions["SFML_BUILD_AUDIO"] = self.options.audio cmake.definitions["SFML_INSTALL_PKGCONFIG_FILES"] = False cmake.definitions["SFML_GENERATE_PDB"] = False cmake.definitions["SFML_USE_SYSTEM_DEPS"] = True if is_msvc(self): cmake.definitions[ "SFML_USE_STATIC_STD_LIBS"] = is_msvc_static_runtime(self) cmake.configure(build_folder=self._build_subfolder) return cmake
def package(self): self.copy("COPYING.LIB", src=self._source_subfolder, dst="licenses") with self._build_context(): autotools = self._configure_autotools() autotools.install() tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.la") tools.rmdir(os.path.join(self.package_folder, "share")) if (is_msvc(self) or self._is_clang_cl) and self.options.shared: for import_lib in ["iconv", "charset"]: rename( self, os.path.join(self.package_folder, "lib", "{}.dll.lib".format(import_lib)), os.path.join(self.package_folder, "lib", "{}.lib".format(import_lib)))
def configure(self): if self.options.shared: del self.options.fPIC if self.settings.arch not in ["x86", "x86_64"]: del self.options.simd_intrinsics if self.options.without_lerc: del self.options.with_zstd # if self.options.with_spatialite: # del self.options.with_sqlite3 if not self.options.get_safe("with_sqlite3", False): del self.options.with_pcre del self.options.with_pcre2 if is_msvc(self): del self.options.threadsafe del self.options.with_null del self.options.with_zlib # zlib and png are always used in nmake build, del self.options.with_png # and it's not trivial to fix self._strict_options_requirements()
def package_info(self): self.cpp_info.set_property("cmake_file_name", "antlr4-runtime") self.cpp_info.set_property("cmake_target_name", "antlr4_shared" if self.options.shared else "antlr4_static") libname = "antlr4-runtime" if is_msvc(self) and not self.options.shared: libname += "-static" self.cpp_info.libs = [libname] self.cpp_info.includedirs.append(os.path.join("include", "antlr4-runtime")) if self.settings.os == "Windows" and not self.options.shared: self.cpp_info.defines.append("ANTLR4CPP_STATIC") if self.settings.os in ("FreeBSD", "Linux"): self.cpp_info.system_libs = ["pthread"] # TODO: to remove in conan v2 once cmake_find_package* generatores removed self.cpp_info.filenames["cmake_find_package"] = "antlr4-runtime" self.cpp_info.filenames["cmake_find_package_multi"] = "antlr4-runtime" self.cpp_info.build_modules["cmake_find_package"] = [self._module_file_rel_path] self.cpp_info.build_modules["cmake_find_package_multi"] = [self._module_file_rel_path]
def _configure_cmake(self): cmake = CMake(self) cmake.definitions["THREADSAFE"] = self.options.threadsafe cmake.definitions["USE_SSH"] = self.options.with_libssh2 cmake.definitions["USE_ICONV"] = self.options.get_safe("with_iconv", False) cmake.definitions["USE_HTTPS"] = self._cmake_https[str(self.options.with_https)] cmake.definitions["SHA1_BACKEND"] = self._cmake_sha1[str(self.options.with_sha1)] cmake.definitions["BUILD_CLAR"] = False cmake.definitions["BUILD_EXAMPLES"] = False if is_msvc(self): cmake.definitions["STATIC_CRT"] = is_msvc_static_runtime(self) cmake.configure() return cmake
def _build_context(self): if is_msvc(self): with tools.vcvars(self.settings): msvc_cl_sh = os.path.join(self.build_folder, "msvc_cl.sh").replace("\\", "/") env = { "AR": "lib", "CC": msvc_cl_sh, "CXX": msvc_cl_sh, "LD": msvc_cl_sh, "NM": "dumpbin -symbols", "OBJDUMP": ":", "RANLIB": ":", "STRIP": ":", } with tools.environment_append(env): yield else: yield
def package_info(self): self.cpp_info.set_property("cmake_file_name", "yaml-cpp") self.cpp_info.set_property("cmake_target_name", "yaml-cpp") self.cpp_info.set_property("pkg_config_name", "yaml-cpp") self.cpp_info.libs = tools.collect_libs(self) if self.settings.os in ("Linux", "FreeBSD"): self.cpp_info.system_libs.append("m") if is_msvc(self): self.cpp_info.defines.append("_NOEXCEPT=noexcept") if self.options.shared: self.cpp_info.defines.append("YAML_CPP_DLL") # TODO: to remove in conan v2 once cmake_find_package_* generators removed self.cpp_info.build_modules["cmake_find_package"] = [ self._module_file_rel_path ] self.cpp_info.build_modules["cmake_find_package_multi"] = [ self._module_file_rel_path ]
def _build_context(self): if is_msvc(self): with tools.vcvars(self): env = { "CC": "cl -nologo", "CXX": "cl -nologo", "LD": "link -nologo", "AR": "{} lib".format( tools.unix_path( self._user_info_build["automake"].ar_lib)), } with tools.environment_append(env): yield else: yield
def validate(self): if self.settings.compiler.get_safe("cppstd"): tools.check_min_cppstd(self, 17) minimum_version = self._compiler_required_cpp17.get( str(self.settings.compiler), False) if minimum_version: if tools.Version(self.settings.compiler.version) < minimum_version: raise tools.ConanInvalidConfiguration( "{} requires C++17, which your compiler does not support.". format(self.name)) else: self.output.warn( "{0} requires C++17. Your compiler is unknown. Assuming it supports C++17." .format(self.name)) if is_msvc(self) and self.options.shared: raise tools.ConanInvalidConfiguration( "{} does not support shared build in MSVC".format(self.name))
def validate(self): # In 1.2.2, arsenalgear doesn't support Visual Studio. if is_msvc(self): raise ConanInvalidConfiguration( "{} doesn't support Visual Studio(yet)".format(self.name)) if self.settings.compiler.get_safe("cppstd"): tools.check_min_cppstd(self, 17) minimum_version = self._compiler_required_cpp17.get( str(self.settings.compiler), False) if minimum_version: if tools.Version(self.settings.compiler.version) < minimum_version: raise ConanInvalidConfiguration( "{} requires C++17, which your compiler does not support.". format(self.name)) else: self.output.warn( "{0} requires C++17. Your compiler is unknown. Assuming it supports C++17." .format(self.name))
def package_info(self): libname = "dime" if self.settings.os == "Windows" and is_msvc(self): libname = "{}{}{}{}".format( libname, tools.Version(self.version).major, "" if self.options.shared else "s", "d" if self.settings.build_type == "Debug" else "", ) self.cpp_info.libs = [libname] if self.settings.os == "Windows": self.cpp_info.cxxflags.append( "-DDIME_DLL" if self.options.shared else "-DDIME_NOT_DLL") if self.options.fixbig: self.cpp_info.cxxflags.append("-DDIME_FIXBIG") bindir = os.path.join(self.package_folder, "bin") self.output.info( "Appending PATH environment variable: {}".format(bindir)) self.env_info.PATH.append(bindir)
def package(self): self.copy("COPYING", dst="licenses", src=self._source_subfolder) meson = self._configure_meson() meson.install() if is_msvc(self): tools.remove_files_by_mask( os.path.join(self.package_folder, "bin"), "*.pdb") if not self.options.shared: rename( self, os.path.join( self.package_folder, "lib", f"libcairomm-{self._abi_version()}.a", ), os.path.join(self.package_folder, "lib", f"cairomm-{self._abi_version()}.lib"), ) for header_file in glob.glob( os.path.join( self.package_folder, "lib", f"cairomm-{self._abi_version()}", "include", "*.h", )): shutil.move( header_file, os.path.join( self.package_folder, "include", f"cairomm-{self._abi_version()}", os.path.basename(header_file), ), ) for dir_to_remove in ["pkgconfig", f"cairomm-{self._abi_version()}"]: tools.rmdir(os.path.join(self.package_folder, "lib", dir_to_remove))
def package_info(self): binpath = os.path.join(self.package_folder, "bin") self.output.info(f"Adding to PATH: {binpath}") self.env_info.PATH.append(binpath) version = tools.Version(self.version) rubylib = self.cpp_info.components["rubylib"] config_file = glob.glob(os.path.join(self.package_folder, "include", "**", "ruby", "config.h"), recursive=True)[0] rubylib.includedirs = [ os.path.join(self.package_folder, "include", f"ruby-{version}"), os.path.dirname(os.path.dirname(config_file)) ] rubylib.libs = tools.collect_libs(self) if is_msvc(self): if self.options.shared: rubylib.libs = list(filter(lambda l: not l.endswith("-static"), rubylib.libs)) else: rubylib.libs = list(filter(lambda l: l.endswith("-static"), rubylib.libs)) rubylib.requires.extend(["zlib::zlib", "gmp::gmp"]) if self.options.with_openssl: rubylib.requires.append("openssl::openssl") if self.settings.os in ("FreeBSD", "Linux"): rubylib.system_libs = ["dl", "pthread", "rt", "m", "crypt"] elif self.settings.os == "Windows": rubylib.system_libs = self._windows_system_libs if str(self.settings.compiler) in ("clang", "apple-clang"): rubylib.cflags = ["-fdeclspec"] rubylib.cxxflags = ["-fdeclspec"] if tools.is_apple_os(self.settings.os): rubylib.frameworks = ["CoreFoundation"] self.cpp_info.filenames["cmake_find_package"] = "Ruby" self.cpp_info.filenames["cmake_find_package_multi"] = "Ruby" self.cpp_info.set_property("cmake_file_name", "Ruby") self.cpp_info.names["cmake_find_package"] = "Ruby" self.cpp_info.names["cmake_find_package_multi"] = "Ruby" self.cpp_info.set_property("cmake_target_name", "Ruby::Ruby") self.cpp_info.set_property("pkg_config_aliases", [f"ruby-{version.major}.{version.minor}"])
def package(self): self.copy("COPYING", dst="licenses", src=self._source_subfolder) meson = self._configure_meson() meson.install() shutil.move( os.path.join(self.package_folder, "lib", "libxml++-2.6", "include", "libxml++config.h"), os.path.join(self.package_folder, "include", "libxml++-2.6", "libxml++config.h")) tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) tools.rmdir(os.path.join(self.package_folder, "lib", "libxml++-2.6")) if is_msvc(self): tools.remove_files_by_mask( os.path.join(self.package_folder, "bin"), "*.pdb") if not self.options.shared: rename( self, os.path.join(self.package_folder, "lib", "libxml++-2.6.a"), os.path.join(self.package_folder, "lib", "xml++-2.6.lib"))
def _configure_autotools(self): if self._autotools: return self._autotools self._autotools = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) self._autotools.libs = [] yes_no = lambda v: "yes" if v else "no" args = [ "--enable-shared={}".format(yes_no(self.options.shared)), "--enable-static={}".format(yes_no(not self.options.shared)), "--with-pic={}".format(yes_no(self.options.get_safe("fPIC", True))) ] if is_msvc(self): self._autotools.defines.append("__WOE__") if self.settings.compiler == "Visual Studio" and \ tools.Version(self.settings.compiler.version) >= "12": self._autotools.flags.append("-FS") self._autotools.configure(args=args, configure_dir=self._source_subfolder) return self._autotools
def requirements(self): self.requires("boost/1.78.0") self.requires("bzip2/1.0.8") self.requires("double-conversion/3.2.0") self.requires("gflags/2.2.2") self.requires("glog/0.4.0") self.requires("libevent/2.1.12") self.requires("openssl/1.1.1n") self.requires("lz4/1.9.3") self.requires("snappy/1.1.9") self.requires("zlib/1.2.12") self.requires("zstd/1.5.2") if not is_msvc(self): self.requires("libdwarf/20191104") self.requires("libsodium/1.0.18") self.requires("xz_utils/5.2.5") # FIXME: Causing compilation issues on clang: self.requires("jemalloc/5.2.1") if self.settings.os == "Linux": self.requires("libiberty/9.1.0") self.requires("libunwind/1.5.0") if tools.Version(self.version) >= "2020.08.10.00": self.requires("fmt/7.0.3")
def validate(self): if self.settings.compiler.cppstd: tools.check_min_cppstd(self, 17) minimum_version = self._compilers_minimum_version.get( str(self.settings.compiler), False) if minimum_version: if Version(self.settings.compiler.version) < minimum_version: raise ConanInvalidConfiguration( "{} requires C++17, which your compiler does not support.". format(self.name)) else: self.output.warn( "{} requires C++17. Your compiler is unknown. Assuming it supports C++17." .format(self.name)) if self.settings.arch not in ["x86", "x86_64"]: raise ConanInvalidConfiguration( "Hexl only supports x86 architecture") if self.options.shared and is_msvc(self): raise ConanInvalidConfiguration( "Hexl only supports static linking with msvc")
def package(self): self.copy("COPYING", src=self._source_subfolder, dst="licenses") with self._build_context(): autotools = self._configure_autotools() autotools.install() if is_msvc(self) and not self.options.shared: rename(self, os.path.join(self.package_folder, "lib", "libxapian.lib"), os.path.join(self.package_folder, "lib", "xapian.lib")) os.unlink( os.path.join( os.path.join(self.package_folder, "bin", "xapian-config"))) os.unlink( os.path.join( os.path.join(self.package_folder, "lib", "libxapian.la"))) tools.rmdir(os.path.join(self.package_folder, "lib", "cmake")) tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) tools.rmdir(os.path.join(self._datarootdir, "doc")) tools.rmdir(os.path.join(self._datarootdir, "man")) self._create_cmake_module_variables( os.path.join(self.package_folder, self._module_file_rel_path))
def validate(self): compiler = self.settings.compiler compiler_version = tools.Version(self.settings.compiler.version) ctre_version = tools.Version(self.version) min_gcc = "7.4" if ctre_version < "3" else "8" if self.settings.compiler.get_safe("cppstd"): tools.check_min_cppstd(self, "17") if is_msvc(self): if compiler_version < "15": raise ConanInvalidConfiguration( "{}/{} doesn't support MSVC < 15".format( self.name, self.version)) if ctre_version >= "3.7" and compiler_version < 16: raise ConanInvalidConfiguration( "{}/{} doesn't support MSVC < 16".format( self.name, self.version)) elif compiler == "gcc" and compiler_version < min_gcc: raise ConanInvalidConfiguration( "{}/{} doesn't support gcc < {}".format( self.name, self.version, min_gcc)) elif compiler == "clang" and compiler_version < "6.0": raise ConanInvalidConfiguration( "{}/{} doesn't support clang < 6.0".format( self.name, self.version)) elif compiler == "apple-clang": if compiler_version < "10.0": raise ConanInvalidConfiguration( "{}/{} doesn't support Apple clang < 10.0".format( self.name, self.version)) # "library does not compile with (at least) Xcode 12.0-12.4" # https://github.com/hanickadot/compile-time-regular-expressions/issues/188 # it's also occurred in Xcode 13. if ctre_version.major == "3" and ctre_version.minor == "4" and compiler_version >= "12": raise ConanInvalidConfiguration( "{}/{} doesn't support Apple clang".format( self.name, self.version))
def environment(self): env = Environment() apple_flags = [ self.apple_isysroot_flag, self.apple_arch_flag, self.apple_min_version_flag ] fpic = "-fPIC" if self.fpic else None extra_flags = self._get_extra_flags() self.cxxflags.extend([ self.libcxx, self.cppstd, self.arch_flag, fpic, self.msvc_runtime_flag, self.sysroot_flag ] + self.build_type_flags + apple_flags + extra_flags["cxxflags"]) self.cflags.extend( [self.arch_flag, fpic, self.msvc_runtime_flag, self.sysroot_flag] + self.build_type_flags + apple_flags + extra_flags["cflags"]) self.ldflags.extend([self.arch_flag, self.sysroot_flag] + self.build_type_link_flags + apple_flags + extra_flags["ldflags"]) self.defines.extend([self.ndebug, self.gcc_cxx11_abi] + extra_flags["defines"]) if is_msvc(self._conanfile): env.define("CXX", "cl") env.define("CC", "cl") env.append("CPPFLAGS", [ "-D{}".format(d) for d in self._filter_list_empty_fields(self.defines) ]) env.append("CXXFLAGS", self._filter_list_empty_fields(self.cxxflags)) env.append("CFLAGS", self._filter_list_empty_fields(self.cflags)) env.append("LDFLAGS", self._filter_list_empty_fields(self.ldflags)) env.prepend_path("PKG_CONFIG_PATH", self._conanfile.generators_folder) return env
def _configure_cmake(self): cmake = CMake(self, set_cmake_flags=True) cmake.definitions["ENABLE_STATIC"] = not self.options.shared cmake.definitions["ENABLE_SHARED"] = self.options.shared cmake.definitions["WITH_SIMD"] = self.options.get_safe("SIMD", False) cmake.definitions[ "WITH_ARITH_ENC"] = self._is_arithmetic_encoding_enabled cmake.definitions[ "WITH_ARITH_DEC"] = self._is_arithmetic_decoding_enabled cmake.definitions["WITH_JPEG7"] = self.options.libjpeg7_compatibility cmake.definitions["WITH_JPEG8"] = self.options.libjpeg8_compatibility cmake.definitions["WITH_MEM_SRCDST"] = self.options.get_safe( "mem_src_dst", False) cmake.definitions["WITH_TURBOJPEG"] = self.options.get_safe( "turbojpeg", False) cmake.definitions["WITH_JAVA"] = self.options.get_safe("java", False) cmake.definitions["WITH_12BIT"] = self.options.enable12bit if is_msvc(self): cmake.definitions[ "WITH_CRT_DLL"] = True # avoid replacing /MD by /MT in compiler flags if tools.Version(self.version) <= "2.1.0": cmake.definitions[ "CMAKE_MACOSX_BUNDLE"] = False # avoid configuration error if building for iOS/tvOS/watchOS if tools.cross_building(self): # TODO: too specific and error prone, should be delegated to a conan helper function cmake_system_processor = { "armv8": "aarch64", "armv8.3": "aarch64", }.get(str(self.settings.arch), str(self.settings.arch)) cmake.definitions[ "CONAN_LIBJPEG_SYSTEM_PROCESSOR"] = cmake_system_processor cmake.configure() return cmake