def adjust_path(path, win_bash=False, subsystem=None, compiler=None): """ adjusts path to be safely passed to the compiler command line for Windows bash, ensures path is in format according to the subsystem for path with spaces, places double quotes around it converts slashes to backslashes, or vice versa """ if str(compiler) == 'Visual Studio': path = path.replace('/', '\\') else: path = path.replace('\\', '/') if win_bash: path = unix_path(path, subsystem) return '"%s"' % path if ' ' in path else path
def run_in_windows_bash_test(self): if platform.system() != "Windows": return conanfile = ''' from conans import ConanFile, tools class ConanBash(ConanFile): name = "bash" version = "0.1" settings = "os", "compiler", "build_type", "arch" def build(self): tools.run_in_windows_bash(self, "pwd") ''' client = TestClient() client.save({CONANFILE: conanfile}) client.run("export lasote/stable") client.run("install bash/0.1@lasote/stable --build") expected_curdir_base = unix_path(client.client_cache.conan(ConanFileReference.loads("bash/0.1@lasote/stable"))) self.assertIn(expected_curdir_base, client.user_io.out)
def test_wsl_path(self): self.assertEqual('/mnt/c/Windows/System32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.WSL))
def _configure_args(self): openssldir = self.options.openssldir if self.options.openssldir else os.path.join( self.package_folder, "res") prefix = tools.unix_path( self.package_folder) if self._win_bash else self.package_folder openssldir = tools.unix_path( openssldir) if self._win_bash else openssldir args = [ '"%s"' % (self._target if self._full_version >= "1.1.0" else self._ancestor_target), "shared" if self.options.shared else "no-shared", "--prefix=%s" % prefix, "--openssldir=%s" % openssldir, "no-unit-test" ] if self._full_version >= "1.1.1": args.append("PERL=%s" % self._perl) if self._full_version < "1.1.0" or self._full_version >= "1.1.1": args.append("no-tests") if self._full_version >= "1.1.0": args.append("--debug" if self.settings.build_type == "Debug" else "--release") if str(self.settings.os) == "Android": args.append(" -D__ANDROID_API__=%s" % str(self.settings.os.api_level)) # see NOTES.ANDROID if str(self.settings.os) == "Emscripten": args.append("-D__STDC_NO_ATOMICS__=1") if self.settings.os == "Windows": if self.options.capieng_dialog: args.append("-DOPENSSL_CAPIENG_DIALOG=1") else: args.append("-fPIC" if self.options.fPIC else "") if self.settings.os == "Neutrino": args.append("-lsocket no-asm") if "zlib" in self.deps_cpp_info.deps: zlib_info = self.deps_cpp_info["zlib"] include_path = zlib_info.include_paths[0] if self.settings.os == "Windows": lib_path = "%s/%s.lib" % (zlib_info.lib_paths[0], zlib_info.libs[0]) else: lib_path = zlib_info.lib_paths[ 0] # Just path, linux will find the right file if tools.os_info.is_windows: # clang-cl doesn't like backslashes in #define CFLAGS (builldinf.h -> cversion.c) include_path = include_path.replace('\\', '/') lib_path = lib_path.replace('\\', '/') args.extend([ '--with-zlib-include="%s"' % include_path, '--with-zlib-lib="%s"' % lib_path ]) for option_name in self.options.values.fields: activated = getattr(self.options, option_name) if activated and option_name not in [ "fPIC", "openssldir", "capieng_dialog" ]: self.output.info("activated option: %s" % option_name) args.append(option_name.replace("_", "-")) return args
def _get_configure_command_args(self): yes_no = lambda v: "yes" if v else "no" params = [ "--with-libidn2={}".format(yes_no(self.options.with_libidn)), "--with-librtmp={}".format(yes_no(self.options.with_librtmp)), "--with-libmetalink={}".format( yes_no(self.options.with_libmetalink)), "--with-libpsl={}".format(yes_no(self.options.with_libpsl)), "--with-schannel={}".format( yes_no(self.options.with_ssl == "schannel")), "--with-secure-transport={}".format( yes_no(self.options.with_ssl == "darwinssl")), "--with-brotli={}".format(yes_no(self.options.with_brotli)), "--enable-shared={}".format(yes_no(self.options.shared)), "--enable-static={}".format(yes_no(not self.options.shared)), "--enable-ldap={}".format(yes_no(self.options.with_ldap)), "--enable-debug={}".format( yes_no(self.settings.build_type == "Debug")), "--enable-ares={}".format(yes_no(self.options.with_c_ares)), "--enable-threaded-resolver={}".format( yes_no(self.options.with_c_ares)), ] if self.options.with_ssl == "openssl": params.append("--with-ssl={}".format( tools.unix_path(self.deps_cpp_info["openssl"].rootpath))) else: params.append("--without-ssl") if self.options.with_ssl == "wolfssl": params.append("--with-wolfssl={}".format( tools.unix_path(self.deps_cpp_info["wolfssl"].rootpath))) else: params.append("--without-wolfssl") if self.options.with_libssh2: params.append("--with-libssh2={}".format( tools.unix_path(self.deps_cpp_info["libssh2"].rootpath))) else: params.append("--without-libssh2") if self.options.with_nghttp2: params.append("--with-nghttp2={}".format( tools.unix_path(self.deps_cpp_info["libnghttp2"].rootpath))) else: params.append("--without-nghttp2") if self.options.with_zlib: params.append("--with-zlib={}".format( tools.unix_path(self.deps_cpp_info["zlib"].rootpath))) else: params.append("--without-zlib") if self._has_zstd_option: params.append("--with-zstd={}".format( yes_no(self.options.with_zstd))) # Cross building flags if tools.cross_building(self.settings): if self.settings.os == "Linux" and "arm" in self.settings.arch: params.append("--host=%s" % self._get_linux_arm_host()) elif self.settings.os == "iOS": params.append("--enable-threaded-resolver") params.append("--disable-verbose") elif self.settings.os == "Android": pass # this just works, conan is great! return params
def package_info(self): # library components self.cpp_info.components["libelf"].libs = ["elf"] self.cpp_info.components["libelf"].requires = ["zlib::zlib"] self.cpp_info.components["libdw"].libs = ["dw"] self.cpp_info.components["libdw"].requires = ["libelf", "zlib::zlib"] if self.options.with_bzlib: self.cpp_info.components["libdw"].requires.append("bzip2::bzip2") if self.options.with_lzma: self.cpp_info.components["libdw"].requires.append( "xz_utils::xz_utils") self.cpp_info.components["libasm"].includedirs = ["include/elfutils"] self.cpp_info.components["libasm"].libs = ["asm"] self.cpp_info.components["libasm"].requires = ["libelf", "libdw"] # utilities bin_path = os.path.join(self.package_folder, "bin") self.output.info("Appending PATH env var with : {}".format(bin_path)) self.env_info.PATH.append(bin_path) bin_ext = ".exe" if self.settings.os == "Windows" else "" addr2line = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-addr2line" + bin_ext)) self.output.info("Setting ADDR2LINE to {}".format(addr2line)) self.env_info.ADDR2LINE = addr2line ar = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-ar" + bin_ext)) self.output.info("Setting AR to {}".format(ar)) self.env_info.AR = ar elfclassify = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-elfclassify" + bin_ext)) self.output.info("Setting ELFCLASSIFY to {}".format(elfclassify)) self.env_info.ELFCLASSIFY = elfclassify elfcmp = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-elfcmp" + bin_ext)) self.output.info("Setting ELFCMP to {}".format(elfcmp)) self.env_info.ELFCMP = elfcmp elfcompress = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-elfcompress" + bin_ext)) self.output.info("Setting ELFCOMPRESS to {}".format(elfcompress)) self.env_info.ELFCOMPRESS = elfcompress elflint = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-elflint" + bin_ext)) self.output.info("Setting ELFLINT to {}".format(elflint)) self.env_info.ELFLINT = elflint findtextrel = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-findtextrel" + bin_ext)) self.output.info("Setting FINDTEXTREL to {}".format(findtextrel)) self.env_info.FINDTEXTREL = findtextrel make_debug_archive = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-make-debug-archive" + bin_ext)) self.output.info( "Setting MAKE_DEBUG_ARCHIVE to {}".format(make_debug_archive)) self.env_info.MAKE_DEBUG_ARCHIVE = make_debug_archive nm = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-nm" + bin_ext)) self.output.info("Setting NM to {}".format(nm)) self.env_info.NM = nm objdump = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-objdump" + bin_ext)) self.output.info("Setting OBJDUMP to {}".format(objdump)) self.env_info.OBJDUMP = objdump ranlib = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-ranlib" + bin_ext)) self.output.info("Setting RANLIB to {}".format(ranlib)) self.env_info.RANLIB = ranlib readelf = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-readelf" + bin_ext)) self.output.info("Setting READELF to {}".format(readelf)) self.env_info.READELF = readelf size = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-size" + bin_ext)) self.output.info("Setting SIZE to {}".format(size)) self.env_info.SIZE = size stack = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-stack" + bin_ext)) self.output.info("Setting STACK to {}".format(stack)) self.env_info.STACK = stack strings = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-strings" + bin_ext)) self.output.info("Setting STRINGS to {}".format(strings)) self.env_info.STRINGS = strings strip = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-strip" + bin_ext)) self.output.info("Setting STRIP to {}".format(strip)) self.env_info.STRIP = strip unstrip = tools.unix_path( os.path.join(self.package_folder, "bin", "eu-unstrip" + bin_ext)) self.output.info("Setting UNSTRIP to {}".format(unstrip)) self.env_info.UNSTRIP = unstrip
def _autotools_build_environment(self): with tools.chdir(self._source_subfolder): with tools.run_environment(self): with tools.environment_append({"PKG_CONFIG_PATH": tools.unix_path(self.build_folder)}): yield
def _configure_autotools(self): if self._autotools: return self._autotools self._autotools = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) build = None host = None conf_args = [ "--enable-widec" if self.options.with_widec else "--disable-widec", "--enable-ext-colors" if self.options.get_safe( "with_extended_colors", False) else "--disable-ext-colors", "--enable-reentrant" if self.options.with_reentrant else "--disable-reentrant", "--with-pcre2" if self.options.with_pcre2 else "--without-pcre2", "--with-cxx-binding" if self.options.with_cxx else "--without-cxx-binding", "--with-progs" if self.options.with_progs else "--without-progs", "--without-libtool", "--without-ada", "--without-manpages", "--without-tests", "--disable-echo", "--without-debug", "--without-profile", "--with-sp-funcs", "--disable-rpath", "--datarootdir={}".format( tools.unix_path( os.path.join(self.package_folder, "bin", "share"))), "--disable-pc-files", ] if self.options.shared: conf_args.extend([ "--with-shared", "--without-normal", "--with-cxx-shared", ]) else: conf_args.extend( ["--without-shared", "--with-normal", "--without-cxx-shared"]) if self.settings.os == "Windows": conf_args.extend([ "--disable-macros", "--disable-termcap", "--enable-database", "--enable-sp-funcs", "--enable-term-driver", "--enable-interop", ]) if self.settings.compiler == "Visual Studio": conf_args.extend([ "ac_cv_func_getopt=yes", ]) build = host = "{}-w64-mingw32-msvc7".format(self.settings.arch) self._autotools.flags.append("-FS") self._autotools.cxx_flags.append("-EHsc") self._autotools.configure(args=conf_args, configure_dir=self._source_subfolder, host=host, build=build) return self._autotools
def test_sfu_path(self): self.assertEqual( '/dev/fs/C/windows/system32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.SFU))
def _configure_args(self): openssldir = self.options.openssldir or self._get_default_openssl_dir() prefix = tools.unix_path( self.package_folder) if self._win_bash else self.package_folder openssldir = tools.unix_path( openssldir) if self._win_bash else openssldir args = [ '"%s"' % (self._target if self._full_version >= "1.1.0" else self._ancestor_target), "shared" if self.options.shared else "no-shared", "--prefix=\"%s\"" % prefix, "--openssldir=\"%s\"" % openssldir, "no-unit-test", "no-threads" if self.options.no_threads else "threads" ] if self._full_version >= "1.1.1": args.append("PERL=%s" % self._perl) if self._full_version < "1.1.0" or self._full_version >= "1.1.1": args.append("no-tests") if self._full_version >= "1.1.0": args.append("--debug" if self.settings.build_type == "Debug" else "--release") if self.settings.os in ["tvOS", "watchOS"]: args.append( " -DNO_FORK") # fork is not available on tvOS and watchOS if self.settings.os == "Android": args.append(" -D__ANDROID_API__=%s" % str(self.settings.os.api_level)) # see NOTES.ANDROID if self.settings.os == "Emscripten": args.append("-D__STDC_NO_ATOMICS__=1") if self.settings.os == "Windows": if self.options.enable_capieng: args.append("enable-capieng") if self.options.capieng_dialog: args.append("-DOPENSSL_CAPIENG_DIALOG=1") else: args.append( "-fPIC" if self.options.get_safe("fPIC", True) else "no-pic") if self.settings.os == "Neutrino": args.append("no-asm -lsocket -latomic") if self._full_version < "1.1.0": if self.options.get_safe("no_zlib"): args.append("no-zlib") else: zlib_info = self.deps_cpp_info["zlib"] include_path = zlib_info.include_paths[0] if self.settings.os == "Windows": lib_path = "%s/%s.lib" % (zlib_info.lib_paths[0], zlib_info.libs[0]) else: lib_path = zlib_info.lib_paths[ 0] # Just path, linux will find the right file # clang-cl doesn't like backslashes in #define CFLAGS (builldinf.h -> cversion.c) include_path = self._adjust_path(include_path) lib_path = self._adjust_path(lib_path) if zlib_info.shared: args.append("zlib-dynamic") else: args.append("zlib") args.extend([ '--with-zlib-include="%s"' % include_path, '--with-zlib-lib="%s"' % lib_path ]) for option_name in self.options.values.fields: activated = getattr(self.options, option_name) if activated and option_name not in [ "fPIC", "openssldir", "capieng_dialog", "enable_capieng" ]: self.output.info("activated option: %s" % option_name) args.append(option_name.replace("_", "-")) return args
def _configure_autotools(self): if self._autotools: return self._autotools self._autotools = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) self._autotools.libs = [] args = [ "--bit-depth=%s" % str(self.options.bit_depth), "--disable-cli", "--prefix={}".format(tools.unix_path(self.package_folder)), ] if self.options.shared: args.append("--enable-shared") else: args.append("--enable-static") if self.options.get_safe("fPIC", self.settings.os != "Windows"): args.append("--enable-pic") if self.settings.build_type == "Debug": args.append("--enable-debug") if self.settings.os == "Macos" and self.settings.arch == "armv8": # bitstream-a.S:29:18: error: unknown token in expression args.append("--extra-asflags=-arch arm64") args.append("--extra-ldflags=-arch arm64") args.append("--host=aarch64-apple-darwin") if self._with_nasm: # FIXME: get using user_build_info self._override_env["AS"] = os.path.join( self.dependencies.build["nasm"].package_folder, "bin", "nasm{}".format( ".exe" if tools.os_info.is_windows else "")).replace( "\\", "/") if tools.cross_building(self): if self.settings.os == "Android": # the as of ndk does not work well for building libx264 self._override_env["AS"] = os.environ["CC"] ndk_root = tools.unix_path(os.environ["NDK_ROOT"]) arch = { "armv7": "arm", "armv8": "aarch64", "x86": "i686", "x86_64": "x86_64", }.get(str(self.settings.arch)) abi = "androideabi" if self.settings.arch == "armv7" else "android" args.append("--cross-prefix={}".format( "{}/bin/{}-linux-{}-".format(ndk_root, arch, abi))) if self._is_msvc: self._override_env["CC"] = "cl -nologo" self._autotools.flags.append("-{}".format(msvc_runtime_flag(self))) if not (self.settings.compiler == "Visual Studio" and tools.Version(self.settings.compiler.version) < "12"): self._autotools.flags.append("-FS") build_canonical_name = None host_canonical_name = None if self._is_msvc: # autotools does not know about the msvc canonical name(s) build_canonical_name = False host_canonical_name = False self._autotools.configure(args=args, vars=self._override_env, configure_dir=self._source_subfolder, build=build_canonical_name, host=host_canonical_name) return self._autotools
def build_configure(self): with tools.chdir('sources'): prefix = tools.unix_path(self.package_folder) if self.settings.os == 'Windows' else self.package_folder args = ['--prefix=%s' % prefix, '--disable-doc', '--disable-programs'] if self.options.shared: args.extend(['--disable-static', '--enable-shared']) else: args.extend(['--disable-shared', '--enable-static', '--pkg-config-flags=--static']) if self.settings.build_type == 'Debug': args.extend(['--disable-optimizations', '--disable-mmx', '--disable-stripping', '--enable-debug']) if self.settings.compiler == 'Visual Studio': args.append('--toolchain=msvc') if self.settings.arch == 'x86': args.append('--arch=x86') args.append('--enable-postproc' if self.options.postproc else '--disable-postproc') args.append('--enable-pic' if self.options.fPIC else '--disable-pic') args.append('--enable-zlib' if self.options.zlib else '--disable-zlib') args.append('--enable-bzlib' if self.options.bzlib else '--disable-bzlib') args.append('--enable-lzma' if self.options.lzma else '--disable-lzma') args.append('--enable-iconv' if self.options.iconv else '--disable-iconv') args.append('--enable-libfreetype' if self.options.freetype else '--disable-libfreetype') args.append('--enable-libopenjpeg' if self.options.openjpeg else '--disable-libopenjpeg') args.append('--enable-libopenh264' if self.options.openh264 else '--disable-libopenh264') args.append('--enable-libvorbis' if self.options.vorbis else '--disable-libvorbis') args.append('--enable-libopus' if self.options.opus else '--disable-libopus') args.append('--enable-libzmq' if self.options.zmq else '--disable-libzmq') args.append('--enable-sdl2' if self.options.sdl2 else '--disable-sdl2') args.append('--enable-libx264' if self.options.x264 else '--disable-libx264') args.append('--enable-libx265' if self.options.x265 else '--disable-libx265') args.append('--enable-libvpx' if self.options.vpx else '--disable-libvpx') args.append('--enable-libmp3lame' if self.options.mp3lame else '--disable-libmp3lame') args.append('--enable-libfdk-aac' if self.options.fdk_aac else '--disable-libfdk-aac') if self.options.x264 or self.options.x265 or self.options.postproc: args.append('--enable-gpl') if self.options.fdk_aac: args.append('--enable-nonfree') if self.settings.os == "Linux": args.append('--enable-alsa' if self.options.alsa else '--disable-alsa') args.append('--enable-jack' if self.options.jack else '--disable-jack') args.append('--enable-libpulse' if self.options.pulse else '--disable-libpulse') args.append('--enable-vaapi' if self.options.vaapi else '--disable-vaapi') args.append('--enable-vdpau' if self.options.vdpau else '--disable-vdpau') if self.options.xcb: args.extend(['--enable-libxcb', '--enable-libxcb-shm', '--enable-libxcb-shape', '--enable-libxcb-xfixes']) else: args.extend(['--disable-libxcb', '--disable-libxcb-shm', '--disable-libxcb-shape', '--disable-libxcb-xfixes']) if self.settings.os == "Macos": args.append('--enable-appkit' if self.options.appkit else '--disable-appkit') args.append('--enable-avfoundation' if self.options.avfoundation else '--disable-avfoundation') args.append('--enable-coreimage' if self.options.avfoundation else '--disable-coreimage') args.append('--enable-audiotoolbox' if self.options.audiotoolbox else '--disable-audiotoolbox') args.append('--enable-videotoolbox' if self.options.videotoolbox else '--disable-videotoolbox') args.append('--enable-vda' if self.options.vda else '--disable-vda') args.append('--enable-securetransport' if self.options.securetransport else '--disable-securetransport') if self.settings.os == "Windows": args.append('--enable-libmfx' if self.options.qsv else '--disable-libmfx') # FIXME disable CUDA and CUVID by default, revisit later args.extend(['--disable-cuda', '--disable-cuvid']) os.makedirs('pkgconfig') if self.options.freetype: self.copy_pkg_config('freetype') self.copy_pkg_config('libpng') if self.options.opus: self.copy_pkg_config('opus') if self.options.vorbis: self.copy_pkg_config('ogg') self.copy_pkg_config('vorbis') if self.options.zmq: self.copy_pkg_config('zmq') if self.options.sdl2: self.copy_pkg_config('sdl2') if self.options.x264: self.copy_pkg_config('libx264') if self.options.x265: self.copy_pkg_config('libx265') if self.options.vpx: self.copy_pkg_config('libvpx') if self.options.fdk_aac: self.copy_pkg_config('libfdk_aac') if self.options.openh264: self.copy_pkg_config('openh264') env_vars = {'PKG_CONFIG_PATH': os.path.abspath('pkgconfig')} if self.settings.compiler == 'Visual Studio': args.append('--extra-cflags=-%s' % self.settings.compiler.runtime) if int(str(self.settings.compiler.version)) <= 12: args.append('--extra-cflags=-Dsnprintf=_snprintf') with tools.environment_append(env_vars): env_build = AutoToolsBuildEnvironment(self, win_bash=self.is_mingw or self.is_msvc) # ffmpeg's configure is not actually from autotools, so it doesn't understand standard options like # --host, --build, --target env_build.configure(args=args, build=False, host=False, target=False) env_build.make()
def build_configure(self): with tools.chdir(self._source_subfolder): prefix = tools.unix_path( self.package_folder ) if self.settings.os == "Windows" else self.package_folder args = [ "--prefix=%s" % prefix, "--disable-doc", "--disable-programs" ] if self.options.shared: args.extend(["--disable-static", "--enable-shared"]) else: args.extend(["--disable-shared", "--enable-static"]) args.append("--pkg-config-flags=--static") 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 "CC" in os.environ: args.append("--cc=%s" % os.environ["CC"]) if "CXX" in os.environ: args.append("--cxx=%s" % os.environ["CXX"]) if self._is_msvc: args.append("--toolchain=msvc") args.append("--extra-cflags=-%s" % self.settings.compiler.runtime) if int(str(self.settings.compiler.version)) <= 12: # Visual Studio 2013 (and earlier) doesn"t support "inline" keyword for C (only for C++) args.append("--extra-cflags=-Dinline=__inline" % self.settings.compiler.runtime) if self.settings.arch == "x86": args.append("--arch=x86") if self.settings.os != "Windows": args.append( "--enable-pic" if self.options.fPIC else "--disable-pic") args.append("--enable-postproc" if self.options. postproc else "--disable-postproc") args.append( "--enable-zlib" if self.options.zlib else "--disable-zlib") args.append( "--enable-bzlib" if self.options.bzlib else "--disable-bzlib") args.append( "--enable-lzma" if self.options.lzma else "--disable-lzma") args.append( "--enable-iconv" if self.options.iconv else "--disable-iconv") args.append("--enable-libfreetype" if self.options. freetype else "--disable-libfreetype") args.append("--enable-libopenjpeg" if self.options. openjpeg else "--disable-libopenjpeg") args.append("--enable-libopenh264" if self.options. openh264 else "--disable-libopenh264") args.append("--enable-libvorbis" if self.options. vorbis else "--disable-libvorbis") args.append("--enable-libopus" if self.options. opus else "--disable-libopus") args.append( "--enable-libzmq" if self.options.zmq else "--disable-libzmq") args.append( "--enable-sdl2" if self.options.sdl2 else "--disable-sdl2") args.append("--enable-libx264" if self.options. x264 else "--disable-libx264") args.append("--enable-libx265" if self.options. x265 else "--disable-libx265") args.append( "--enable-libvpx" if self.options.vpx else "--disable-libvpx") args.append("--enable-libmp3lame" if self.options. mp3lame else "--disable-libmp3lame") args.append("--enable-libfdk-aac" if self.options. fdk_aac else "--disable-libfdk-aac") args.append("--enable-libwebp" if self.options. webp else "--disable-libwebp") args.append("--enable-openssl" if self.options. openssl else "--disable-openssl") if self.options.x264 or self.options.x265 or self.options.postproc: args.append('--enable-gpl') enable_gpl = True if self.options.fdk_aac or (enable_gpl and self.options.openssl): args.append('--enable-nonfree') if self.settings.os == "Linux": args.append( "--enable-alsa" if self.options.alsa else "--disable-alsa") args.append("--enable-libpulse" if self.options. pulse else "--disable-libpulse") args.append("--enable-vaapi" if self.options. vaapi else "--disable-vaapi") args.append("--enable-vdpau" if self.options. vdpau else "--disable-vdpau") if self.options.xcb: args.extend([ "--enable-libxcb", "--enable-libxcb-shm", "--enable-libxcb-shape", "--enable-libxcb-xfixes" ]) else: args.extend([ "--disable-libxcb", "--disable-libxcb-shm", "--disable-libxcb-shape", "--disable-libxcb-xfixes" ]) if self.settings.os == "Macos": args.append("--enable-appkit" if self.options. appkit else "--disable-appkit") args.append("--enable-avfoundation" if self.options. avfoundation else "--disable-avfoundation") args.append("--enable-coreimage" if self.options. avfoundation else "--disable-coreimage") args.append("--enable-audiotoolbox" if self.options. audiotoolbox else "--disable-audiotoolbox") args.append("--enable-videotoolbox" if self.options. videotoolbox else "--disable-videotoolbox") args.append("--enable-securetransport" if self.options. securetransport else "--disable-securetransport") if self.settings.os == "Windows": args.append("--enable-libmfx" if self.options. qsv else "--disable-libmfx") # FIXME disable CUDA and CUVID by default, revisit later args.extend(["--disable-cuda", "--disable-cuvid"]) env_build = AutoToolsBuildEnvironment( self, win_bash=self._is_mingw_windows or self._is_msvc) # ffmpeg"s configure is not actually from autotools, so it doesn"t understand standard options like # --host, --build, --target env_build.configure(args=args, build=False, host=False, target=False) env_build.make() env_build.make(args=["install"])
def _configure_autotools(self): args = [ "--prefix={}".format(tools.unix_path(self.package_folder)), "--disable-examples", "--disable-unit-tests", "--disable-tools", "--disable-docs", "--enable-vp9-highbitdepth", "--as=yasm", ] if self.options.shared: args.extend(['--disable-static', '--enable-shared']) else: args.extend(['--disable-shared', '--enable-static']) if self.settings.os != 'Windows' and self.options.get_safe( "fPIC", True): args.append('--enable-pic') if self.settings.build_type == "Debug": args.append('--enable-debug') if self._is_msvc and "MT" in msvc_runtime_flag(self): args.append('--enable-static-msvcrt') arch = { 'x86': 'x86', 'x86_64': 'x86_64', 'armv7': 'armv7', 'armv8': 'arm64', 'mips': 'mips32', 'mips64': 'mips64', 'sparc': 'sparc' }.get(str(self.settings.arch)) if self._is_msvc: if self.settings.compiler == "Visual Studio": vc_version = self.settings.compiler.version else: vc_version = msvc_version_to_vs_ide_version( self.settings.compiler.version) compiler = "vs{}".format(vc_version) elif self.settings.compiler in ["gcc", "clang", "apple-clang"]: compiler = 'gcc' host_os = str(self.settings.os) if host_os == 'Windows': os_name = 'win32' if self.settings.arch == 'x86' else 'win64' elif tools.is_apple_os(host_os): if self.settings.arch in ["x86", "x86_64"]: os_name = 'darwin11' elif self.settings.arch == "armv8" and self.settings.os == "Macos": os_name = 'darwin20' else: # Unrecognized toolchain 'arm64-darwin11-gcc', see list of toolchains in ./configure --help os_name = 'darwin' elif host_os == 'Linux': os_name = 'linux' elif host_os == 'Solaris': os_name = 'solaris' elif host_os == 'Android': os_name = 'android' target = "%s-%s-%s" % (arch, os_name, compiler) args.append('--target=%s' % target) if str(self.settings.arch) in ["x86", "x86_64"]: for name in self._arch_options: if not self.options.get_safe(name): args.append('--disable-%s' % name) autotools = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) if self._is_msvc: # gen_msvs_vcxproj.sh doesn't like custom flags autotools.cxxflags = [] autotools.flags = [] if tools.is_apple_os(self.settings.os) and self.settings.get_safe( "compiler.libcxx") == "libc++": # special case, as gcc/g++ is hard-coded in makefile, it implicitly assumes -lstdc++ autotools.link_flags.append("-stdlib=libc++") autotools.configure(args=args, configure_dir=self._source_subfolder, host=False, build=False, target=False) return autotools
def test_msys_path(self): self.assertEqual('/c/windows/system32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.MSYS2))
def _make_program(self): return tools.unix_path( tools.get_env("CONAN_MAKE_PROGRAM", tools.which("make") or tools.which("mingw32-make")))
def _configure_cmd(self): if self.settings.compiler in ('clang', 'apple-clang'): botan_compiler = 'clang' elif self.settings.compiler == 'gcc': botan_compiler = 'gcc' else: botan_compiler = 'msvc' botan_abi_flags = [] botan_extra_cxx_flags = [] build_flags = [] if self._is_linux_clang_libcxx: botan_abi_flags.extend(["-stdlib=libc++", "-lc++abi"]) if botan_compiler in ['clang', 'apple-clang', 'gcc']: if self.settings.arch == "x86": botan_abi_flags.append('-m32') elif self.settings.arch == "x86_64": botan_abi_flags.append('-m64') if self.settings.os != "Windows" and self.options.fPIC: botan_extra_cxx_flags.append('-fPIC') if tools.is_apple_os(self.settings.os): if self.settings.get_safe("os.version"): 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 test_msys_path(self): self.assertEqual( '/c/windows/system32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.MSYS2))
def build(self): self.output.info("") self.output.info("---------- build ----------") self.output.info("") self.output.info("os : " + str(self.settings.os)) self.output.info("arch : " + str(self.settings.arch)) self.output.info("compiler : " + str(self.settings.compiler) + " " + str(self.settings.compiler.version)) self.output.info("build type: " + str(self.settings.build_type)) if self.settings.compiler == "Visual Studio": self.output.info("runtime : " + str(self.settings.compiler.runtime)) else: self.output.info("libcxx : " + str(self.settings.compiler.libcxx)) ffmpegInstallDir = "install" params = "" params += " --disable-doc" params += " --disable-bzlib" params += " --disable-lzma" params += " --disable-zlib" if self.settings.os == "Windows": params += " --disable-avdevice" params += " --disable-ffmpeg" params += " --disable-ffplay" params += " --disable-ffprobe" params += " --disable-iconv" params += " --disable-libopenjpeg" params += " --enable-asm" params += " --enable-yasm" params += " --prefix=\"" + tools.unix_path(ffmpegInstallDir) + "\"" else: params += " --prefix=\"" + ffmpegInstallDir + "\"" if self.settings.build_type == "Debug": params += " --enable-debug" if self.settings.compiler == "Visual Studio": # use --disable-encoder=ffv1 flag for Visual Studio 2010 to avoid make compilation loop if self.settings.compiler.version == "10": params += " --disable-encoder=ffv1" params += " --toolchain=msvc" params += " --extra-cflags=\"-" + str( self.settings.compiler.runtime) + "\"" params += " --extra-cxxflags=\"-" + str( self.settings.compiler.runtime) + "\"" if self.settings.arch == "x86": params += " --arch=x86" params += " --target-os=win32" else: params += " --arch=amd64" if self.settings.compiler.runtime == "MT": params += " --extra-ldflags=\"/NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcd.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib /NODEFAULTLIB:libcmtd.lib\"" elif self.settings.compiler.runtime == "MTd": params += " --extra-ldflags=\"/NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcd.lib /NODEFAULTLIB:msvcrt.lib /NODEFAULTLIB:msvcrtd.lib /NODEFAULTLIB:libcmt.lib\"" elif self.settings.compiler.runtime == "MD": params += " --extra-ldflags=\"/NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcd.lib /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:libcmtd.lib /NODEFAULTLIB:msvcrtd.lib\"" elif self.settings.compiler.runtime == "MDd": params += " --extra-ldflags=\"/NODEFAULTLIB:libc.lib /NODEFAULTLIB:libcd.lib /NODEFAULTLIB:libcmt.lib /NODEFAULTLIB:libcmtd.lib /NODEFAULTLIB:msvcrt.lib\"" else: raise Exception("unsupported runtime: " + str(self.settings.compiler.runtime)) elif self.settings.arch == "armv7hf" and not re.match( "arm.*", platform.machine()): if not "CC" in os.environ: raise Exception( "failed to extract compiler from environment variable \"CC\" (variable is not set)" ) result = re.search("(.*)gcc$", os.environ.get("CC"), re.M | re.I) if not result: raise Exception( "failed to extract compiler from environment variable \"CC\" (variable value does not end with \"gcc\", e.g. \"arm-linux-gnueabihf-gcc\")" ) params += " --enable-cross-compile --cross-prefix=" + result.group( 1) + " --arch=armhf --target-os=linux" with tools.chdir(self.name): command = "" if self.settings.os == "Windows": if self.settings.compiler == "Visual Studio": command += tools.vcvars_command(self.settings) command += " && bash.exe -c \"./configure" + params + "\"" command += " && bash.exe -c \"make -j" + str( tools.cpu_count()) + " install\"" else: command = "./configure" + params command += " && make -j" + str(tools.cpu_count()) + " install" self.output.info("") self.output.info("executing the following commands:") self.output.info(command) self.run(command) if not os.path.exists(ffmpegInstallDir): raise Exception("install directory does not exist: " + ffmpegInstallDir) if self.settings.os == "Windows": libDir = os.path.join(ffmpegInstallDir, "lib") for f in os.listdir(libDir): if f.endswith(".a"): base = os.path.splitext(f)[0] src = os.path.join(libDir, f) dst = os.path.join(libDir, base + ".lib") os.rename(src, dst)
def _configure_autotools(self): autotools = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows) yes_no = lambda v: "yes" if v else "no" internal_no = lambda v: "internal" if v else "no" rootpath = lambda req: tools.unix_path(self.deps_cpp_info[req].rootpath) rootpath_no = lambda v, req: rootpath(req) if v else "no" args = [] args.append("--datarootdir={}".format(tools.unix_path(os.path.join(self.package_folder, "res")))) # Shared/Static args.extend([ "--enable-static={}".format(yes_no(not self.options.shared)), "--enable-shared={}".format(yes_no(self.options.shared)), ]) args.append("--includedir={}".format(tools.unix_path(os.path.join(self.package_folder, "include", "gdal")))) # Enable C++14 if requested in conan profile or if with_charls enabled if (self.settings.compiler.cppstd and tools.valid_min_cppstd(self, 14)) or self.options.with_charls: args.append("--with-cpp14") # Debug if self.settings.build_type == "Debug": args.append("--enable-debug") # SIMD Intrinsics simd_intrinsics = self.options.get_safe("simd_intrinsics", False) if not simd_intrinsics: args.extend(["--without-sse", "--without-ssse3", "--without-avx"]) elif simd_intrinsics == "sse": args.extend(["--with-sse", "--without-ssse3", "--without-avx"]) elif simd_intrinsics == "ssse3": args.extend(["--with-sse", "--with-ssse3", "--without-avx"]) elif simd_intrinsics == "avx": args.extend(["--with-sse", "--with-ssse3", "--with-avx"]) # LTO (disabled) args.append("--disable-lto") # Symbols args.append("--with-hide_internal_symbols") # Do not add /usr/local/lib and /usr/local/include args.append("--without-local") # Threadsafe args.append("--with-threads={}".format(yes_no(self.options.threadsafe))) # Depencencies: args.append("--with-proj=yes") # always required ! args.append("--with-libz={}".format(yes_no(self.options.with_zlib))) if self._has_with_libdeflate_option: args.append("--with-libdeflate={}".format(yes_no(self.options.with_libdeflate))) args.append("--with-libiconv-prefix={}".format(rootpath_no(self.options.with_libiconv, "libiconv"))) args.append("--with-liblzma=no") # always disabled: liblzma is an optional transitive dependency of gdal (through libtiff). args.append("--with-zstd={}".format(yes_no(self.options.get_safe("with_zstd")))) # Optional direct dependency of gdal only if lerc lib enabled if self._has_with_blosc_option: args.append("--with-blosc={}".format(yes_no(self.options.with_blosc))) if self._has_with_lz4_option: args.append("--with-lz4={}".format(yes_no(self.options.with_lz4))) # Drivers: if not (self.options.with_zlib and self.options.with_png and bool(self.options.with_jpeg)): # MRF raster driver always depends on zlib, libpng and libjpeg: https://github.com/OSGeo/gdal/issues/2581 if tools.Version(self.version) < "3.0.0": args.append("--without-mrf") else: args.append("--disable-driver-mrf") args.append("--with-pg={}".format(yes_no(self.options.with_pg))) args.extend(["--without-grass", "--without-libgrass"]) # TODO: to implement when libgrass lib available args.append("--with-cfitsio={}".format(rootpath_no(self.options.with_cfitsio, "cfitsio"))) args.append("--with-pcraster={}".format(internal_no(self.options.with_pcraster))) # TODO: use conan recipe when available instead of internal one args.append("--with-png={}".format(rootpath_no(self.options.with_png, "libpng"))) args.append("--with-dds={}".format(rootpath_no(self.options.with_dds, "crunch"))) args.append("--with-gta={}".format(rootpath_no(self.options.with_gta, "libgta"))) args.append("--with-pcidsk={}".format(internal_no(self.options.with_pcidsk))) # TODO: use conan recipe when available instead of internal one args.append("--with-libtiff={}".format(rootpath("libtiff"))) # always required ! args.append("--with-geotiff={}".format(rootpath("libgeotiff"))) # always required ! if self.options.with_jpeg == "libjpeg": args.append("--with-jpeg={}".format(rootpath("libjpeg"))) elif self.options.with_jpeg == "libjpeg-turbo": args.append("--with-jpeg={}".format(rootpath("libjpeg-turbo"))) else: args.append("--without-jpeg") args.append("--without-jpeg12") # disabled: it requires internal libjpeg and libgeotiff args.append("--with-charls={}".format(yes_no(self.options.with_charls))) args.append("--with-gif={}".format(rootpath_no(self.options.with_gif, "giflib"))) args.append("--without-ogdi") # TODO: to implement when ogdi lib available (https://sourceforge.net/projects/ogdi/) args.append("--without-fme") # commercial library args.append("--without-sosi") # TODO: to implement when fyba lib available args.append("--without-mongocxx") # TODO: handle mongo-cxx-driver v2 args.append("--with-mongocxxv3={}".format(yes_no(self.options.with_mongocxx))) args.append("--with-hdf4={}".format(yes_no(self.options.with_hdf4))) args.append("--with-hdf5={}".format(yes_no(self.options.with_hdf5))) args.append("--with-kea={}".format(yes_no(self.options.with_kea))) args.append("--with-netcdf={}".format(rootpath_no(self.options.with_netcdf, "netcdf"))) args.append("--with-jasper={}".format(rootpath_no(self.options.with_jasper, "jasper"))) args.append("--with-openjpeg={}".format(yes_no(self.options.with_openjpeg))) args.append("--without-fgdb") # TODO: to implement when file-geodatabase-api lib available args.append("--without-ecw") # commercial library args.append("--without-kakadu") # commercial library args.extend(["--without-mrsid", "--without-jp2mrsid", "--without-mrsid_lidar"]) # commercial library args.append("--without-jp2lura") # commercial library args.append("--without-msg") # commercial library args.append("--without-oci") # TODO args.append("--with-gnm={}".format(yes_no(self.options.with_gnm))) args.append("--with-mysql={}".format(yes_no(self.options.with_mysql))) args.append("--without-ingres") # commercial library args.append("--with-xerces={}".format(rootpath_no(self.options.with_xerces, "xerces-c"))) args.append("--with-expat={}".format(yes_no(self.options.with_expat))) args.append("--with-libkml={}".format(rootpath_no(self.options.with_libkml, "libkml"))) if self.options.with_odbc: args.append("--with-odbc={}".format("yes" if self.settings.os == "Windows" else rootpath("odbc"))) else: args.append("--without-odbc") args.append("--without-dods-root") # TODO: to implement when libdap lib available args.append("--with-curl={}".format(yes_no(self.options.with_curl))) args.append("--with-xml2={}".format(yes_no(self.options.with_xml2))) args.append("--without-spatialite") # TODO: to implement when libspatialite lib available args.append("--with-sqlite3={}".format(yes_no(self.options.get_safe("with_sqlite3")))) args.append("--without-rasterlite2") # TODO: to implement when rasterlite2 lib available if self._has_with_pcre2_option: args.append("--with-pcre2={}".format(yes_no(self.options.get_safe("with_pcre2")))) args.append("--with-pcre={}".format(yes_no(self.options.get_safe("with_pcre")))) args.append("--without-teigha") # commercial library args.append("--without-idb") # commercial library if tools.Version(self.version) < "3.2.0": args.append("--without-sde") # commercial library if tools.Version(self.version) < "3.3.0": args.append("--without-epsilon") args.append("--with-webp={}".format(rootpath_no(self.options.with_webp, "libwebp"))) args.append("--with-geos={}".format(yes_no(self.options.with_geos))) args.append("--without-sfcgal") # TODO: to implement when sfcgal lib available args.append("--with-qhull={}".format(yes_no(self.options.with_qhull))) if self.options.with_opencl: args.extend([ "--with-opencl", "--with-opencl-include={}".format(tools.unix_path(self.deps_cpp_info["opencl-headers"].include_paths[0])), "--with-opencl-lib=-L{}".format(tools.unix_path(self.deps_cpp_info["opencl-icd-loader"].lib_paths[0])) ]) else: args.append("--without-opencl") args.append("--with-freexl={}".format(yes_no(self.options.with_freexl))) args.append("--with-libjson-c={}".format(rootpath("json-c"))) # always required ! if self.options.without_pam: args.append("--without-pam") args.append("--with-poppler={}".format(yes_no(self.options.with_poppler))) args.append("--with-podofo={}".format(rootpath_no(self.options.with_podofo, "podofo"))) if self.options.with_podofo: args.append("--with-podofo-lib=-l{}".format(" -l".join(self._gather_libs("podofo")))) args.append("--without-pdfium") # TODO: to implement when pdfium lib available args.append("--without-perl") args.append("--without-python") args.append("--without-java") args.append("--without-hdfs") if tools.Version(self.version) >= "3.0.0": args.append("--without-tiledb") # TODO: to implement when tiledb lib available args.append("--without-mdb") args.append("--without-rasdaman") # TODO: to implement when rasdaman lib available if self._has_with_brunsli_option: args.append("--with-brunsli={}".format(yes_no(self.options.with_brunsli))) if tools.Version(self.version) >= "3.1.0": args.append("--without-rdb") # commercial library args.append("--without-armadillo") # TODO: to implement when armadillo lib available args.append("--with-cryptopp={}".format(rootpath_no(self.options.with_cryptopp, "cryptopp"))) args.append("--with-crypto={}".format(yes_no(self.options.with_crypto))) if tools.Version(self.version) >= "3.3.0": args.append("--with-lerc={}".format(internal_no(not self.options.without_lerc))) else: args.append("--with-lerc={}".format(yes_no(not self.options.without_lerc))) if self.options.with_null: args.append("--with-null") if self._has_with_exr_option: args.append("--with-exr={}".format(yes_no(self.options.with_exr))) if self._has_with_heif_option: args.append("--with-heif={}".format(yes_no(self.options.with_heif))) # Inject -stdlib=libc++ for clang with libc++ env_build_vars = autotools.vars if self.settings.compiler == "clang" and \ self.settings.os == "Linux" and tools.stdcpp_library(self) == "c++": env_build_vars["LDFLAGS"] = "-stdlib=libc++ {}".format(env_build_vars["LDFLAGS"]) autotools.configure(args=args, vars=env_build_vars) return autotools
def _configure_cmd(self): if self.settings.compiler in ('clang', 'apple-clang'): botan_compiler = 'clang' elif self.settings.compiler == 'gcc': botan_compiler = 'gcc' else: botan_compiler = 'msvc' botan_abi_flags = [] botan_extra_cxx_flags = [] build_flags = [] if self._is_linux_clang_libcxx: botan_abi_flags.extend(["-stdlib=libc++", "-lc++abi"]) if botan_compiler in ['clang', 'apple-clang', 'gcc']: if self.settings.arch == "x86": botan_abi_flags.append('-m32') elif self.settings.arch == "x86_64": botan_abi_flags.append('-m64') if self.settings.os != "Windows" and self.options.fPIC: botan_extra_cxx_flags.append('-fPIC') if self.settings.os == "Macos" and self.settings.os.version: macos_min_version = tools.apple_deployment_target_flag( self.settings.os, self.settings.os.version) macos_sdk_path = "-isysroot {}".format( tools.XCRun(self.settings).sdk_path) botan_extra_cxx_flags.extend([macos_min_version, macos_sdk_path]) # This is to work around botan's configure script that *replaces* its # standard (platform dependent) flags in presence of an environment # variable ${CXXFLAGS}. Most notably, this would build botan with # disabled compiler optimizations. environment_cxxflags = tools.get_env("CXXFLAGS") if environment_cxxflags: del os.environ["CXXFLAGS"] botan_extra_cxx_flags.append(environment_cxxflags) if self.options.enable_modules: build_flags.append('--minimized-build') build_flags.append('--enable-modules={}'.format( self.options.enable_modules)) if self.options.amalgamation: build_flags.append('--amalgamation') if self.options.single_amalgamation: build_flags.append('--single-amalgamation-file') if self.options.system_cert_bundle: build_flags.append('--system-cert-bundle={}'.format( self.options.system_cert_bundle)) if self.options.bzip2: build_flags.append('--with-bzip2') build_flags.extend(self._dependency_build_flags("bzip2")) if self.options.openssl: build_flags.append('--with-openssl') build_flags.extend(self._dependency_build_flags("OpenSSL")) if self.options.quiet: build_flags.append('--quiet') if self.options.sqlite3: build_flags.append('--with-sqlite3') build_flags.extend(self._dependency_build_flags("sqlite3")) if self.options.zlib: build_flags.append('--with-zlib') build_flags.extend(self._dependency_build_flags("zlib")) if self.options.boost: build_flags.append('--with-boost') build_flags.extend(self._dependency_build_flags("boost")) # required boost libraries are listed in Botan's src/utils/boost/info.txt # under the <libs></libs> tag... # Note that boost_system is actually a header-only library as of # boost 1.69. We are linking this for compatibility with older boost # versions... boost_system = [ lib for lib in self.deps_cpp_info["boost"].libs if "boost_system" in lib ] if len(boost_system) != 1: raise ConanException( "did not find a comprehensive boost_system library name: " + str(boost_system)) boost_system_name = boost_system[ 0] + ".lib" if self.settings.os == "Windows" else boost_system[ 0] build_flags.append( '--boost-library-name={}'.format(boost_system_name)) if self.settings.build_type == 'RelWithDebInfo' or self.options.debug_info: build_flags.append('--with-debug-info') if str(self.settings.build_type).lower() == 'debug': build_flags.append('--debug-mode') build_targets = ["shared"] if self.options.shared else ["static"] if self._is_mingw_windows: build_flags.append('--without-stack-protector') if self.settings.compiler == 'Visual Studio': build_flags.append('--msvc-runtime=%s' % str(self.settings.compiler.runtime)) call_python = 'python' if self.settings.os == 'Windows' else '' prefix = tools.unix_path( self.package_folder ) if self._is_mingw_windows else self.package_folder botan_abi = ' '.join(botan_abi_flags) if botan_abi_flags else ' ' botan_cxx_extras = ' '.join( botan_extra_cxx_flags) if botan_extra_cxx_flags else ' ' configure_cmd = ('{python_call} ./configure.py' ' --build-targets={targets}' ' --distribution-info="Conan"' ' --without-documentation' ' --cc-abi-flags="{abi}"' ' --extra-cxxflags="{cxxflags}"' ' --cc={compiler}' ' --cpu={cpu}' ' --prefix={prefix}' ' --os={os}' ' {build_flags}').format( python_call=call_python, targets=",".join(build_targets), abi=botan_abi, cxxflags=botan_cxx_extras, compiler=botan_compiler, cpu=self.settings.arch, prefix=prefix, os=self._botan_os, build_flags=' '.join(build_flags)) return configure_cmd
def _get_configure_command_args(self): yes_no = lambda v: "yes" if v else "no" params = [ "--with-libidn2={}".format(yes_no(self.options.with_libidn)), "--with-librtmp={}".format(yes_no(self.options.with_librtmp)), "--with-libpsl={}".format(yes_no(self.options.with_libpsl)), "--with-schannel={}".format( yes_no(self.options.with_ssl == "schannel")), "--with-secure-transport={}".format( yes_no(self.options.with_ssl == "darwinssl")), "--with-brotli={}".format(yes_no(self.options.with_brotli)), "--enable-shared={}".format(yes_no(self.options.shared)), "--enable-static={}".format(yes_no(not self.options.shared)), "--enable-dict={}".format(yes_no(self.options.with_dict)), "--enable-file={}".format(yes_no(self.options.with_file)), "--enable-ftp={}".format(yes_no(self.options.with_ftp)), "--enable-gopher={}".format(yes_no(self.options.with_gopher)), "--enable-http={}".format(yes_no(self.options.with_http)), "--enable-imap={}".format(yes_no(self.options.with_imap)), "--enable-ldap={}".format(yes_no(self.options.with_ldap)), "--enable-mqtt={}".format(yes_no(self.options.with_mqtt)), "--enable-pop3={}".format(yes_no(self.options.with_pop3)), "--enable-rtsp={}".format(yes_no(self.options.with_rtsp)), "--enable-smb={}".format(yes_no(self.options.with_smb)), "--enable-smtp={}".format(yes_no(self.options.with_smtp)), "--enable-telnet={}".format(yes_no(self.options.with_telnet)), "--enable-tftp={}".format(yes_no(self.options.with_tftp)), "--enable-debug={}".format( yes_no(self.settings.build_type == "Debug")), "--enable-ares={}".format(yes_no(self.options.with_c_ares)), "--enable-threaded-resolver={}".format( yes_no(self.options.with_c_ares)), "--enable-cookies={}".format(yes_no(self.options.with_cookies)), "--enable-ipv6={}".format(yes_no(self.options.with_ipv6)), "--enable-manual={}".format(yes_no(self.options.with_docs)), "--enable-verbose={}".format( yes_no(self.options.with_verbose_debug)), "--enable-symbol-hiding={}".format( yes_no(self.options.with_symbol_hiding)), "--enable-unix-sockets={}".format( yes_no(self.options.with_unix_sockets)), ] if self.options.with_ssl == "openssl": params.append("--with-ssl={}".format( tools.unix_path(self.deps_cpp_info["openssl"].rootpath))) else: params.append("--without-ssl") if self.options.with_ssl == "wolfssl": params.append("--with-wolfssl={}".format( tools.unix_path(self.deps_cpp_info["wolfssl"].rootpath))) else: params.append("--without-wolfssl") if self.options.with_libssh2: params.append("--with-libssh2={}".format( tools.unix_path(self.deps_cpp_info["libssh2"].rootpath))) else: params.append("--without-libssh2") if self.options.with_nghttp2: params.append("--with-nghttp2={}".format( tools.unix_path(self.deps_cpp_info["libnghttp2"].rootpath))) else: params.append("--without-nghttp2") if self.options.with_zlib: params.append("--with-zlib={}".format( tools.unix_path(self.deps_cpp_info["zlib"].rootpath))) else: params.append("--without-zlib") if self._has_zstd_option: params.append("--with-zstd={}".format( yes_no(self.options.with_zstd))) if self._has_metalink_option: params.append("--with-libmetalink={}".format( yes_no(self.options.with_libmetalink))) if not self.options.with_proxy: params.append("--disable-proxy") if not self.options.with_rtsp: params.append("--disable-rtsp") if not self.options.with_crypto_auth: params.append( "--disable-crypto-auth" ) # also disables NTLM in versions of curl prior to 7.78.0 # ntlm will default to enabled if any SSL options are enabled if not self.options.with_ntlm: if tools.Version(self.version) <= "7.77.0": params.append("--disable-crypto-auth") else: params.append("--disable-ntlm") if not self.options.with_ntlm_wb: params.append("--disable-ntlm-wb") # Cross building flags if tools.cross_building(self.settings): if self.settings.os == "Linux" and "arm" in self.settings.arch: params.append("--host=%s" % self._get_linux_arm_host()) elif self.settings.os == "iOS": params.append("--enable-threaded-resolver") params.append("--disable-verbose") elif self.settings.os == "Android": pass # this just works, conan is great! return params
def _unix_path(self, path): if self.settings.os == "Windows": return tools.unix_path(path) return path
def windows_build(self): # this overrides pre-configured environments (such as Appveyor's) if "VisualStudioVersion" in os.environ: del os.environ["VisualStudioVersion"] compiler_cxx = compiler_cc = '$PWD/ragel-%s/compile cl -nologo' % self.version self.autotools = AutoToolsBuildEnvironment(self, win_bash=True) with tools.chdir("{0}-{1}".format('ragel', self.version)): tools.run_in_windows_bash( self, 'pacman -S automake-wrapper autoconf --noconfirm --needed') makefile_am = os.path.join('ragel', 'Makefile.am').replace('\\', '/') self.output.info("Patching: %s" % makefile_am) tools.replace_in_file(makefile_am, 'INCLUDES = -I$(top_srcdir)/aapl', 'AM_CPPFLAGS = -I$(top_srcdir)/aapl') main_cpp = os.path.join('ragel', 'main.cpp').replace('\\', '/') self.output.info("Patching: %s" % main_cpp) tools.replace_in_file(main_cpp, '#include <unistd.h>', '') tools.run_in_windows_bash(self, 'aclocal') tools.run_in_windows_bash(self, 'autoheader') tools.run_in_windows_bash( self, 'automake --foreign --add-missing --force-missing') tools.run_in_windows_bash(self, 'autoconf') with tools.vcvars(self.settings): compiler_options = '-D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE ' \ '-D_CRT_NONSTDC_NO_WARNINGS -WL -W2 -WX- -Gy -DNDEBUG ' \ '-diagnostics:classic -DWIN32 -D_WINDOWS -O2 -Ob2 ' compiler_options += '-wd4577 -wd5026 -wd5027 -wd4710 -wd4711 -wd4626 -wd4250 -wd4365 ' \ '-wd4625 -wd4774 -wd4530 -wd4100 -wd4706 -wd4512 -wd4800 -wd4702 ' \ '-wd4819 -wd4355 -wd4091 -wd4267 -wd4365 -wd4625 -wd4774 -wd4820' linker_options = '/MACHINE:X{0}'.format( '86' if self.settings.arch_build == 'x86' else '64') runtime = '-%s' % str(self.settings.compiler.runtime) prefix = tools.unix_path(os.path.abspath(self.package_folder), tools.MSYS2) flags = '{compiler_options} {runtime} -I{prefix}/include'.format( compiler_options=compiler_options, runtime=runtime, prefix=prefix) ldflags = '-L{prefix}/lib {linker_options}'.format( linker_options=linker_options, prefix=prefix) configure_args = [ 'CC={compiler_cc}'.format(compiler_cc=compiler_cc), 'CXX={compiler_cxx}'.format(compiler_cxx=compiler_cxx), 'CFLAGS={flags}'.format(flags=flags), 'CXXFLAGS={flags}'.format(flags=flags), 'CPPFLAGS={flags}'.format(flags=flags), 'LDFLAGS={ldflags}'.format(ldflags=ldflags), 'LD=link', 'NM=dumpbin -symbols', 'STRIP=:', 'RANLIB=:' ] self.autotools.configure(configure_dir="ragel-%s" % self.version, args=configure_args) self.autotools.make()
def _make_program(self): if self.settings.compiler == "Visual Studio": return "nmake" make_program = tools.get_env("CONAN_MAKE_PROGRAM", tools.which("make") or tools.which('mingw32-make')) make_program = tools.unix_path(make_program) if tools.os_info.is_windows else make_program return make_program
def _configure_args(self): openssldir = self.options.openssldir or self._get_default_openssl_dir() prefix = tools.unix_path(self.package_folder) if self._win_bash else self.package_folder openssldir = tools.unix_path(openssldir) if self._win_bash else openssldir args = [ '"%s"' % (self._target), "shared" if self.options.shared else "no-shared", "--prefix=\"%s\"" % prefix, "--libdir=lib", "--openssldir=\"%s\"" % openssldir, "no-unit-test", "no-threads" if self.options.no_threads else "threads", "PERL=%s" % self._perl, "no-tests", "--debug" if self.settings.build_type == "Debug" else "--release", ] if self.settings.os == "Android": args.append(" -D__ANDROID_API__=%s" % str(self.settings.os.api_level)) # see NOTES.ANDROID if self.settings.os == "Emscripten": args.append("-D__STDC_NO_ATOMICS__=1") if self.settings.os == "Windows": if self.options.enable_capieng: args.append("enable-capieng") if self.options.capieng_dialog: args.append("-DOPENSSL_CAPIENG_DIALOG=1") else: args.append("-fPIC" if self.options.get_safe("fPIC", True) else "no-pic") args.append("no-fips" if self.options.get_safe("no_fips", True) else "enable-fips") if self.settings.os == "Neutrino": args.append("no-asm -lsocket -latomic") if not self.options.no_zlib: zlib_info = self.deps_cpp_info["zlib"] include_path = zlib_info.include_paths[0] if self.settings.os == "Windows": lib_path = "%s/%s.lib" % (zlib_info.lib_paths[0], zlib_info.libs[0]) else: # Just path, linux will find the right file lib_path = zlib_info.lib_paths[0] if tools.os_info.is_windows: # clang-cl doesn't like backslashes in #define CFLAGS (builldinf.h -> cversion.c) include_path = include_path.replace("\\", "/") lib_path = lib_path.replace("\\", "/") if self.options["zlib"].shared: args.append("zlib-dynamic") else: args.append("zlib") args.extend([ '--with-zlib-include="%s"' % include_path, '--with-zlib-lib="%s"' % lib_path ]) for option_name in self.options.values.fields: if self.options.get_safe(option_name, False) and option_name not in ("shared", "fPIC", "openssldir", "capieng_dialog", "enable_capieng", "zlib", "no_fips"): self.output.info(f"Activated option: {option_name}") args.append(option_name.replace("_", "-")) return args
def build_configure(self): with tools.chdir(self._source_subfolder): prefix = tools.unix_path( self.package_folder ) if self.settings.os == 'Windows' else self.package_folder args = [ '--prefix=%s' % prefix, '--disable-doc', '--disable-programs' ] if self.options.shared: args.extend(['--disable-static', '--enable-shared']) else: args.extend(['--disable-shared', '--enable-static']) args.append('--pkg-config-flags=--static') 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 'CC' in os.environ: args.append('--cc=%s' % os.environ['CC']) if 'CXX' in os.environ: args.append('--cxx=%s' % os.environ['CXX']) if self._is_msvc: args.append('--toolchain=msvc') args.append('--extra-cflags=-%s' % self.settings.compiler.runtime) if int(str(self.settings.compiler.version)) <= 12: # Visual Studio 2013 (and earlier) doesn't support "inline" keyword for C (only for C++) args.append('--extra-cflags=-Dinline=__inline' % self.settings.compiler.runtime) if self.settings.arch == 'x86': args.append('--arch=x86') if self.settings.os != "Windows": args.append( '--enable-pic' if self.options.fPIC else '--disable-pic') args.append('--enable-postproc' if self.options. postproc else '--disable-postproc') args.append( '--enable-zlib' if self.options.zlib else '--disable-zlib') args.append( '--enable-bzlib' if self.options.bzlib else '--disable-bzlib') args.append( '--enable-lzma' if self.options.lzma else '--disable-lzma') args.append( '--enable-iconv' if self.options.iconv else '--disable-iconv') args.append('--enable-libfreetype' if self.options. freetype else '--disable-libfreetype') args.append('--enable-libopenjpeg' if self.options. openjpeg else '--disable-libopenjpeg') args.append('--enable-libopenh264' if self.options. openh264 else '--disable-libopenh264') args.append('--enable-libvorbis' if self.options. vorbis else '--disable-libvorbis') args.append('--enable-libopus' if self.options. opus else '--disable-libopus') args.append( '--enable-libzmq' if self.options.zmq else '--disable-libzmq') args.append( '--enable-sdl2' if self.options.sdl2 else '--disable-sdl2') args.append('--enable-libx264' if self.options. x264 else '--disable-libx264') args.append('--enable-libx265' if self.options. x265 else '--disable-libx265') args.append( '--enable-libvpx' if self.options.vpx else '--disable-libvpx') args.append('--enable-libmp3lame' if self.options. mp3lame else '--disable-libmp3lame') args.append('--enable-libfdk-aac' if self.options. fdk_aac else '--disable-libfdk-aac') args.append('--enable-libwebp' if self.options. webp else '--disable-libwebp') args.append('--enable-openssl' if self.options. openssl else '--disable-openssl') if self.options.x264 or self.options.x265 or self.options.postproc: args.append('--enable-gpl') if self.options.fdk_aac: args.append('--enable-nonfree') if self.settings.os == "Linux": args.append( '--enable-alsa' if self.options.alsa else '--disable-alsa') args.append('--enable-libpulse' if self.options. pulse else '--disable-libpulse') args.append('--enable-vaapi' if self.options. vaapi else '--disable-vaapi') args.append('--enable-vdpau' if self.options. vdpau else '--disable-vdpau') if self.options.xcb: args.extend([ '--enable-libxcb', '--enable-libxcb-shm', '--enable-libxcb-shape', '--enable-libxcb-xfixes' ]) else: args.extend([ '--disable-libxcb', '--disable-libxcb-shm', '--disable-libxcb-shape', '--disable-libxcb-xfixes' ]) if self.settings.os == "Macos": args.append('--enable-appkit' if self.options. appkit else '--disable-appkit') args.append('--enable-avfoundation' if self.options. avfoundation else '--disable-avfoundation') args.append('--enable-coreimage' if self.options. avfoundation else '--disable-coreimage') args.append('--enable-audiotoolbox' if self.options. audiotoolbox else '--disable-audiotoolbox') args.append('--enable-videotoolbox' if self.options. videotoolbox else '--disable-videotoolbox') args.append('--enable-securetransport' if self.options. securetransport else '--disable-securetransport') if self.settings.os == "Windows": args.append('--enable-libmfx' if self.options. qsv else '--disable-libmfx') # FIXME disable CUDA and CUVID by default, revisit later args.extend(['--disable-cuda', '--disable-cuvid']) env_build = AutoToolsBuildEnvironment( self, win_bash=self._is_mingw_windows or self._is_msvc) # ffmpeg's configure is not actually from autotools, so it doesn't understand standard options like # --host, --build, --target env_build.configure(args=args, build=False, host=False, target=False) env_build.make() env_build.make(args=['install'])
def test_cygwin_path(self): self.assertEqual('/cygdrive/c/windows/system32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.CYGWIN))
def _configure_autotools(self): if self._autotools: return self._autotools self._autotools = AutoToolsBuildEnvironment(self) self._autotools.libs = [] self._autotools.include_paths = [] if self._with_crypto: if self.settings.os == "Linux": self._autotools.libs.append("dl") conf_args = [ "--with-apr={}".format( tools.unix_path(self.deps_cpp_info["apr"].rootpath)), "--with-crypto" if self._with_crypto else "--without-crypto", "--with-iconv={}".format( tools.unix_path(self.deps_cpp_info["libiconv"].rootpath)), "--with-openssl={}".format( tools.unix_path(self.deps_cpp_info["openssl"].rootpath)) if self.options.with_openssl else "--without-openssl", "--with-expat={}".format( tools.unix_path(self.deps_cpp_info["expat"].rootpath)) if self.options.with_expat else "--without-expat", "--with-mysql={}".format( tools.unix_path(self.deps_cpp_info["libmysqlclient"].rootpath)) if self.options.with_mysql else "--without-mysql", "--with-pgsql={}".format( tools.unix_path(self.deps_cpp_info["libpq"].rootpath)) if self.options.with_postgresql else "--without-pgsql", "--with-sqlite3={}".format( tools.unix_path(self.deps_cpp_info["sqlite3"].rootpath)) if self.options.with_sqlite3 else "--without-sqlite3", "--with-ldap={}".format( tools.unix_path(self.deps_cpp_info["ldap"].rootpath)) if self.options.with_ldap else "--without-ldap", "--with-berkeley-db={}".format( tools.unix_path(self.deps_cpp_info["libdb"].rootpath)) if self.options.dbm == "db" else "--without-berkeley-db", "--with-gdbm={}".format( tools.unix_path(self.deps_cpp_info["gdbm"].rootpath)) if self.options.dbm == "gdbm" else "--without-gdbm", "--with-ndbm={}".format( tools.unix_path(self.deps_cpp_info["ndbm"].rootpath)) if self.options.dbm == "ndbm" else "--without-ndbm", ] if self.options.dbm: conf_args.append("--with-dbm={}".format(self.options.dbm)) self._autotools.configure(args=conf_args, configure_dir=self._source_subfolder) return self._autotools
def test_sfu_path(self): self.assertEqual('/dev/fs/C/windows/system32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.SFU))
def test_cygwin_path(self): self.assertEqual( '/cygdrive/c/windows/system32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.CYGWIN))
def test_wsl_path(self): self.assertEqual( '/mnt/c/Windows/System32', tools.unix_path('C:\\Windows\\System32', path_flavor=tools.WSL))
def build(self): if 'MSYS_ROOT' not in os.environ: os.environ['MSYS_ROOT'] = self.deps_env_info[ "msys2_installer"].MSYS_ROOT if 'MSYS_ROOT' not in os.environ: raise Exception("MSYS_ROOT environment variable must be set.") else: self.output.info("Using MSYS from: " + os.environ["MSYS_ROOT"]) os.environ['PATH'] = os.path.join(os.environ['MSYS_ROOT'], 'usr', 'bin') + os.pathsep + \ os.environ['PATH'] compiler_options = '' linker_options = '' runtime_options = '' ld_options = '' nm_options = '' ranlib_options = '' strip_options = '' if self.settings.compiler == 'Visual Studio': # this overrides pre-configured environments (such as Appveyor's) if "VisualStudioVersion" in os.environ: del os.environ["VisualStudioVersion"] vccmd = tools.vcvars_command(self.settings) + " &&" compiler_cc = '$PWD/compile cl -nologo' compiler_cxx = compiler_cc elif self.settings.compiler == 'gcc': vccmd = '' if 'MINGW_HOME' in os.environ: compiler_cc = tools.unix_path( self.deps_env_info["mingw_installer"].CC) compiler_cxx = tools.unix_path( self.deps_env_info["mingw_installer"].CXX) else: compiler_cc = self.settings.compiler compiler_cxx = compiler_cc env_build = AutoToolsBuildEnvironment(self) with tools.chdir("{0}-{1}".format('ragel', self.version)): with tools.environment_append(env_build.vars): self.run( "bash -c 'pacman -S automake-wrapper autoconf --noconfirm --needed'" ) makefile_am = os.path.join('ragel', 'Makefile.am').replace('\\', '/') self.output.info("Patching: %s" % makefile_am) tools.replace_in_file(makefile_am, 'INCLUDES = -I$(top_srcdir)/aapl', 'AM_CPPFLAGS = -I$(top_srcdir)/aapl') main_cpp = os.path.join('ragel', 'main.cpp').replace('\\', '/') self.output.info("Patching: %s" % main_cpp) tools.replace_in_file(main_cpp, '#include <unistd.h>', '') self.run("{vccmd} bash -c 'aclocal'".format(vccmd=vccmd)) self.run("{vccmd} bash -c 'autoheader'".format(vccmd=vccmd)) self.run( "{vccmd} bash -c 'automake --foreign --add-missing --force-missing'" .format(vccmd=vccmd)) self.run("{vccmd} bash -c 'autoconf'".format(vccmd=vccmd)) if self.settings.compiler == 'Visual Studio': compiler_options = '-D_CRT_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_DEPRECATE ' \ '-D_CRT_NONSTDC_NO_WARNINGS -WL -W2 -WX- -Gy -DNDEBUG ' \ '-diagnostics:classic -DWIN32 -D_WINDOWS -O2 -Ob2 ' compiler_options += '-wd4577 -wd5026 -wd5027 -wd4710 -wd4711 -wd4626 -wd4250 -wd4365 ' \ '-wd4625 -wd4774 -wd4530 -wd4100 -wd4706 -wd4512 -wd4800 -wd4702 ' \ '-wd4819 -wd4355 -wd4091 -wd4267 -wd4365 -wd4625 -wd4774 -wd4820' linker_options = '/MACHINE:X{0}'.format( '86' if self.settings.arch == 'x86' else '64') runtime_options = '-' + str(self.settings.compiler.runtime) ld_options = 'LD="link" ' nm_options = 'NM="dumpbin -symbols" ' strip_options = 'STRIP=":" ' ranlib_options = 'RANLIB=":" ' prefix = tools.unix_path(os.path.abspath("../out")) self.run( '{vccmd} bash -c \'./configure ' '--prefix={prefix} ' 'CC="{compiler_cc}" ' 'CXX="{compiler_cxx}" ' 'CFLAGS="{compiler_options} {runtime} -I{prefix}/include " ' 'CXXFLAGS="{compiler_options} {runtime} -I{prefix}/include " ' 'CPPFLAGS="{compiler_options} {runtime} -I{prefix}/include " ' 'LDFLAGS="-L{prefix}/lib {linker_options}" ' '{ld_options}' '{nm_options}' '{strip_options}' '{ranlib_options}' '\''.format(vccmd=vccmd, prefix=prefix, compiler_cc=compiler_cc, compiler_cxx=compiler_cxx, ld_options=ld_options, nm_options=nm_options, strip_options=strip_options, ranlib_options=ranlib_options, compiler_options=compiler_options, linker_options=linker_options, runtime=runtime_options)) self.run("{vccmd} bash -c 'make -s -j {cpus} install".format( vccmd=vccmd, cpus=tools.cpu_count()))