def visual_build(self): self.output.warn("----------CONFIGURING OPENSSL FOR WINDOWS. %s-------------" % self.version) target = self._get_target() no_asm = "no-asm" if self.options.no_asm else "" # Will output binaries to ./binaries with tools.vcvars(self.settings, filter_known_paths=False): config_command = "perl Configure %s %s --prefix=%s/binaries %s" % (target, no_asm, self.source_folder, self._get_flags()) self.output.warn(config_command) self.run_in_src(config_command) self._patch_runtime() self.output.warn("----------MAKE OPENSSL %s-------------" % self.version) self.run_in_src("nmake build_libs")
def build(self): with tools.vcvars(self.settings) if self._use_nmake else tools.no_op(): env_vars = {"PERL": self._perl} if self._full_version < "1.1.0": cflags = " ".join(self._get_env_build().flags) env_vars["CC"] = "%s %s" % (self._cc, cflags) if self.settings.compiler == "apple-clang": xcrun = tools.XCRun(self.settings) env_vars["CROSS_SDK"] = os.path.basename(xcrun.sdk_path) env_vars["CROSS_TOP"] = os.path.dirname(os.path.dirname(xcrun.sdk_path)) with tools.environment_append(env_vars): if self._full_version >= "1.1.0": self._create_targets() else: self._patch_makefile_org() self._make()
def run(self): context = tools.no_op() compiler = self.settings.get("compiler", None) if not self._exclude_vcvars_precommand: if compiler == "Visual Studio" and "compiler.version" in self.settings: compiler_set = namedtuple("compiler", "version")( self.settings["compiler.version"]) mock_sets = namedtuple( "mock_settings", "arch compiler get_safe")( self.settings["arch"], compiler_set, lambda x: self.settings.get(x, None)) context = tools.vcvars(mock_sets) with context: self.printer.print_rule() self.printer.print_profile(tools.load(self._profile_abs_path)) with self.printer.foldable_output("conan_create"): name, version, user, channel = self._reference if self._build_policy: self._build_policy = [self._build_policy] # https://github.com/conan-io/conan-package-tools/issues/184 with tools.environment_append({"_CONAN_CREATE_COMMAND_": "1"}): params = { "name": name, "version": version, "user": user, "channel": channel, "build_modes": self._build_policy, "profile_name": self._profile_abs_path } self.printer.print_message("Calling 'conan create'") self.printer.print_dict(params) r = self._conan_api.create( ".", name=name, version=version, user=user, channel=channel, build_modes=self._build_policy, profile_name=self._profile_abs_path, test_folder=self._test_folder) for installed in r['installed']: if installed["recipe"]["id"] == str(self._reference): package_id = installed['packages'][0]['id'] self._uploader.upload_packages( self._reference, self._upload, package_id)
def build(self): for patch in self.conan_data.get("patches", {}).get(self.version, []): tools.patch(**patch) if self.options.dat_package_file: dat_package_file = glob.glob(os.path.join(self.source_folder, self._source_subfolder, "source", "data", "in", "*.dat")) if dat_package_file: shutil.copy(str(self.options.dat_package_file), dat_package_file[0]) if self._is_msvc: run_configure_icu_file = os.path.join(self._source_subfolder, "source", "runConfigureICU") if self.settings.compiler == "Visual Studio": flags = "-{}".format(self.settings.compiler.runtime) if tools.Version(self.settings.compiler.version) >= "12": flags += " -FS" else: flags = "-{}{}".format( "MT" if self.settings.runtime == "static" else "MD", "d" if self.settings.runtime_type == "Debug" else "", ) flags += " -FS" tools.replace_in_file(run_configure_icu_file, "-MDd", flags) tools.replace_in_file(run_configure_icu_file, "-MD", flags) self._workaround_icu_20545() env_build = self._configure_autotools() build_dir = os.path.join(self.build_folder, self._source_subfolder, "build") os.mkdir(build_dir) with tools.vcvars(self.settings) if self._is_msvc else tools.no_op(): with tools.environment_append(env_build.vars): with tools.chdir(build_dir): # workaround for https://unicode-org.atlassian.net/browse/ICU-20531 os.makedirs(os.path.join("data", "out", "tmp")) # workaround for "No rule to make target 'out/tmp/dirs.timestamp'" tools.save(os.path.join("data", "out", "tmp", "dirs.timestamp"), "") self.run(self._build_config_cmd, win_bash=tools.os_info.is_windows) command = "{make} {silent} -j {cpu_count}".format(make=self._make_tool, silent=self._silent, cpu_count=tools.cpu_count()) self.run(command, win_bash=tools.os_info.is_windows) if self.options.with_unit_tests: command = "{make} {silent} check".format(make=self._make_tool, silent=self._silent) self.run(command, win_bash=tools.os_info.is_windows)
def build(self): if self.settings.compiler == "Visual Studio": os.makedirs(os.path.join(self._source_subfolder, "sys")) tools.download( "https://raw.githubusercontent.com/win32ports/unistd_h/master/unistd.h", os.path.join(self._source_subfolder, "unistd.h")) tools.download( "https://raw.githubusercontent.com/win32ports/sys_time_h/master/sys/time.h", os.path.join(self._source_subfolder, "sys", "time.h")) with tools.vcvars( self.settings ) if self.settings.compiler == "Visual Studio" else tools.no_op(): with tools.chdir(self._source_subfolder): host = None build = None if self.settings.compiler == "Visual Studio": 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) args = ["--disable-dependency-tracking", "--disable-doc"] 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.compiler == "Visual Studio": runtime = str(self.settings.compiler.runtime) prefix = tools.unix_path(self.package_folder) args.extend([ 'CC=$PWD/build-aux/compile cl -nologo', 'CFLAGS=-%s' % runtime, 'CXX=$PWD/build-aux/compile cl -nologo', 'CXXFLAGS=-%s' % runtime, 'CPPFLAGS=-D_WIN32_WINNT=0x0600 -I%s/include' % prefix, 'LDFLAGS=-L%s/lib' % prefix, 'LD=link', 'NM=dumpbin -symbols', 'STRIP=:', 'AR=$PWD/build-aux/ar-lib lib', 'RANLIB=:' ]) env_build.configure(args=args, build=build, host=host) with tools.chdir("lib"): env_build.make() env_build.install()
def _build_windows(self): with tools.chdir(os.path.join(self._full_source_subfolder, 'win32')): debug = "yes" if self.settings.build_type == "Debug" else "no" static = "no" if self.options.shared else "yes" with tools.vcvars(self.settings): args = ["cscript", "configure.js", "compiler=msvc", "prefix=%s" % self.package_folder, "cruntime=/%s" % self.settings.compiler.runtime, "debug=%s" % debug, "static=%s" % static, 'include="%s"' % ";".join(self.deps_cpp_info.include_paths), 'lib="%s"' % ";".join(self.deps_cpp_info.lib_paths), 'iconv=no', 'xslt_debug=no', 'debugger=no', 'crypto=no'] configure_command = ' '.join(args) self.output.info(configure_command) self.run(configure_command) # Fix library names because they can be not just zlib.lib def format_libs(package): libs = [] for lib in self.deps_cpp_info[package].libs: libname = lib if not libname.endswith('.lib'): libname += '.lib' libs.append(libname) return ' '.join(libs) def fix_library(option, package, old_libname): if option: tools.replace_in_file("Makefile.msvc", "LIBS = %s" % old_libname, "LIBS = %s" % format_libs(package)) if "icu" in self.deps_cpp_info.deps: fix_library(True, 'icu', 'wsock32.lib') tools.replace_in_file("Makefile.msvc", "libxml2.lib", format_libs("libxml2")) tools.replace_in_file("Makefile.msvc", "libxml2_a.lib", format_libs("libxml2")) with tools.environment_append(VisualStudioBuildEnvironment(self).vars): self.run("nmake /f Makefile.msvc install")
def build(self): with tools.chdir(self.source_subfolder): build_config = "build_config.rb" os.rename(build_config, build_config + ".0") with open(build_config, "w") as f: f.write("MRuby::Build.new do |conf|\n") if self.settings.compiler == "Visual Studio": f.write(" toolchain :visualcpp\n") else: f.write(" toolchain :gcc\n") if self.settings.build_type == "Debug": f.write(" enable_debug\n") if self.options.enable_cxx_abi: f.write(" enable_cxx_abi\n") if self.settings.compiler != "Visual Studio": env = AutoToolsBuildEnvironment(self) vars = env.vars c_flags = vars["CFLAGS"] + " " + vars["CPPFLAGS"] f.write(" conf.cc do |cc|\n") f.write(" cc.flags << %%w(%s)\n" % c_flags) f.write(" end\n") f.write(" conf.linker do |linker|\n") f.write(" linker.flags << %%w(%s)\n" % vars["LDFLAGS"]) f.write(" end\n") else: env = VisualStudioBuildEnvironment(self) vars = env.vars print(vars) f.write(" conf.cc do |cc|\n") f.write(" cc.flags << %%w(%s)\n" % vars["CL"]) f.write(" print(cc.flags)\n") f.write(" end\n") # default gembox f.write(" conf.gembox 'default'\n") f.write("end\n") print("== generated build_config.rb ==") print(open(build_config, "r").read()) print("===============================") with tools.vcvars(self.settings): self.run("ruby minirake")
def _build_nmake(self, target="release"): # https://core.tcl.tk/tips/doc/trunk/tip/477.md opts = [] if not self.options.shared: opts.append("static") if self.settings.build_type == "Debug": opts.append("symbols") if "MD" in str(self.settings.compiler.runtime): opts.append("msvcrt") else: opts.append("nomsvcrt") if "d" not in str(self.settings.compiler.runtime): opts.append("unchecked") # https://core.tcl.tk/tk/tktview?name=3d34589aa0 # https://wiki.tcl-lang.org/page/Building+with+Visual+Studio+2017 tcl_lib_path = os.path.join(self.deps_cpp_info["tcl"].rootpath, "lib") tclimplib, tclstublib = None, None for lib in os.listdir(tcl_lib_path): if not lib.endswith(".lib"): continue if lib.startswith("tcl{}".format("".join( self.version.split(".")[:2]))): tclimplib = os.path.join(tcl_lib_path, lib) elif lib.startswith("tclstub{}".format("".join( self.version.split(".")[:2]))): tclstublib = os.path.join(tcl_lib_path, lib) if tclimplib is None or tclstublib is None: raise ConanException( "tcl dependency misses tcl and/or tclstub library") with tools.vcvars(self.settings): tcldir = self.deps_cpp_info["tcl"].rootpath.replace("/", "\\\\") self.run( """nmake -nologo -f "{cfgdir}/makefile.vc" INSTALLDIR="{pkgdir}" OPTS={opts} TCLDIR="{tcldir}" TCL_LIBRARY="{tcl_library}" TCLIMPLIB="{tclimplib}" TCLSTUBLIB="{tclstublib}" {target}""" .format( cfgdir=self._get_configure_folder("win"), pkgdir=self.package_folder, opts=",".join(opts), tcldir=tcldir, tclstublib=tclstublib, tclimplib=tclimplib, tcl_library=self.deps_env_info['tcl'].TCL_LIBRARY.replace( "\\", "/"), target=target, ), cwd=self._get_configure_folder("win"), )
def build_visual(self): # fully replace gif_lib.h for VS, with patched version ver_components = self.version.split(".") tools.replace_in_file('gif_lib.h', '@GIFLIB_MAJOR@', ver_components[0]) tools.replace_in_file('gif_lib.h', '@GIFLIB_MINOR@', ver_components[1]) tools.replace_in_file('gif_lib.h', '@GIFLIB_RELEASE@', ver_components[2]) shutil.copy('gif_lib.h', os.path.join(self._source_subfolder, 'lib')) # add unistd.h for VS shutil.copy('unistd.h', os.path.join(self._source_subfolder, 'lib')) with tools.chdir(self._source_subfolder): if self.settings.arch == "x86": host = "i686-w64-mingw32" elif self.settings.arch == "x86_64": host = "x86_64-w64-mingw32" else: raise ConanInvalidConfiguration("unsupported architecture %s" % self.settings.arch) if self.options.shared: options = '--disable-static --enable-shared' else: options = '--enable-static --disable-shared' cflags = '' if not self.options.shared: cflags = '-DUSE_GIF_LIB' prefix = tools.unix_path(os.path.abspath(self.package_folder)) with tools.vcvars(self.settings): command = './configure ' \ '{options} ' \ '--host={host} ' \ '--prefix={prefix} ' \ 'CC="$PWD/compile cl -nologo" ' \ 'CFLAGS="-{runtime} {cflags}" ' \ 'CXX="$PWD/compile cl -nologo" ' \ 'CXXFLAGS="-{runtime} {cflags}" ' \ 'CPPFLAGS="-I{prefix}/include" ' \ 'LDFLAGS="-L{prefix}/lib" ' \ 'LD="link" ' \ 'NM="dumpbin -symbols" ' \ 'STRIP=":" ' \ 'AR="$PWD/ar-lib lib" ' \ 'RANLIB=":" '.format(host=host, prefix=prefix, options=options, runtime=self.settings.compiler.runtime, cflags=cflags) self.run(command, win_bash=True) self.run('make', win_bash=True) self.run('make install', win_bash=True)
def _upgrade_single_project_file(self, project_file): """ `devenv /upgrade <project.vcxproj>` will upgrade *ALL* projects referenced by the project. By temporarily moving the solution project, only one project is upgraded This is needed for static cpython or for disabled optional dependencies (e.g. tkinter=False) Restore it afterwards because it is needed to build some targets. """ tools.rename(os.path.join(self._source_subfolder, "PCbuild", "pcbuild.sln"), os.path.join(self._source_subfolder, "PCbuild", "pcbuild.sln.bak")) tools.rename(os.path.join(self._source_subfolder, "PCbuild", "pcbuild.proj"), os.path.join(self._source_subfolder, "PCbuild", "pcbuild.proj.bak")) with tools.vcvars(self.settings): self.run("devenv \"{}\" /upgrade".format(project_file), run_environment=True) tools.rename(os.path.join(self._source_subfolder, "PCbuild", "pcbuild.sln.bak"), os.path.join(self._source_subfolder, "PCbuild", "pcbuild.sln")) tools.rename(os.path.join(self._source_subfolder, "PCbuild", "pcbuild.proj.bak"), os.path.join(self._source_subfolder, "PCbuild", "pcbuild.proj"))
def build(self): for patch in self.conan_data.get("patches").get(self.version, []): tools.patch(**patch) with tools.chdir(self._source_subfolder): # README.W32 if tools.os_info.is_windows: if self.settings.compiler == "Visual Studio": command = "build_w32.bat --without-guile" else: command = "build_w32.bat --without-guile gcc" else: env_build = AutoToolsBuildEnvironment(self) env_build.configure() command = "./build.sh" with tools.vcvars(self.settings) if self.settings.compiler == "Visual Studio" else tools.no_op(): self.run(command)
def _build_context(self): if self.settings.compiler == "Visual Studio": with tools.vcvars(self.settings): env = { "CC": "{} cl -nologo".format(tools.unix_path(self.deps_user_info["automake"].compile)), "CXX": "{} cl -nologo".format(tools.unix_path(self.deps_user_info["automake"].compile)), "LD": "link -nologo", "AR": "{} lib".format(tools.unix_path(self.deps_user_info["automake"].ar_lib)), "DLLTOOL": ":", "OBJDUMP": ":", "RANLIB": ":", "STRIP": ":", } with tools.environment_append(env): yield else: yield
def _build_context(self): if self.settings.compiler == "Visual Studio": with tools.vcvars(self.settings): env = { "AR": "{}/build-aux/ar-lib lib".format(tools.unix_path(self._source_subfolder)), "CC": "cl -nologo", "CXX": "cl -nologo", "LD": "link", "NM": "dumpbin -symbols", "OBJDUMP": ":", "RANLIB": ":", "STRIP": ":", } with tools.environment_append(env): yield else: yield
def build_msvc(self): with tools.chdir(self._source_subfolder): # https://cairographics.org/end_to_end_build_for_win32/ win32_common = os.path.join('build', 'Makefile.win32.common') tools.replace_in_file(win32_common, '-MD ', '-%s ' % self.settings.compiler.runtime) tools.replace_in_file(win32_common, '-MDd ', '-%s ' % self.settings.compiler.runtime) tools.replace_in_file(win32_common, '$(ZLIB_PATH)/zdll.lib', self.deps_cpp_info['zlib'].libs[0] + '.lib') tools.replace_in_file(win32_common, '$(LIBPNG_PATH)/libpng.lib', self.deps_cpp_info['libpng'].libs[0] + '.lib') tools.replace_in_file(win32_common, '$(PIXMAN_PATH)/pixman/$(CFG)/pixman-1.lib', self.deps_cpp_info['pixman'].libs[0] + '.lib') with tools.vcvars(self.settings): env_msvc = VisualStudioBuildEnvironment(self) env_msvc.flags.append('/FS') # C1041 if multiple CL.EXE write to the same .PDB file, please use /FS with tools.environment_append(env_msvc.vars): env_build = AutoToolsBuildEnvironment(self) env_build.make(args=['-f', 'Makefile.win32', 'CFG=%s' % str(self.settings.build_type).lower()])
def _build_context(self): if self.settings.compiler == "Visual Studio": with tools.vcvars(self): env = { "CC": "{} cl -nologo".format( tools.unix_path( self._user_info_build["automake"].compile)), "LD": "{} link -nologo".format( tools.unix_path( self._user_info_build["automake"].compile)), } with tools.environment_append(env): yield else: yield
def build(self): cmake, env = self._set_up_cmake() if len(env.keys()): s = '\nAdditional Environment:\n' for k,v in env.items(): s += ' - %s=%s\n'%(k, v) self.output.info(s) with tools.environment_append(env): if tools.os_info.is_windows and 'Visual Studio' == self.settings.compiler: with tools.vcvars(self.settings, filter_known_paths=False): cmake.configure(source_folder=self.name) cmake.build() else: cmake.configure(source_folder=self.name) cmake.build()
def _build_msvc(self): kwargs = {} with tools.chdir(os.path.join(self._source_subfolder, "msvc++")): # cl : Command line error D8016: '/ZI' and '/Gy-' command-line options are incompatible tools.replace_in_file("libid3tag.dsp", "/ZI ", "") if self.settings.compiler == "clang": tools.replace_in_file("libid3tag.dsp", "CPP=cl.exe", "CPP=clang-cl.exe") tools.replace_in_file("libid3tag.dsp", "RSC=rc.exe", "RSC=llvm-rc.exe") kwargs["toolset"] = "ClangCl" if self.settings.arch == "x86_64": tools.replace_in_file("libid3tag.dsp", "Win32", "x64") with tools.vcvars(self.settings): self.run("devenv /Upgrade libid3tag.dsp") msbuild = MSBuild(self) msbuild.build(project_file="libid3tag.vcxproj", **kwargs)
def package(self): self.copy('LICENSE', dst='licenses', src=self._source_folder) with tools.chdir(self._source_folder): if self.settings.compiler == "Visual Studio": with tools.vcvars(self.settings): self.run('nmake install DESTROOT=%s' % self.package_folder) else: autotools = self._configure_autotools() tools.mkdir(os.path.join(self.package_folder, "include")) tools.mkdir(os.path.join(self.package_folder, "lib")) autotools.make(target="install-headers") if self.options.shared: tools.mkdir(os.path.join(self.package_folder, "bin")) autotools.make(target="install-dlls") autotools.make(target="install-implib-default") else: autotools.make(target="install-lib-default")
def _build_context(self): if self.settings.compiler == "Visual Studio": with tools.vcvars(self): env = { "CC": "{} cl -nologo".format(tools.unix_path(self.deps_user_info["automake"].compile)), "CXX": "{} cl -nologo".format(tools.unix_path(self.deps_user_info["automake"].compile)), "CFLAGS": "-{}".format(self.settings.compiler.runtime), "LD": "link", "NM": "dumpbin -symbols", "STRIP": ":", "AR": "{} lib".format(tools.unix_path(self.deps_user_info["automake"].ar_lib)), "RANLIB": ":", } with tools.environment_append(env): yield else: yield
def package(self): self.copy("COPYING", src=self._source_subfolder, dst="licenses") with tools.vcvars(self) if self._is_clang_cl else tools.no_op(): meson = self._configure_meson() meson.install() if self._is_msvc: tools.remove_files_by_mask(os.path.join(self.package_folder, "bin"), "*.pdb") if not self.options.shared: os.rename(os.path.join(self.package_folder, "lib", "libpkgconf.a"), os.path.join(self.package_folder, "lib", "pkgconf.lib"),) tools.rmdir(os.path.join(self.package_folder, "share", "man")) os.rename(os.path.join(self.package_folder, "share", "aclocal"), os.path.join(self.package_folder, "bin", "aclocal")) tools.rmdir(os.path.join(self.package_folder, "share")) tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig"))
def package(self): self.copy(pattern="LICENSE", src=self._source_subfolder, dst="licenses") with tools.vcvars(self) if self._is_msvc else tools.no_op(): autotools = self._configure_autotools() autotools.install() tools.rmdir(os.path.join(self.package_folder, "lib", "pkgconfig")) if self._is_msvc: # don't trust install target tools.rmdir(os.path.join(self.package_folder, "lib")) libdir = os.path.join( "Win32" if self.settings.arch == "x86" else "x64", "Debug" if self.settings.build_type == "Debug" else "Release", ) self.copy("vpx*.lib", src=libdir, dst="lib")
def bootstrap(self): folder = os.path.join(self.source_folder, self.folder_name, "tools", "build") try: bootstrap = "bootstrap.bat" if tools.os_info.is_windows else "./bootstrap.sh" with tools.vcvars(self.settings) if self.settings.compiler == "Visual Studio" else tools.no_op(): self.output.info("Using %s %s" % (self.settings.compiler, self.settings.compiler.version)) with tools.chdir(folder): option = "" if tools.os_info.is_windows else "-with-toolset=" cmd = "%s %s%s" % (bootstrap, option, self._get_boostrap_toolset()) self.output.info(cmd) self.run(cmd) except Exception as exc: self.output.warn(str(exc)) if os.path.exists(os.path.join(folder, "bootstrap.log")): self.output.warn(tools.load(os.path.join(folder, "bootstrap.log"))) raise return os.path.join(folder, "b2.exe") if tools.os_info.is_windows else os.path.join(folder, "b2")
def _build_context(self): env = {} if self.settings.compiler != "Visual Studio": env["YACC"] = self._user_info_build["bison"].YACC if self.settings.compiler == "Visual Studio": with tools.vcvars(self): env.update({ "CC": "{} cl -nologo".format(tools.unix_path(self._user_info_build["automake"].compile)), "CXX": "{} cl -nologo".format(tools.unix_path(self._user_info_build["automake"].compile)), "AR": "{} link".format(self._user_info_build["automake"].ar_lib), "LD": "link", }) with tools.environment_append(env): yield else: with tools.environment_append(env): yield
def build(self): if self.settings.os == "Windows": if tools.os_info.detect_windows_subsystem() not in ("cygwin", "msys2"): raise ConanInvalidConfiguration("This recipe needs a Windows Subsystem to be compiled. " "You can specify a build_require to:" " 'msys2_installer/latest@bincrafters/stable' or" " 'cygwin_installer/2.9.0@bincrafters/stable' or" " put in the PATH your own installation") if self._is_msvc: with tools.vcvars(self.settings): self._build_autotools() elif self._is_mingw_windows: self._build_autotools() else: raise ConanInvalidConfiguration("unsupported build") else: self._build_autotools()
def _build_context(self): if self.settings.compiler == "Visual Studio": with tools.vcvars(self.settings): msvc_env = { "CC": "cl -nologo", "CXX": "cl -nologo", "LD": "link -nologo", "LDFLAGS": "", "NM": "dumpbin -symbols", "STRIP": ":", "AR": "lib -nologo", "RANLIB": ":", } with tools.environment_append(msvc_env): yield else: yield
def build(self): with tools.chdir("libmaxminddb"): if self.settings.compiler != "Visual Studio": self.run("autoreconf -fiv", run_environment=True) args = ["--prefix=%s" % self.package_folder] if self.options.shared: args.extend(["--disable-static", "--enable-shared"]) else: args.extend(["--disable-shared", "--enable-static"]) if self.settings.build_type == "Debug": args.append("--enable-debug") if self.options.fPIC: args.append("--with-pic") else: args.append("--without-pic") if tools.cross_building(self.settings): args.append("--disable-tests") autotools = AutoToolsBuildEnvironment(self) autotools.configure(args=args) autotools.make() if not tools.cross_building(self.settings): self.run("make check") autotools.install() else: if self.options["shared"]: self.output.warning( "libmaxminddb does not support building dynamic library yet, building static library instead" ) self.options["shared"] = False with tools.vcvars(self.settings): sdk = tools.get_env("WindowsSDKVersion") if sdk: sdk = sdk.strip(" \\") msbuild = MSBuild(self) msbuild.build( "projects/VS12/libmaxminddb.sln", targets=["libmaxminddb"], properties={"WindowsTargetPlatformVersion": sdk} if sdk else {}, platforms={"x86": "Win32"}, )
def build(self): for f in glob.glob("*.cmake"): tools.replace_in_file(f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:>", "", strict=False) tools.replace_in_file(f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:>", "", strict=False) tools.replace_in_file(f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,EXECUTABLE>:>", "", strict=False) tools.replace_in_file(f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,SHARED_LIBRARY>:-Wl,--export-dynamic>", "", strict=False) tools.replace_in_file(f, "$<$<STREQUAL:$<TARGET_PROPERTY:TYPE>,MODULE_LIBRARY>:-Wl,--export-dynamic>", "", strict=False) with tools.vcvars(self.settings) if self.settings.compiler == "Visual Studio" else tools.no_op(): # next lines force cmake package to be in PATH before the one provided by visual studio (vcvars) build_env = tools.RunEnvironment(self).vars if self.settings.compiler == "Visual Studio" else {} build_env["MAKEFLAGS"] = "j%d" % tools.cpu_count() build_env["PKG_CONFIG_PATH"] = [self.build_folder] if self.settings.os == "Windows": if not "PATH" in build_env: build_env["PATH"] = [] build_env["PATH"].append(os.path.join(self.source_folder, "qt6", "gnuwin32", "bin")) if self.settings.compiler == "Visual Studio": # this avoids cmake using gcc from strawberryperl build_env["CC"] = "cl" build_env["CXX"] = "cl" with tools.environment_append(build_env): if tools.os_info.is_macos: open(".qmake.stash" , "w").close() open(".qmake.super" , "w").close() cmake = self._configure_cmake() if tools.os_info.is_macos: with open("bash_env", "w") as f: f.write('export DYLD_LIBRARY_PATH="%s"' % ":".join(RunEnvironment(self).vars["DYLD_LIBRARY_PATH"])) with tools.environment_append({ "BASH_ENV": os.path.abspath("bash_env") }) if tools.os_info.is_macos else tools.no_op(): with tools.run_environment(self): cmake.build()
def build(self): if tools.os_info.is_windows: msys_bin = self.deps_env_info["msys2_installer"].MSYS_BIN # Make sure that Ruby is first in the path order path = self.deps_env_info["ruby_installer"].path + [msys_bin] with tools.environment_append({ "PATH": path, "CONAN_BASH_PATH": os.path.join(msys_bin, "bash.exe") }): if self.settings.compiler == "Visual Studio": with tools.vcvars(self.settings): self.build_configure() else: self.build_configure() else: self.build_configure()
def _build_context(self): env = {} if self.settings.compiler == "Visual Studio": with tools.vcvars(self.settings): env.update({ "AR": "{} lib".format(tools.unix_path(self.deps_user_info["automake"].ar_lib)), "CC": "{} cl -nologo".format(tools.unix_path(self.deps_user_info["automake"].compile)), "CXX": "{} cl -nologo".format(tools.unix_path(self.deps_user_info["automake"].compile)), "NM": "dumpbin -symbols", "OBJDUMP": ":", "RANLIB": ":", "STRIP": ":", }) with tools.environment_append(env): yield else: with tools.environment_append(env): yield
def _build_vs(self): with tools.chdir( os.path.join(self._source_subfolder, 'Mkfiles', 'vc10')): with tools.vcvars(self.settings, arch=str(self.settings.arch_build), force=True): msbuild = MSBuild(self) if self.settings.arch_build == "x86": msbuild.build_env.link_flags.append('/MACHINE:X86') elif self.settings.arch_build == "x86_64": msbuild.build_env.link_flags.append( '/SAFESEH:NO /MACHINE:X64') msbuild.build(project_file="yasm.sln", arch=self.settings.arch_build, build_type="Release", targets=["yasm"], platforms={"x86": "Win32"}, force_vcvars=True)