def build(self): args = [ "--with-quantum-depth=16", "--enable-shared=yes", "--enable-static=no", "--without-bzlib", "--without-dps", "--without-fpx", "--without-gslib", "--without-jbig", "--without-jpeg", "--without-jp2", "--without-lcms2", "--without-lzma", "--without-magick-plus-plus", "--without-png", "--without-tiff", "--without-trio", "--without-ttf", "--without-umem", "--without-wmf", "--without-webp", "--without-x", "--without-xml", "--without-zlib", ] autotools = AutoToolsBuildEnvironment(self) autotools.configure(configure_dir="GraphicsMagick-1.3.28", args=args) autotools.make() autotools.install()
def build(self): with tools.chdir(self.source_subfolder): _args = ["--prefix=%s/builddir" % (os.getcwd())] autotools = AutoToolsBuildEnvironment(self) autotools.configure(args=_args) autotools.make(args=["-j4"]) autotools.install()
def build_configure(self): without_ext = (tuple( extension for extension in self.extensions if not getattr(self.options, "with_" + extension))) with tools.chdir(self._source_subfolder): if self.settings.compiler == "Visual Studio": with tools.environment_append({ "INCLUDE": self.deps_cpp_info.include_paths, "LIB": self.deps_cpp_info.lib_paths }): if self.settings.arch == "x86": target = "i686-mswin32" elif self.settings.arch == "x86_64": target = "x64-mswin64" else: raise Exception("Invalid arch") self.run( '{} --prefix={} --target={} --without-ext="{}," --with-ext="{}" --with-static-linked-ext --disable-install-doc' .format(os.path.join("win32", "configure.bat"), self.package_folder, target, ",".join(without_ext), str(self.options.get_safe("additional_exts")))) # Patch in runtime settings def define(line): tools.replace_in_file("Makefile", "CC = cl -nologo", "CC = cl -nologo\n" + line) define("RUNTIMEFLAG = -{}".format( self.settings.compiler.runtime)) if self.settings.build_type == "Debug": define("COMPILERFLAG = -Zi") define("OPTFLAGS = -Od -Ob0") self.run("nmake") self.run("nmake install") else: win_bash = tools.os_info.is_windows autotools = AutoToolsBuildEnvironment(self, win_bash=win_bash) # Remove our libs; Ruby doesn't like Conan's help autotools.libs = [] if self.settings.compiler == "clang": autotools.link_flags.append("--rtlib=compiler-rt") args = [ "--with-out-ext=" + ",".join(without_ext), "--with-ext=" + str(self.options.get_safe("additional_exts")), "--with-static-linked-ext", "--disable-install-doc", "--without-gmp", "--enable-shared", ] autotools.configure(args=args) autotools.make() autotools.install()
def build(self): autotools = AutoToolsBuildEnvironment(self) if self.options.lto: autotools.flags.append("-flto") autotools.link_flags.append("-flto") autotools.link_flags.append("-fuse-ld=gold") autotools.link_flags.append("-fuse-linker-plugin") autotools.configure( configure_dir = f"{self.source_folder}/{self.name}-{self.version}" , pkg_config_paths = [ f'''{self.deps_cpp_info["xorg-util-macros"].rootpath}/share/pkgconfig''' , f'''{self.deps_cpp_info["xcb"].rootpath}/share/pkgconfig''' ] , args = [ "--disable-static" if self.options.shared else "--enable-static" , "--enable-shared" if self.options.shared else "--disable-shared" , "--disable-selective-werror" , "--disable-strict-compilation" , "--disable-devel-docs" ] ) autotools.make() autotools.install()
def _build_static_lib_in_shared(self): """ Build shared library using libtool (while linking to a static library) """ # Copy static-in-shared directory to build folder autotools_folder = os.path.join(self.build_folder, "sis") shutil.copytree(os.path.join(self.source_folder, "sis"), autotools_folder) install_prefix = os.path.join(autotools_folder, "prefix") # Build static library using CMake cmake = CMake(self) cmake.definitions["CMAKE_INSTALL_PREFIX"] = install_prefix cmake.configure(source_folder=autotools_folder, build_folder=os.path.join(autotools_folder, "cmake_build")) cmake.build() cmake.install() # Copy autotools directory to build folder with tools.chdir(autotools_folder): self.run("{} -ifv -Wall".format(os.environ["AUTORECONF"]), win_bash=tools.os_info.is_windows) with tools.chdir(autotools_folder): conf_args = [ "--enable-shared", "--disable-static", "--prefix={}".format(tools.unix_path(os.path.join(install_prefix))), ] with self._build_context(): autotools = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows) autotools.libs = [] autotools.link_flags.append("-L{}".format(tools.unix_path(os.path.join(install_prefix, "lib")))) autotools.configure(args=conf_args, configure_dir=autotools_folder) autotools.make(args=["V=1"]) autotools.install()
def _build_autotools(self): prefix = os.path.abspath(self.package_folder) host = None build = None if self._is_mingw_windows or self._is_msvc: prefix = prefix.replace('\\', '/') build = False if self.settings.arch == "x86": host = "i686-w64-mingw32" elif self.settings.arch == "x86_64": host = "x86_64-w64-mingw32" env_build = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows) if self.settings.os != "Windows": env_build.fpic = self.options.fPIC configure_args = ['--prefix=%s' % prefix] configure_args.extend(['--enable-static', '--disable-shared']) env_vars = { "FFMPEG_LIBS": "-L%s" % self.deps_cpp_info["ffmpeg"].lib_paths[0], "FFMPEG_CFLAGS": "-I%s" % self.deps_cpp_info["ffmpeg"].include_paths[0] } with tools.chdir(self._source_subfolder): with tools.environment_append(env_vars): self.run("autoreconf -vfi", win_bash=tools.os_info.is_windows) env_build.configure(args=configure_args, host=host, build=build) env_build.make() env_build.install()
def build_with_make(self): autotools = AutoToolsBuildEnvironment(self) sharedargs = ([ '--enable-shared', '--disable-static' ] if self.options.shared else ['--enable-static', '--disable-shared']) autotools.configure(configure_dir=self.folder, args=[ "--with-freetype-exec-prefix=" + self.deps_cpp_info["freetype"].lib_paths[0] ] + sharedargs) old_str = '\nLIBS = ' new_str = '\n# Removed by conan: LIBS = ' tools.replace_in_file("Makefile", old_str, new_str) old_str = '\nLIBTOOL = ' new_str = '\nLIBS = {}\nLIBTOOL = '.format(" ".join([ "-l%s" % lib for lib in self.deps_cpp_info.libs ])) # Trust conaaaan! tools.replace_in_file("Makefile", old_str, new_str) old_str = '\nSDL_CFLAGS =' new_str = '\n# Removed by conan: SDL_CFLAGS =' tools.replace_in_file("Makefile", old_str, new_str) old_str = '\nSDL_LIBS =' new_str = '\n# Removed by conan: SDL_LIBS =' tools.replace_in_file("Makefile", old_str, new_str) autotools.make() autotools.install()
def build(self): env_build = AutoToolsBuildEnvironment(self) static_flag = 'no' if self.options.shared else 'yes' shared_flag = 'yes' if self.options.shared else 'no' libiconv_flag = 'yes' if self.options.with_libiconv else 'no' args = [ '--enable-static=%s' % static_flag, '--enable-shared=%s' % shared_flag, '--enable-ltdl-install', '--enable-iconv=%s' % libiconv_flag ] if self.options.with_libiconv: if tools.is_apple_os(self.settings.os): libiconv_prefix = "/usr" else: libiconv_prefix = self.deps_cpp_info["libiconv"].rootpath args.append('--with-libiconv-prefix=%s' % libiconv_prefix) env_build.configure(configure_dir=self._source_subfolder, args=args) env_build.make() env_build.install() tools.rmdir(os.path.join(self.package_folder, "share")) tools.rmdir(os.path.join(self.package_folder, "etc")) tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) os.remove(os.path.join(self.package_folder, "lib", "libodbc.la")) os.remove(os.path.join(self.package_folder, "lib", "libodbccr.la")) os.remove(os.path.join(self.package_folder, "lib", "libodbcinst.la")) os.remove(os.path.join(self.package_folder, "lib", "libltdl.la"))
def build(self): triple = str(self.settings.arch)+"-elf" #TODO swap this to use self.settings.arch env_build = AutoToolsBuildEnvironment(self) env_build.configure(configure_dir=self.source_folder+"/musl",target=triple,args=["--enable-debug","--disable-shared"]) #what goes in here preferably env_build.make() env_build.install()
def package(self): be = AutoToolsBuildEnvironment(self) tmp_dir = os.path.join(self.build_folder, "install") with tools.chdir(self._source_subfolder): with tools.environment_append(be.vars): be.install(args=["DESTDIR={}".format(tmp_dir)]) self.copy("*", src=os.path.join(tmp_dir, "usr", "local"))
def build(self): autotools = AutoToolsBuildEnvironment(self) autotools.fPIC = True env_build_vars = autotools.vars configure_args = [ "--disable-bsdtar", "--disable-bsdcat", "--disable-bsdcpio", "--with-zlib", "--without-bz2lib", "--without-iconv", "--without-lz4", "--without-lzma", "--without-lzo2", "--without-nettle", "--without-openssl", "--without-xml2", "--without-expat" ] if self.options["shared"]: configure_args += ["--enable-shared", "--disable-static"] else: configure_args += ["--disable-shared", "--enable-static"] if self.options["fPIC"]: configure_args += ["--with-pic"] autotools.configure(configure_dir="libarchive-3.3.3", vars=env_build_vars, args=configure_args) autotools.make(vars=env_build_vars) autotools.install(vars=env_build_vars)
def package(self): autotools = AutoToolsBuildEnvironment(self) with build_env_vars_set(self, append_libdirs_to_rpath = True, additional_vars_to_merge=self.fpic_env): autotools.configure(configure_dir=self.topdir, args=self.configure_additional_args) autotools.make(target=self.topdir) autotools.install()
def _build_autotools(self): """ Test autotools integration """ # Copy autotools directory to build folder shutil.copytree(os.path.join(self.source_folder, "autotools"), os.path.join(self.build_folder, "autotools")) with tools.chdir("autotools"): self.run("{} --install --verbose -Wall".format( os.environ["AUTORECONF"]), win_bash=tools.os_info.is_windows) tools.mkdir(self._package_folder) conf_args = [ "--prefix={}".format(tools.unix_path(self._package_folder)), "--enable-shared", "--enable-static", ] os.mkdir("bin_autotools") with tools.chdir("bin_autotools"): with self._build_context(): autotools = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) autotools.libs = [] autotools.configure(args=conf_args, configure_dir=os.path.join( self.build_folder, "autotools")) autotools.make(args=["V=1", "-j1"]) autotools.install()
def build(self): for lib in self.deps_cpp_info.deps: self.import_pkg_config_files(lib, self.build_folder) autotools = AutoToolsBuildEnvironment(self) env = autotools.vars env["PATH"] = os.getenv("PATH") + ":" + os.path.join( self.deps_cpp_info["glib"].rootpath, "bin") env["PKG_CONFIG_PATH"] = env.get("PKG_CONFIG_PATH", "") + ":" + self.build_folder configure_args = ['--disable-gtk-doc'] if self.options.shared: configure_args.extend(['--disable-static', '--enable-shared']) else: configure_args.extend(['--enable-static', '--disable-shared']) with tools.environment_append(env): os.chdir("%s/pango" % self.build_folder) self.run("NOCONFIGURE=1 ./autogen.sh --disable-gtk-doc") autotools.pic = self.options.fPIC autotools.include_paths.extend( os.path.join(s, "harfbuzz") for s in self.deps_cpp_info["harfbuzz"].include_paths) autotools.configure(args=configure_args, pkg_config_paths=[self.build_folder]) autotools.make() autotools.install()
def build_configure(self): win_bash = tools.os_info.is_windows if self.settings.compiler == "Visual Studio": make_vars = { "MMX": "on" if self.settings.arch == "x86" else "off", "SSE2": "on", "SSSE3": "on", "CFG": str(self.settings.build_type).lower(), } tools.replace_in_file( os.path.join(self.folder, 'Makefile.win32.common'), '-MDd ', '-%s ' % str(self.settings.compiler.runtime)) tools.replace_in_file( os.path.join(self.folder, 'Makefile.win32.common'), '-MD ', '-%s ' % str(self.settings.compiler.runtime)) var_args = " ".join("{}={}".format(k, v) for k, v in make_vars.items()) self.run("make -C {}/pixman -f Makefile.win32 {}".format( self.folder, var_args), win_bash=win_bash) else: args = ["--disable-libpng", "--disable-gtk"] if self.options.shared: args.extend(["--enable-shared", "--disable-static"]) else: args.extend(["--enable-static", "--disable-shared"]) autotools = AutoToolsBuildEnvironment(self, win_bash=win_bash) if self.settings.os != 'Windows': autotools.pic = self.options.fPIC autotools.configure(configure_dir=self.folder, args=args) autotools.make(target="pixman") autotools.install()
def build(self): # the previous step might hang when converting from ISO-8859-2 to UTF-8 late in the build process os.unlink(os.path.join(self._source_subfolder, "po", "ro.po")) build = None host = None rc = None env = dict() args = [ "--disable-dependency-tracking", "--disable-nls", "--disable-languages", "--disable-doc", "--disable-tests" ] if self.settings.os != "Windows" and self.options.fPIC: args.append("--with-pic") if self.options.shared: args.extend(["--disable-static", "--enable-shared"]) else: args.extend(["--disable-shared", "--enable-static"]) if self.settings.os == "Linux" and self.settings.arch == "x86": host = "i686-linux-gnu" with tools.chdir(self._source_subfolder): with tools.environment_append(env): env_build = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) env_build.configure(args=args, build=build, host=host) env_build.make() env_build.install()
def _build_install_binutils(self, target): autotools = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows) conf_args = [ "--prefix={}".format(os.path.join(self.package_folder, target).replace("\\", "/")), "--disable-build-warnings", "--target={}".format(target), ] autotools.flags.extend(["-DSTDC_HEADERS", "-D_FORTIFY_SOURCE=0"]) host = tools.get_gnu_triplet(str(self.settings.os), str(self.settings.arch), str(self.settings.compiler)) build = tools.get_gnu_triplet(tools.detected_os(), tools.detected_architecture(), "gcc") if tools.os_info.is_windows: build = "{}-w64-mingw32".format({ "x86": "i686", }.get(str(tools.detected_architecture()), str(tools.detected_architecture()))) if self.settings.os == "Windows": host = "{}-w64-mingw32".format({ "x86": "i686", }.get(str(self.settings.arch), str(self.settings.arch))) build_folder = os.path.join("build_binutils_{}".format(target)) tools.mkdir(build_folder) with tools.chdir(build_folder): self.output.info("Building binutils for target={}".format(target)) autotools.configure(args=conf_args, configure_dir=os.path.join(self.source_folder, "binutils"), build=build, host=host) autotools.make() autotools.install()
def build_with_make(self): win_bash = tools.os_info.detect_windows_subsystem() == "msys2" with tools.environment_append(RunEnvironment(self).vars): self.run("./autogen.sh", win_bash=win_bash, cwd=self._source_subfolder) autotools = AutoToolsBuildEnvironment(self, win_bash=win_bash) args = [ "--with-freetype-prefix=" + self.deps_cpp_info["freetype"].rootpath, "--with-sdl-prefix=" + self.deps_cpp_info["sdl2"].rootpath, ] if self.options.shared: args.extend(['--enable-shared', '--disable-static']) else: args.extend(['--enable-static', '--disable-shared']) autotools.configure(configure_dir=self._source_subfolder, args=args) patches = ( ('\nnoinst_PROGRAMS = ', '\n# Removed by conan: noinst_PROGRAMS = '), ('\nLIBS = ', '\n# Removed by conan: LIBS = '), ('\nLIBTOOL = ', '\nLIBS = {}\nLIBTOOL = '.format(" ".join(["-l%s" % lib for lib in self.deps_cpp_info.libs]))), ('\nSDL_CFLAGS =', '\n# Removed by conan: SDL_CFLAGS ='), ('\nSDL_LIBS =' , '\n# Removed by conan: SDL_LIBS ='), ) for old_str, new_str in patches: tools.replace_in_file("Makefile", old_str, new_str) autotools.make() autotools.install()
def build(self): os.unlink("musl/arch/{}/syscall_arch.h".format(self._find_arch())) # this will remove set_thread_area which is just a regular function now os.unlink("musl/src/thread/{}/__set_thread_area.s".format( self._find_arch())) host = self._find_host_arch() + "-pc-linux-gnu" triple = self._find_arch() + "-elf" args = ["--disable-shared", "--disable-gcc-wrapper"] if (self.settings.build_type == "Debug"): args.append("--enable-debug") env_build = AutoToolsBuildEnvironment(self) if str(self.settings.compiler) == 'clang': env_build.flags = [ "-g", "-target {}-pc-linux-gnu".format(self._find_arch()) ] args.append("--target={}-pc-linux-gnu".format(self._find_arch())) #TODO fix this is only correct if the host is x86_64 if str(self.settings.compiler) == 'gcc': if self._find_arch() == "x86_64": env_build.flags = ["-g", "-m64"] if self._find_arch() == "i386": env_build.flags = ["-g", "-m32"] if self.settings.build_type == "Debug": env_build.flags += ["-g"] env_build.configure(configure_dir=self.source_folder + "/musl", host=host, target=triple, args=args) #what goes in here preferably env_build.make() env_build.install()
def package(self): self.copy("*LICENSE", src=self._source_subfolder, dst="licenses", keep_path=False) if self.settings.compiler == "Visual Studio": self.copy("*.h", src=os.path.join(self._source_subfolder, "include"), dst="include") self.copy("*.dll", src=os.path.join(self._source_subfolder, "vs2015", "build"), dst="bin") self.copy("*.lib", src=os.path.join(self._source_subfolder, "vs2015", "build"), dst="lib") os.rename(os.path.join(self.package_folder, "lib", "Argon2OptDll.lib"), os.path.join(self.package_folder, "lib", "argon2.lib")) else: autotools = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows) with tools.chdir(self._source_subfolder): with tools.environment_append(autotools.vars): autotools.install(args=self._make_args) # drop unneeded dirs tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) tools.rmdir(os.path.join(self.package_folder, "bin")) if self.settings.os == "Windows" and self.options.shared: os.unlink(os.path.join(self.package_folder, "lib", "libargon2.a")) self.copy("libargon2.dll.a", src=self._source_subfolder, dst="lib") tools.mkdir(os.path.join(self.package_folder, "bin")) os.rename(os.path.join(self.package_folder, "lib", "libargon2.dll"), os.path.join(self.package_folder, "bin", "libargon2.dll")) # drop unneeded libs if self.options.shared: if self.settings.os != "Windows": tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.a*") else: tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.dll") tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.so") tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.so.*") tools.remove_files_by_mask(os.path.join(self.package_folder, "lib"), "*.dylib")
class LibevConan(ConanFile): name = "libev" version = "4.24" license = "http://cvs.schmorp.de/libev/LICENSE?view=markup" url = "http://software.schmorp.de/pkg/libev.html" description = "A full-featured and high-performance event loop that is loosely modelled after libevent, but without its limitations and bugs." settings = "os", "compiler", "build_type", "arch" options = {"shared": [True, False]} default_options = "shared=True" generators = "cmake" exports_sources = ["FindLibev.cmake"] def source(self): self.run("wget http://dist.schmorp.de/libev/libev-4.24.tar.gz") self.run("tar xf libev-4.24.tar.gz") def build(self): self.autotools = AutoToolsBuildEnvironment(self) self.autotools.configure(configure_dir="libev-4.24") self.autotools.make() def package(self): self.autotools.install() self.copy("FindLibev.cmake", ".", ".") def package_info(self): self.cpp_info.libs = ["ev"]
def build(self): autotools = AutoToolsBuildEnvironment(self) if self.options.lto: autotools.flags.append("-flto") autotools.link_flags.append("-flto") autotools.link_flags.append("-fuse-ld=gold") autotools.link_flags.append("-fuse-linker-plugin") autotools.configure( configure_dir=f"{self.source_folder}/libXdmcp-{self.version}", pkg_config_paths=[ f'''{self.deps_cpp_info["xorg-util-macros"].rootpath}/share/pkgconfig''', f'''{self.deps_cpp_info["xorgproto"].rootpath}/share/pkgconfig''' ], args=[ "--disable-static" if self.options.shared else "--enable-static", "--enable-shared" if self.options.shared else "--disable-shared", "--disable-selective-werror", "--disable-strict-compilation", "--disable-lint-library", "--disable-unit-tests", "--without-xmlto", "--without-fop", "--without-xsltproc", "--without-lint" ]) autotools.make() autotools.install()
def _build_configure(self): with tools.chdir(self._source_subfolder): args = ['--disable-cli'] if self.options.shared: args.append('--enable-shared') else: args.append('--enable-static') if self.settings.os != 'Windows' and self.options.fPIC: args.append('--enable-pic') if self.settings.build_type == 'Debug': args.append('--enable-debug') args.append('--bit-depth=%s' % str(self.options.bit_depth)) if self.settings.os == "Android": if str(self.settings.arch).startswith('armv7'): args.append('--host=arm-linux') elif str(self.settings.arch).startswith('armv8'): args.append('--host=aarch64-linux') env_vars = dict() env_vars['PATH'] = [self.source_folder] if self._is_msvc: env_vars['CC'] = 'cl' with tools.environment_append(env_vars): env_build = AutoToolsBuildEnvironment( self, win_bash=tools.os_info.is_windows) if self._is_msvc: env_build.flags.append('-%s' % str(self.settings.compiler.runtime)) # cannot open program database ... if multiple CL.EXE write to the same .PDB file, please use /FS env_build.flags.append('-FS') env_build.configure(args=args, build=False, host=False) env_build.make() if not (self.settings.os == "Android" and tools.os_info.is_windows): env_build.install()
def package(self): be = AutoToolsBuildEnvironment(self) re = RunEnvironment(self) with tools.chdir(self._source_subfolder): with tools.environment_append(be.vars): with tools.environment_append(re.vars): be.install()
def build_configure(self): with tools.chdir(self._source_subfolder): # disable build of test suite tools.replace_in_file(os.path.join('test', 'Makefile.am'), 'noinst_PROGRAMS = cairo-test-suite$(EXEEXT)', '') os.makedirs('pkgconfig') for lib in ['libpng', 'zlib', 'pixman']: self.copy_pkg_config(lib) if self.options.enable_ft: self.copy_pkg_config('freetype') tools.replace_in_file(os.path.join(self.source_folder, self._source_subfolder, "src", "cairo-ft-font.c"), '#if HAVE_UNISTD_H', '#ifdef HAVE_UNISTD_H') pkg_config_path = os.path.abspath('pkgconfig') pkg_config_path = tools.unix_path(pkg_config_path) if self.settings.os == 'Windows' else pkg_config_path configure_args = ['--enable-ft'] if self.options.enable_ft else ['--disable-ft'] if self.options.shared: configure_args.extend(['--disable-static', '--enable-shared']) else: configure_args.extend(['--enable-static', '--disable-shared']) env_build = AutoToolsBuildEnvironment(self) if self.settings.os == 'Macos': env_build.link_flags.extend(['-framework CoreGraphics', '-framework CoreFoundation']) if str(self.settings.compiler) in ['gcc', 'clang', 'apple-clang']: env_build.flags.append('-Wno-enum-conversion') with tools.environment_append(env_build.vars): self.run('PKG_CONFIG_PATH=%s NOCONFIGURE=1 ./autogen.sh' % pkg_config_path) env_build.pic = self.options.fPIC env_build.configure(args=configure_args, pkg_config_paths=[pkg_config_path]) env_build.make() env_build.install()
def package_linux(self): autotools = AutoToolsBuildEnvironment(self) autotools.install() # Delete all shared-objects for static-mode, since we cannot prevent building them if not self.options.shared: for shared_object in glob.iglob(os.path.join(self.package_folder, "lib", "lib*.so*")): os.remove(shared_object)
def build_configure(self): # works for unix and mingw environments env_build = AutoToolsBuildEnvironment(self, win_bash=tools.os_info.is_windows) env_build.fpic = True config_args = [] if self.options.shared: config_args.extend(["--enable-shared=yes", "--enable-static=no"]) else: config_args.extend(["--enable-shared=no", "--enable-static=yes"]) prefix = os.path.abspath(self.package_folder) if tools.os_info.is_windows: prefix = tools.unix_path(prefix) config_args.append("--prefix=%s" % prefix) # mingw-specific if self.settings.os == 'Windows': if self.settings.arch == "x86_64": config_args.append('--build=x86_64-w64-mingw32') config_args.append('--host=x86_64-w64-mingw32') if self.settings.arch == "x86": config_args.append('--build=i686-w64-mingw32') config_args.append('--host=i686-w64-mingw32') env_build.configure(configure_dir=self.source_subfolder, args=config_args) env_build.make() env_build.install()
def package(self): with tools.chdir(self.build_folder): autoTools = AutoToolsBuildEnvironment(self) autoTools.install() self.copy("COPYING", src=os.path.join(self.source_folder, self._source_subfolder), dst="licenses")
def build(self): autotools = AutoToolsBuildEnvironment(self) autotools.fpic = True env_build_vars = autotools.vars self.run("cd squashfuse.git && ./autogen.sh") lzma_libs_dir = self.deps_cpp_info["lzma"].lib_paths[0] autotools.configure(configure_dir="squashfuse.git", vars=env_build_vars, args=[ "--disable-demo", "--disable-high-level", "--without-lzo", "--without-lz4", "--with-xz=%s" % lzma_libs_dir ]) # https://github.com/vasi/squashfuse/issues/12 self.run( "cd squashfuse.git && sed -i \"/PKG_CHECK_MODULES.*/,/,:./d\" configure" ) # off_t's size might differ, see https://stackoverflow.com/a/9073762 self.run( "cd squashfuse.git && sed -i \"s/typedef off_t sqfs_off_t/typedef int64_t sqfs_off_t/g\" common.h" ) autotools.make(vars=env_build_vars) autotools.install(vars=env_build_vars)
def build(self): self.run('sh autogen.sh') autotools = AutoToolsBuildEnvironment(self) args = [] if self.options.shared: args.append('--enable-static=no') else: args.append('--enable-shared=no') if 'Rel' in self.settings.build_type: args.append('--disable-debug') if not self.options.cli: args.append('--enable-cli=no') autotools.configure(args=args) autotools.install() def here(*args): return os.path.join(self.package_folder, *args) shutil.rmtree(here('share')) shutil.rmtree(here('lib', 'pkgconfig')) for path in glob.iglob(here('lib', '*.la')): os.remove(path)