def build(self):
with tools.chdir(self.source_subfolder):
#with tools.chdir(self.build_subfolder):
#self.run("./download_dependencies.sh")
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
#env_build.libs.append("pthread")
env_build.defines.append("BUILD_WITH_NNAPI=false")
env_build.defines.append("BUILD_WITH_MMAP=false")
build_target = "all" # "micro"?
env_build.make(target="%s -f %s/Makefile -C %s" %
(build_target, self.build_subfolder, getcwd()))
def build(self):
env_build = AutoToolsBuildEnvironment(
self, win_bash=self.settings.os == '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"])
if self.options.with_bzlib:
config_args.append('--with-bzlib')
else:
config_args.append('--without-bzlib')
if self.options.with_jpeg:
config_args.append('--with-jpeg')
else:
config_args.append('--without-jpeg')
if self.options.with_png:
config_args.append('--with-png')
else:
config_args.append('--without-png')
config_args.extend([
"--without-dps", "--without-fpx", "--without-jbig",
"--without-jp2", "--without-lcms2", "--without-lzma",
"--with-magick-plus-plus", "--without-perl", "--without-trio",
"--without-webp", "--without-wmf", "--with-zlib"
])
prefix = os.path.abspath(self.package_folder)
if self.settings.os == 'Windows':
prefix = tools.unix_path(prefix)
config_args.append("--prefix=%s" % prefix)
env_build_vars = env_build.vars
#GM configure script links a program with jpeg lib and tries to run it. If libjpeg is a shared library, the dynamic linker must be able to find it
if self.settings.os == 'Linux':
env_build_vars['LD_LIBRARY_PATH'] = ""
if self.options.with_jpeg:
env_build_vars['LD_LIBRARY_PATH'] += self.deps_cpp_info[
"libjpeg"].lib_paths[0]
if self.options.with_png:
if len(env_build_vars['LD_LIBRARY_PATH']) != 0:
env_build_vars['LD_LIBRARY_PATH'] += ':'
env_build_vars['LD_LIBRARY_PATH'] += self.deps_cpp_info[
"libpng"].lib_paths[0]
print("configure with vars")
print(env_build_vars['LD_LIBRARY_PATH'])
env_build.configure(configure_dir=os.path.join(self.source_folder,
self.source_subfolder),
args=config_args,
vars=env_build_vars)
env_build.make()
env_build.make(args=["install"])
def _build_linux(self):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
with tools.environment_append(env_build.vars):
configure_args = [
'--with-fc=0',
'--prefix=../%s' % self.install_dir
]
with tools.chdir(self.source_subfolder):
env_build.configure(args=configure_args)
env_build.make(args=["-j", "1", "all"])
env_build.make(args=["install"])
def unix_build(self):
with tools.chdir(self.subfolder):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
if self.settings.build_type == "Debug":
env_build.make() # $ make
else:
if self.options.shared:
env_build.make(["shared_lib"]) # $ make shared_lib
else:
env_build.make(["static_lib"]) # $ make static_lib
def _build_with_autotools(self):
build_env = AutoToolsBuildEnvironment(self)
build_env.fpic = self.options.fPIC
with tools.environment_append(build_env.vars):
with tools.chdir(self._source_subfolder):
configure_args = ['--prefix=%s' % self.package_folder]
configure_args.append('--enable-shared' if self.options.
shared else '--disable-shared')
configure_args.append('--enable-static' if not self.options.
shared else '--disable-static')
build_env.configure(args=configure_args)
build_env.make(args=["-s", "all"])
build_env.make(args=["-s", "install"])
def build(self):
autotools = AutoToolsBuildEnvironment(self)
autotools.fpic = True
env_build_vars = autotools.vars
autotools.configure(configure_dir="fuse-2.9.9",
vars=env_build_vars,
args=[
"--disable-util",
"--disable-example",
"--verbose",
])
autotools.make(vars=env_build_vars)
autotools.install(vars=env_build_vars)
def _build_configure(self):
autotools = AutoToolsBuildEnvironment(self)
autotools.fpic = self.options.get_safe("fPIC", False)
with tools.chdir(self._source_subfolder):
args = []
if self.options.with_ssl == "openssl":
args.append("WITH_OPENSSL=1")
elif self.options.with_ssl == "wolfssl":
args.append("WITH_WOLFSSL=1")
if self.options.with_libuv:
args.append("WITH_LIBUV=1")
# set CPPFLAGS, CFLAGS and LDFLAGS
args.extend("{}={}".format(key, value) for key, value in autotools.vars.items())
autotools.make(target="default", args=args)
def build(self):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
configure_args = list()
configure_args.append('--disable-rpath')
if (self.options.shared):
configure_args.append('--enable-shared')
else:
configure_args.append('--enable-static')
env_build.configure(args=configure_args, configure_dir="libiconv")
env_build.make()
def build(self):
name = "libtar-{version}".format(version=self.version)
install_folder = os.path.join(name, "install")
with tools.chdir(name):
args = ["--prefix={}".format(os.path.abspath(install_folder))]
if not self.options.withzlib:
args.append("--without-zlib")
self.run("autoreconf --force --install")
autotools = AutoToolsBuildEnvironment(self)
autotools.fpic = self.options.fPIC
autotools.configure(args=args)
autotools.make()
autotools.install()
def build(self):
with tools.chdir(self.name):
autotools = AutoToolsBuildEnvironment(
self, win_bash=(platform.system() == "Windows"))
env_vars = {}
args = []
if 'gcc' == self.settings.compiler and 'Windows' == platform.system(
):
args.append('--prefix=%s' %
tools.unix_path(self.package_folder))
else:
args.append('--prefix=%s' % self.package_folder)
for option_name in self.options.values.fields:
activated = getattr(self.options, option_name)
if not re.match(r'enable|disable', option_name):
continue
if activated:
option_name = option_name.replace("_", "-")
self.output.info("Activated option! %s" % option_name)
args.append('--%s' % option_name)
args.append('--%s-shared' %
('enable' if self.options.shared else 'disable'))
args.append('--%s-static' %
('enable' if self.options.static else 'disable'))
if self.settings.os == "Linux" or self.settings.os == "Macos":
autotools.fpic = True
if self.settings.arch == 'x86':
env_vars['ABI'] = '32'
autotools.cxx_flags.append('-m32')
# Debug
self.output.info('Configure arguments: %s' % ' '.join(args))
# Set up our build environment
with tools.environment_append(env_vars):
autotools.configure(args=args)
autotools.make()
if 'gcc' == self.settings.compiler and 'Windows' == self.settings.os:
if self.env['DLLTOOL'] is not None:
self.run(
'{dlltool} --output-lib gmp.lib --input-def .libs/libgmp-3.dll.def --dllname libgmp-10.dll'
.format(dlltool=self.env['DLLTOOL']))
autotools.make(args=['install'])
def build_with_autotools(self):
autotools = AutoToolsBuildEnvironment(self, win_bash=self.is_mingw)
if self.settings.os != "Windows":
autotools.fpic = self.options.fPIC
autotools_vars = autotools.vars
# tweaks for mingw
if self.is_mingw:
# patch autotools files
self.patch_mingw_files()
autotools.defines.append('_AMD64_')
autotools_vars['RCFLAGS'] = '-O COFF'
if self.settings.arch == "x86":
autotools_vars['RCFLAGS'] += ' --target=pe-i386'
else:
autotools_vars['RCFLAGS'] += ' --target=pe-x86-64'
del autotools_vars['LIBS']
self.output.info("Autotools env vars: " + repr(autotools_vars))
env_run = RunEnvironment(self)
# run configure with *LD_LIBRARY_PATH env vars
# it allows to pick up shared openssl
self.output.info("Run vars: " + repr(env_run.vars))
with tools.environment_append(env_run.vars):
with tools.chdir(self.source_subfolder):
# autoreconf
self.run('./buildconf', win_bash=self.is_mingw)
# fix generated autotools files
tools.replace_in_file("configure", "-install_name \\$rpath/",
"-install_name ")
# BUG 1420, fixed in 7.54.1
if self.version_components[
0] == 7 and self.version_components[1] < 55:
tools.replace_in_file(
"configure",
'LDFLAGS="`$PKGCONFIG --libs-only-L zlib` $LDFLAGS"',
'LDFLAGS="$LDFLAGS `$PKGCONFIG --libs-only-L zlib`"')
self.run("chmod +x configure")
configure_args = self.get_configure_command_args()
autotools.configure(vars=autotools_vars, args=configure_args)
autotools.make(vars=autotools_vars)
autotools.install(vars=autotools_vars)
def build(self):
with tools.chdir(self.source_subfolder):
self.run("autoreconf -f -i")
autotools = AutoToolsBuildEnvironment(self)
autotools.fpic = True
_args = [
'--prefix=%s/builddir' % (os.getcwd()),
'--libdir=%s/builddir/lib' % (os.getcwd()),
'--disable-maintainer-mode', '--disable-silent-rules'
]
autotools.configure(args=_args)
autotools.make(args=["-j2"])
autotools.install()
def build(self):
with tools.chdir(self.name):
autotools = AutoToolsBuildEnvironment(
self, win_bash=(platform.system() == "Windows"))
env_vars = {}
args = []
if 'gcc' == self.settings.compiler and 'Windows' == platform.system(
):
args.append('--prefix=%s' %
tools.unix_path(self.package_folder))
else:
args.append('--prefix=%s' % self.package_folder)
args.append('--%s-shared' %
('enable' if self.options.shared else 'disable'))
args.append('--%s-static' %
('enable' if self.options.static else 'disable'))
if self.settings.os == "Linux" or self.settings.os == "Macos":
autotools.fpic = True
if self.settings.arch == 'x86':
env_vars['ABI'] = '32'
autotools.cxx_flags.append('-m32')
# Add GMP
autotools.library_paths.append(
os.path.join(self.deps_cpp_info['gmp'].rootpath,
self.deps_cpp_info['gmp'].libdirs[0]))
autotools.include_paths.append(
os.path.join(self.deps_cpp_info['gmp'].rootpath,
self.deps_cpp_info['gmp'].includedirs[0]))
# Debug
self.output.info('Configure arguments: %s' % ' '.join(args))
# Set up our build environment
with tools.environment_append(env_vars):
autotools.configure(args=args)
autotools.make()
if 'gcc' == self.settings.compiler and 'Windows' == self.settings.os:
if self.env['DLLTOOL'] is not None:
self.run(
'{dlltool} --output-lib mpfr.lib --input-def src/.libs/libmpfr-6.dll.def --dllname libmpfr-6.dll'
.format(dlltool=self.env['DLLTOOL']))
autotools.make(args=['install'])
def build_Linux(self):
autotools = AutoToolsBuildEnvironment(self)
env_build_vars = autotools.vars
autotools.fpic = True
autotools.library_paths.append(self.deps_cpp_info["proj"].lib_paths[0])
autotools.library_paths.append(self.deps_cpp_info["sqlite3"].lib_paths[0])
autotools.libs.append(self.deps_cpp_info["sqlite3"].libs[0])
install_dir = os.path.join(self.build_folder,"install")
options = ["--prefix="+install_dir, "--enable-shared=no", "--enable-static=yes", "CXXFLAGS=-fPIC","CFLAGS=-fPIC"]
if self.settings.build_type == "Debug":
options.append("--enable-debug=yes")
os.chdir("gdal")
autotools.configure(args=options,vars=env_build_vars)
autotools.make()
autotools.install()
os.chdir("../")
def build(self):
with tools.chdir(self.source_subfolder):
with tools.environment_append({'LIBS' : "-lm"}):
self.run("autoreconf -f -i")
_args = ["--prefix=%s/builddir"%(os.getcwd()), "--with-pic", "--disable-silent-rules", "--enable-introspection"]
if self.options.shared:
_args.extend(['--enable-shared=yes','--enable-static=no'])
else:
_args.extend(['--enable-shared=no','--enable-static=yes'])
autotools = AutoToolsBuildEnvironment(self)
autotools.fpic = True
autotools.configure(args=_args)
autotools.make(args=["-j4"])
autotools.install()
def build(self):
if self.settings.compiler == "Visual Studio":
#Just skip on win32
return
self.run("./autogen.sh")
autotools = AutoToolsBuildEnvironment(self)
if self.options.fPIC:
autotools.fpic = True
autotools.configure()
autotools.make()
autotools.install()
#If we're building static libraries we don't want the shared around.
if not self.options.shared:
for filename in Path(self.package_folder).glob('**/*.so*'):
print("Removing shared object file at {}".format(filename))
os.remove(str(filename))
def build(self):
if self.settings.compiler == 'Visual Studio':
# self.build_vs()
self.output.fatal(
"No windows support yet. Sorry. Help a fellow out and contribute back?"
)
with tools.chdir("sources"):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
config_args = []
for option_name in self.options.values.fields:
if (option_name == "shared"):
if (getattr(self.options, "shared")):
config_args.append("--enable-shared")
config_args.append("--disable-static")
else:
config_args.append("--enable-static")
config_args.append("--disable-shared")
else:
activated = getattr(self.options, option_name)
if activated:
self.output.info(
"Activated option! {0}".format(option_name))
config_args.append("--{0}".format(option_name))
# find the libgpg-error folder, so we can set the binary path for configuring it
gpg_error_path = ""
for path in self.deps_cpp_info.lib_paths:
if "libgpg-error" in path:
gpg_error_path = '/lib'.join(
path.split("/lib")[0:-1]
) #remove the final /lib. There are probably better ways to do this.
config_args.append("--with-libgpg-error-prefix={0}".format(
gpg_error_path))
break
# This is a terrible hack to make cross-compiling on Travis work
if (self.settings.arch == 'x86' and self.settings.os == 'Linux'):
env_build.configure(
args=config_args, host="i686-linux-gnu"
) #because Conan insists on setting this to i686-linux-gnueabi, which smashes gpg-error hard
else:
env_build.configure(args=config_args)
env_build.make()
def build_unix(self, install_folder):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = self.options.shared
with tools.environment_append(env_build.vars):
configure_command = "./configure"
configure_command += " --prefix=" + install_folder
configure_command += " --enable-shared=" + (
"yes" if self.options.shared else "no")
configure_command += " --enable-static=" + (
"yes" if not self.options.shared else "no")
src_path_abs = self.source_folder + "/apr-" + self.version
with tools.chdir(src_path_abs):
self.run(configure_command)
self.run("make -j " + str(max(tools.cpu_count() - 1, 1)))
self.run("make install")
def build_unix(self):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
with tools.environment_append(env_build.vars):
change_build_dir = "cd fltk && "
configure_cmd = "./configure"
make_cmd = "make -j%d" % (tools.cpu_count())
self.configure_options = ""
self.setConfigureOptions("enable-cygwin",
self.options.enable_cygwin)
self.setConfigureOptions("enable-x11", self.options.enable_x11)
self.setConfigureOptions("enable-cairoext",
self.options.enable_cairoext)
self.setConfigureOptions("enable-cairo", self.options.enable_cairo)
self.setConfigureOptions("enable-gl", self.options.enable_gl)
self.setConfigureOptions("enable-shared",
self.options.enable_shared)
self.setConfigureOptions("enable-threads",
self.options.enable_threads)
self.setConfigureOptions("enable-localjpeg",
self.options.enable_localjpeg)
self.setConfigureOptions("enable-localzlib",
self.options.enable_localzlib)
self.setConfigureOptions("enable-localpng",
self.options.enable_localpng)
self.setConfigureOptions("enable-xft", self.options.enable_xft)
self.setConfigureOptions("enable-xdbe", self.options.enable_xdbe)
self.setConfigureOptions("enable-xfixes",
self.options.enable_xfixes)
self.setConfigureOptions("enable-xcursor",
self.options.enable_xcursor)
self.setConfigureOptions("enable-xrender",
self.options.enable_xrender)
self.configure_options += " --enable-debug=%s" % (
"yes" if self.settings.build_type == "Debug" else "no")
if (self.options.disable_largefile):
self.configure_options += " --disable-largefile"
complete_configure_cmd = change_build_dir + configure_cmd + self.configure_options
self.output.info("Configure: " + complete_configure_cmd)
self.run(complete_configure_cmd)
complete_make_cmd = change_build_dir + make_cmd
self.output.info("Make: " + complete_make_cmd)
self.run(complete_make_cmd)
def build(self):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = self.options.fPIC
with tools.environment_append(env_build.vars):
with tools.chdir(self.source_subfolder):
self.run("./bootstrap")
config_args = []
config_args.append('--disable-%s' %
('static' if self.options.shared else 'shared'))
config_args.append("--prefix=%s" % self.package_folder)
config_args.append("--disable-tests")
env_build.configure(configure_dir=self.source_subfolder,
args=config_args)
env_build.make()
env_build.make(args=["install"])
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("build_type: " + str(self.settings.build_type))
if self.settings.compiler == "Visual Studio":
self.output.info("runtime : " +
str(self.settings.compiler.runtime))
with tools.chdir(self.ZIP_FOLDER_NAME):
files.mkdir("_build")
with tools.chdir("_build"):
if not tools.os_info.is_windows:
env_build = AutoToolsBuildEnvironment(self)
if self.settings.arch in ["x86", "x86_64"
] and self.settings.compiler in [
"apple-clang", "clang", "gcc"
]:
env_build.flags.append('-mstackrealign')
env_build.fpic = True
if self.settings.os == "Macos":
old_str = '-install_name $libdir/$SHAREDLIBM'
new_str = '-install_name $SHAREDLIBM'
tools.replace_in_file("../configure", old_str, new_str)
if self.settings.os == "Windows": # Cross building to Linux
tools.replace_in_file(
"../configure",
'LDSHAREDLIBC="${LDSHAREDLIBC--lc}"',
'LDSHAREDLIBC=""')
# Zlib configure doesnt allow this parameters
env_build.configure("../",
build=False,
host=False,
target=False)
env_build.make()
else:
cmake = CMake(self)
cmake.configure(build_dir=".")
cmake.build(build_dir=".")
def build_configure(self):
prefix = os.path.abspath(self.package_folder)
with tools.chdir(self._source_subfolder):
# works for unix and mingw environments
env_build = AutoToolsBuildEnvironment(
self,
win_bash=self.settings.os == 'Windows'
and platform.system() == 'Windows')
env_build.fpic = self.options.fPIC
if self.settings.os == 'Windows':
prefix = tools.unix_path(prefix)
args = ['--prefix=%s' % prefix]
if self.options.shared:
args.extend(['--disable-static', '--enable-shared'])
else:
args.extend(['--disable-shared', '--enable-static'])
args.append('--with-jpeg7' if self.options.
libjpeg7_compatibility else '--without-jpeg7')
args.append('--with-jpeg8' if self.options.
libjpeg8_compatibility else '--without-jpeg8')
args.append('--with-arith-enc' if self.options.
arithmetic_encoder else '--without-arith-enc')
args.append('--with-arith-dec' if self.options.
arithmetic_decoder else '--without-arith-dec')
args.append('--with-turbojpeg' if self.options.
turbojpeg else '--without-turbojpeg')
args.append('--with-mem-srcdst' if self.options.
mem_src_dst else '--without-mem-srcdst')
args.append('--with-12bit' if self.options.
enable12bit else '--without-12bit')
args.append(
'--with-java' if self.options.java else '--without-java')
args.append(
'--with-simd' if self.options.SIMD else '--without-simd')
if self.options.fPIC:
args.append('--with-pic')
if self.settings.os == "Macos":
tools.replace_in_file("configure",
r'-install_name \$rpath/\$soname',
r'-install_name \$soname')
env_build.configure(args=args)
env_build.make()
env_build.make(args=['install'])
def build(self):
self.patch()
if self.settings.os == "Windows":
cmake = CMake(self)
cmake.configure(source_folder=self.lib_name)
cmake.build()
cmake.install()
else:
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
env_build.configure(configure_dir=self.lib_name,
args=[
'--prefix',
self.package_folder,
],
build=False)
env_build.make()
env_build.make(args=['install'])
def build_make(self):
install_dir = os.path.abspath('lz4-install')
with tools.chdir(self.source_subfolder):
env_build = AutoToolsBuildEnvironment(self)
if self.settings.compiler != 'Visual Studio':
env_build.fpic = self.options.fPIC
with tools.environment_append(env_build.vars):
self.run("make")
self.run("make DESTDIR=%s install" % install_dir)
if self.settings.os == 'Macos' and self.options.shared:
lib_dir = os.path.join(install_dir, 'usr', 'local', 'lib')
old = '/usr/local/lib/liblz4.1.dylib'
new = 'liblz4.1.dylib'
for lib in os.listdir(lib_dir):
if lib.endswith('.dylib'):
self.run('install_name_tool -change %s %s %s' %
(old, new, os.path.join(lib_dir, lib)))
def build(self):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = True
configure_args = list()
configure_args.append('--prefix=%s' %
(os.path.join(self.build_folder, '__install')))
if (self.options.shared):
configure_args.append('--enable-shared')
configure_args.append('--disable-static')
else:
configure_args.append('--enable-static')
configure_args.append('--disable-shared')
env_build.configure(args=configure_args, configure_dir="gmp")
env_build.make()
env_build.make(args=["install"])
def _build_autotools(self):
prefix = os.path.abspath(self.package_folder)
rc = None
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"
rc = "windres --target=pe-i386"
elif self.settings.arch == "x86_64":
host = "x86_64-w64-mingw32"
rc = "windres --target=pe-x86-64"
#
# If you pass --build when building for iPhoneSimulator, the configure script halts.
# So, disable passing --build by setting it to False.
#
if self.settings.os == "iOS" and self.settings.arch == "x86_64":
build = False
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]
if self.options.shared:
configure_args.extend(['--disable-static', '--enable-shared'])
else:
configure_args.extend(['--enable-static', '--disable-shared'])
env_vars = {}
if rc:
configure_args.extend(['RC=%s' % rc, 'WINDRES=%s' % rc])
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(self):
for p in self.conan_data["patches"][self.version]:
tools.patch(**p)
self.patch_source()
if self.settings.os == "Linux" or self.settings.os == "Macos":
env = AutoToolsBuildEnvironment(self)
env.fpic = self.options.fPIC
args = []
if self.options.cpp_bindings:
args.append("--enable-cxx")
if self.settings.os == "Macos" and self.settings.compiler == "apple-clang":
args.append("--disable-mac-universal")
elif self.settings.os == "Linux":
args.append("--with-alsa" if self.options.
with_alsa else "--without-alsa")
args.append("--with-jack" if self.options.
with_jack else "--without-jack")
if self.options.with_alsa:
env.flags.extend(
"-I%s" % p
for p in self.deps_cpp_info["libalsa"].include_paths
) # env.include_paths does not seem to work here
env.configure(configure_dir=self.sources_folder, args=args)
if self.settings.os == "Macos" and self.settings.compiler == "apple-clang":
env_args = []
if self.options.cpp_bindings:
env_args.append("-j1")
env.make(args=env_args)
else:
env.make(target="lib/libportaudio.la")
if self.settings.os == "Macos" and self.options.shared:
self.run(
'cd lib/.libs && for filename in *.dylib; do install_name_tool -id $filename $filename; done'
)
else:
cmake = CMake(self)
cmake.definitions[
"MSVS"] = self.settings.compiler == "Visual Studio"
cmake.definitions["PA_BUILD_STATIC"] = not self.options.shared
cmake.definitions["PA_BUILD_SHARED"] = self.options.shared
cmake.configure()
cmake.build()
def _make_args(self):
prefix = os.path.abspath(self.package_folder)
if tools.os_info.is_windows:
prefix = tools.unix_path(prefix)
args = [
"ARCH={}".format(self._make_arch),
"PREFIX={}".format(prefix),
]
autotools = AutoToolsBuildEnvironment(self)
if self._is_msvc:
autotools.flags.extend(
["-nologo", "-{}".format(self.settings.compiler.runtime)])
autotools.link_flags.insert(0, "-link")
if not (self.settings.compiler == "Visual Studio"
and tools.Version(self.settings.compiler.version) < "12"):
autotools.flags.append("-FS")
elif self.settings.compiler in ("apple-clang", ):
if self.settings.arch in ("armv8", ):
autotools.link_flags.append("-arch arm64")
if self.options.shared:
autotools.fpic = True
args.extend(["{}={}".format(k, v) for k, v in autotools.vars.items()])
if self._is_msvc:
args.append("OS=msvc")
else:
if self.settings.os == "Windows":
args.append("OS=mingw_nt")
if self.settings.os == "Android":
libcxx = str(self.settings.compiler.libcxx)
stl_lib = "$(NDKROOT)/sources/cxx-stl/llvm-libc++/libs/$(APP_ABI)/lib{}".format("c++_static.a" if libcxx == "c++_static" else "c++_shared.so") \
+ "$(NDKROOT)/sources/cxx-stl/llvm-libc++/libs/$(APP_ABI)/libc++abi.a"
ndk_home = os.environ["ANDROID_NDK_HOME"]
args.extend([
"NDKLEVEL={}".format(self.settings.os.api_level),
"STL_LIB={}".format(stl_lib),
"OS=android",
"NDKROOT={}".format(ndk_home), # not NDK_ROOT here
"TARGET={}".format(self._android_target),
"CCASFLAGS=$(CFLAGS) -fno-integrated-as",
])
return args
def build(self):
with tools.chdir(self._source_subfolder):
env_build = AutoToolsBuildEnvironment(self)
env_build.fpic = self.options.fPIC
args = ['--disable-wrapper-rpath', '--disable-wrapper-runpath']
if self.settings.build_type == 'Debug':
args.append('--enable-debug')
if self.options.shared:
args.extend(['--enable-shared', '--disable-static'])
else:
args.extend(['--enable-static', '--disable-shared'])
args.append('--with-pic' if self.options.fPIC else '--without-pic')
args.append('--enable-mpi-fortran=%s' % str(self.options.fortran))
args.append('--with-zlib=%s' % self.deps_cpp_info['zlib'].rootpath)
args.append('--with-zlib-libdir=%s' %
self.deps_cpp_info['zlib'].lib_paths[0])
env_build.configure(args=args)
env_build.make()
env_build.install()
def build(self):
with tools.chdir(self.name):
autotools = AutoToolsBuildEnvironment(self, win_bash=(platform.system() == "Windows"))
env_vars = {}
args = []
if 'gcc' == self.settings.compiler and 'Windows' == platform.system():
args.append('--prefix=%s'%tools.unix_path(self.package_folder))
else:
args.append('--prefix=%s'%self.package_folder)
for option_name in self.options.values.fields:
activated = getattr(self.options, option_name)
if not re.match(r'enable|disable', option_name):
continue
if activated:
option_name = option_name.replace("_", "-")
self.output.info("Activated option! %s"%option_name)
args.append('--%s'%option_name)
args.append('--%s-shared'%('enable' if self.options.shared else 'disable'))
args.append('--%s-static'%('enable' if self.options.static else 'disable'))
if self.settings.os == 'Linux' or self.settings.os == 'Macos':
autotools.fpic = True
if self.settings.arch == 'x86':
env_vars['ABI'] = '32'
autotools.cxx_flags.append('-m32')
if self.settings.get_safe('arch') and self.settings.get_safe('arch').startswith('arm') and not tools.cross_building(self.settings):
# There's an issue with the assemle gmp attempts to use when building on ARM
args.append('--enable-assembly=no')
# Debug
self.output.info('Configure arguments: %s'%' '.join(args))
# Set up our build environment
with tools.environment_append(env_vars):
autotools.configure(args=args)
autotools.make()
autotools.make(args=['install'])
