def vvcars_command_test(self): fake_settings = settings.Settings({"os": "Windows", "arch": "x86_64"}) # preference order with VS 15 with (tools.environment_append({ "CONAN_VS_INSTALLATION_PREFERENCE": "BuildTools, Community,Professional, Enterprise" })): command = tools.vcvars_command(settings=fake_settings, compiler_version="15") self.assertNotIn("Community", command) self.assertIn("VC/Auxiliary/Build/vcvarsall.bat", command) self.assertIn("Microsoft Visual Studio\\2017\\BuildTools", command) self.assertIn("VSCMD_START_DIR", command) with (tools.environment_append({ "CONAN_VS_INSTALLATION_PREFERENCE": "Professional, Enterprise,Community" })): command = tools.vcvars_command(settings=fake_settings, compiler_version="15") self.assertNotIn("BuildTools", command) self.assertIn("VC/Auxiliary/Build/vcvarsall.bat", command) self.assertIn("Microsoft Visual Studio\\2017\\Community", command) self.assertIn("VSCMD_START_DIR", command) # With VS 14 order of preference does not apply command = tools.vcvars_command(settings=fake_settings, compiler_version="14") self.assertNotIn("VSCMD_START_DIR", command) self.assertIn("VC/vcvarsall.bat", command) self.assertIn("Microsoft Visual Studio 14.0\\", command)
def test_invalid(self): if platform.system() != "Windows": return fake_settings_yml = """ os: WindowsStore: version: ["666"] arch: [x86] compiler: Visual Studio: runtime: [MD, MT, MTd, MDd] version: ["8", "9", "10", "11", "12", "14", "15"] build_type: [None, Debug, Release] """ settings = Settings.loads(fake_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '666' with self.assertRaises(ConanException): tools.vcvars_command(settings)
def test_arch(self): settings = Settings.loads(default_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' self.assert_vcvars_command(settings, "x86") with environment_append({"PreferredToolArchitecture": "x64"}): self.assert_vcvars_command(settings, "amd64_x86") settings.arch = 'x86_64' self.assert_vcvars_command(settings, "amd64") settings.arch = 'armv7' self.assert_vcvars_command(settings, "amd64_arm") settings.arch = 'armv8' self.assert_vcvars_command(settings, "amd64_arm64") settings.arch = 'mips' with self.assertRaises(ConanException): tools.vcvars_command(settings) settings.arch_build = 'x86_64' settings.arch = 'x86' self.assert_vcvars_command(settings, "amd64_x86")
def test_no_msvc(self): settings = Settings.loads(default_settings_yml) settings.compiler = 'clang' settings.arch = 'x86_64' settings.os = 'Windows' with mock.patch('conans.client.tools.win.latest_vs_version_installed', mock.MagicMock(return_value=None)): with self.assertRaises(ConanException): tools.vcvars_command(settings)
def vcvars_raises_when_not_found_test(self): text = """ os: [Windows] compiler: Visual Studio: version: ["5"] """ settings = Settings.loads(text) settings.os = "Windows" settings.compiler = "Visual Studio" settings.compiler.version = "5" with self.assertRaisesRegexp(ConanException, "VS non-existing installation: Visual Studio 5"): tools.vcvars_command(settings)
def test_arch_override(self): settings = Settings.loads(default_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'mips64' self.assert_vcvars_command(settings, "x86", arch='x86') self.assert_vcvars_command(settings, "amd64", arch='x86_64') self.assert_vcvars_command(settings, "amd64_arm", arch='armv7') self.assert_vcvars_command(settings, "amd64_arm64", arch='armv8') with self.assertRaises(ConanException): tools.vcvars_command(settings, arch='mips')
def vcvars_raises_when_not_found_test(self): text = """ os: [Windows] compiler: Visual Studio: version: ["5"] """ settings = Settings.loads(text) settings.os = "Windows" settings.compiler = "Visual Studio" settings.compiler.version = "5" with self.assertRaisesRegexp(ConanException, "VS non-existing installation: Visual Studio 5"): tools.vcvars_command(settings)
def vcvars_constrained_test(self): text = """os: [Windows] compiler: Visual Studio: version: ["14"] """ settings = Settings.loads(text) settings.os = "Windows" settings.compiler = "Visual Studio" with self.assertRaisesRegexp(ConanException, "compiler.version setting required for vcvars not defined"): tools.vcvars_command(settings) new_out = StringIO() tools.set_global_instances(ConanOutput(new_out), None) settings.compiler.version = "14" with tools.environment_append({"vs140comntools": "path/to/fake"}): tools.vcvars_command(settings) with tools.environment_append({"VisualStudioVersion": "12"}): with self.assertRaisesRegexp(ConanException, "Error, Visual environment already set to 12"): tools.vcvars_command(settings) with tools.environment_append({"VisualStudioVersion": "12"}): # Not raising tools.vcvars_command(settings, force=True)
def vcvars_constrained_test(self): text = """os: [Windows] compiler: Visual Studio: version: ["14"] """ settings = Settings.loads(text) settings.os = "Windows" settings.compiler = "Visual Studio" with self.assertRaisesRegexp( ConanException, "compiler.version setting required for vcvars not defined"): tools.vcvars_command(settings) new_out = StringIO() tools.set_global_instances(ConanOutput(new_out), None) settings.compiler.version = "14" with tools.environment_append({"vs140comntools": "path/to/fake"}): tools.vcvars_command(settings) if platform.system() != "Windows": self.assertIn("VS non-existing installation", new_out.getvalue()) with tools.environment_append({"VisualStudioVersion": "12"}): with self.assertRaisesRegexp( ConanException, "Error, Visual environment already set to 12"): tools.vcvars_command(settings) with tools.environment_append({"VisualStudioVersion": "12"}): # Not raising tools.vcvars_command(settings, force=True)
def test_winsdk_version_override(self): settings = Settings.loads(default_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '15' settings.arch = 'x86_64' command = tools.vcvars_command(settings, winsdk_version='8.1') self.assertIn('vcvarsall.bat', command) self.assertIn('8.1', command) settings.compiler.version = '14' command = tools.vcvars_command(settings, winsdk_version='8.1') self.assertIn('vcvarsall.bat', command) self.assertIn('8.1', command)
def _build_msvc(self, args): build_command = find_executable("jom.exe") if build_command: build_args = ["-j", str(tools.cpu_count())] else: build_command = "nmake.exe" build_args = [] self.output.info("Using '%s %s' to build" % (build_command, " ".join(build_args))) env = {} env.update({'PATH': ['%s/qtbase/bin' % self.source_folder, '%s/gnuwin32/bin' % self.source_folder, '%s/qtrepotools/bin' % self.source_folder]}) env_build = VisualStudioBuildEnvironment(self) env.update(env_build.vars) with tools.environment_append(env): vcvars = tools.vcvars_command(self.settings) args += ["-opengl %s" % self.options.opengl] if self.options.openssl == "no": args += ["-no-openssl"] elif self.options.openssl == "yes": args += ["-openssl"] else: args += ["-openssl-linked"] self.run("cd %s && %s && set" % (self.source_dir, vcvars)) self.run("cd %s && %s && configure %s" % (self.source_dir, vcvars, " ".join(args))) self.run("cd %s && %s && %s %s" % (self.source_dir, vcvars, build_command, " ".join(build_args))) self.run("cd %s && %s && %s install" % (self.source_dir, vcvars, build_command))
def visual_build(self, config_options_string): self.run_in_src("perl --version") self.output.warn( "----------CONFIGURING OPENSSL FOR WINDOWS. %s-------------" % self.version) debug = "debug-" if self.settings.build_type == "Debug" else "" arch = "32" if self.settings.arch == "x86" else "64A" configure_type = debug + "VC-WIN" + arch no_asm = "no-asm" if self.options.no_asm else "" # Will output binaries to ./binaries vcvars = tools.vcvars_command(self.settings) config_command = "%s && perl Configure %s %s --prefix=../binaries" % ( vcvars, configure_type, no_asm) whole_command = "%s %s" % (config_command, config_options_string) self.output.warn(whole_command) self.run_in_src(whole_command) if not self.options.no_asm and self.settings.arch == "x86": # The 64 bits builds do not require the do_nasm # http://p-nand-q.com/programming/windows/building_openssl_with_visual_studio_2013.html self.run_in_src(r"%s && ms\do_nasm" % vcvars) else: if arch == "64A": self.run_in_src(r"%s && ms\do_win64a" % vcvars) else: self.run_in_src(r"%s && ms\do_ms" % vcvars) runtime = self.settings.compiler.runtime # Replace runtime in ntdll.mak and nt.mak def replace_runtime_in_file(filename): runtimes = ["MDd", "MTd", "MD", "MT"] for e in runtimes: try: tools.replace_in_file(filename, "/%s" % e, "/%s" % runtime) self.output.warn("replace vs runtime %s in %s" % ("/%s" % e, filename)) return # we found a runtime argument in the file, so we can exit the function except: pass raise Exception("Could not find any vs runtime in file") replace_runtime_in_file("./openssl-%s/ms/ntdll.mak" % self.version) replace_runtime_in_file("./openssl-%s/ms/nt.mak" % self.version) make_command = "nmake -f ms\\ntdll.mak" if self.options.shared else "nmake -f ms\\nt.mak " self.output.warn("----------MAKE OPENSSL %s-------------" % self.version) self.run_in_src("%s && %s" % (vcvars, make_command)) self.run_in_src("%s && %s install" % (vcvars, make_command)) # Rename libs with the arch renames = { "./binaries/lib/libeay32.lib": "./binaries/lib/libeay32%s.lib" % runtime, "./binaries/lib/ssleay32.lib": "./binaries/lib/ssleay32%s.lib" % runtime } for old, new in renames.items(): if os.path.exists(old): os.rename(old, new)
def _make_install_cmd(self): if is_msvc(self): vcvars = tools.vcvars_command(self.settings) make_install_cmd = vcvars + ' && nmake install' else: make_install_cmd = '{make} install'.format(make=self._make_program) return make_install_cmd
def build(self): arch = "ia32" if self.settings.arch == "x86" else "intel64" if self.settings.compiler == "Visual Studio": vcvars = tools.vcvars_command(self.settings) self.run("%s && cd tbb && mingw32-make arch=%s" % (vcvars, arch)) else: self.run("cd tbb && make arch=%s" % (arch))
def _build_msvc(self): env_build = VisualStudioBuildEnvironment(self) with tools.environment_append(env_build.vars): vcvars = tools.vcvars_command(self.settings) for make_dir, _ in self._msvc_build_dirs: with tools.chdir(make_dir): self.run("%s && nmake /f makefile NEW_COMPILER=1 CPU=%s" % (vcvars, self._msvc_cpu))
def build(self): prepare_env_cmd = vcvars_command(self.settings) cmake = CMake(self.settings) if self.settings.compiler != "Visual Studio": # TODO: Restrict settings raise ConanException("Not valid compiler") generator = { "14": "Visual Studio 14 2015", "12": "Visual Studio 12 2013", "10": "Visual Studio 10 2010" }[str(self.settings.compiler.version)] if self.settings.compiler.version != "14": tools.replace_in_file( "vcpkg/scripts/cmake/vcpkg_configure_cmake.cmake", "Visual Studio 14 2015", generator) # self._build_only_selected_build_type_patch() # Patch recipes for support any visual studio if self.settings.compiler.version != "14": # Boost toolset if self.name == "boost": tools.replace_in_file( "vcpkg/ports/boost/portfile.cmake", "--toolset=msvc", "--toolset=msvc-%s.0" % self.settings.compiler.version) self.run('%s && cmake %s -DPORT=%s -DTARGET_TRIPLET=%s -DCMD=BUILD' % (prepare_env_cmd, cmake.command_line, self.name, self._get_triplet())) self.run("%s && cmake --build . %s" % (prepare_env_cmd, cmake.build_config))
def _make_install_cmd(self): if self.settings.compiler == 'Visual Studio': vcvars = tools.vcvars_command(self.settings) make_install_cmd = vcvars + ' && nmake install' else: make_install_cmd = '{make} install'.format(make=self._make_program) return make_install_cmd
def build(self): if self.options.header_only: self.output.warn("Header only package, skipping build") return flags = self.boostrap() self.patch_project_jam() flags.extend(self.get_build_flags()) # JOIN ALL FLAGS b2_flags = " ".join(flags) command = "b2" if self.settings.os == "Windows" else "./b2" without_python = "--without-python" if not self.options.python else "" full_command = "cd %s && %s %s -j%s --abbreviate-paths %s -d2" % ( self.FOLDER_NAME, command, b2_flags, tools.cpu_count(), without_python ) # -d2 is to print more debug info and avoid travis timing out without output if self.settings.os == "Windows" and self.settings.compiler == "Visual Studio": full_command = "%s && %s" % (tools.vcvars_command( self.settings), full_command) self.output.warn(full_command) self.run(full_command)
def build(self): pybin = "py -2" if self.settings.os == "Windows" else "python" installFolder = self.build_folder + "/install" bitness = "--enable-64bit" if self.settings.arch == "x86_64" else "" debugging = "--enable-debugging" if self.settings.build_type == "Debug" else "" configureStatic = "%s waf configure --libs-only --disable-java --disable-python --prefix=%s %s %s" % ( pybin, installFolder, bitness, debugging) configureShared = "%s waf configure --libs-only --disable-java --disable-python --prefix=%s %s %s --shared" % ( pybin, installFolder, bitness, debugging) buildAll = "%s waf install" % pybin buildNitfC = "%s waf install --target=nitf-c" % pybin if self.settings.os == "Windows" and self.settings.compiler == "Visual Studio": vsenv = VisualStudioBuildEnvironment(self) with tools.environment_append(vsenv.vars): vcvars = tools.vcvars_command(self.settings) self.run("%s && %s" % (vcvars, configureStatic), cwd="nitro") if self.options.shared: self.run("%s && %s" % (vcvars, buildAll), cwd="nitro") self.run("%s && %s" % (vcvars, configureShared), cwd="nitro") self.run("%s && %s" % (vcvars, buildNitfC), cwd="nitro") else: self.run(configureStatic, cwd="nitro") if self.options.shared: self.run(buildAll, cwd="nitro") self.run(configureShared, cwd="nitro") self.run(buildNitfC, cwd="nitro")
def _build_visual(self): crypto_dep = self.deps_cpp_info[str(self.options.crypto_library)] crypto_incdir = crypto_dep.include_paths[0] crypto_libdir = crypto_dep.lib_paths[0] libs = map(lambda lib : lib + ".lib", crypto_dep.libs) system_libs = map(lambda lib : lib + ".lib", crypto_dep.system_libs) nmake_flags = [ "TLIBS=\"%s %s\"" % (" ".join(libs), " ".join(system_libs)), "LTLIBPATHS=/LIBPATH:%s" % crypto_libdir, "OPTS=\"-I%s -DSQLITE_HAS_CODEC\"" % (crypto_incdir), "NO_TCL=1", "USE_AMALGAMATION=1", "OPT_FEATURE_FLAGS=-DSQLCIPHER_CRYPTO_OPENSSL", "SQLITE_TEMP_STORE=%s" % self._temp_store_nmake_value, "TCLSH_CMD=%s" % self.deps_env_info.TCLSH, ] main_target = "dll" if self.options.shared else "sqlcipher.lib" if self.settings.compiler.runtime in ["MD", "MDd"]: nmake_flags.append("USE_CRT_DLL=1") if self.settings.build_type == "Debug": nmake_flags.append("DEBUG=2") nmake_flags.append("FOR_WIN10=1") platforms = {"x86": "x86", "x86_64": "x64"} nmake_flags.append("PLATFORM=%s" % platforms[self.settings.arch.value]) vcvars = tools.vcvars_command(self.settings) self.run("%s && nmake /f Makefile.msc %s %s" % (vcvars, main_target, " ".join(nmake_flags)), cwd=self._source_subfolder)
def build(self): with tools.chdir(self._source_subfolder): self.run( "{python} build.py prepare".format(python=self.options.python)) if tools.os_info.is_macos or tools.os_info.is_linux: if tools.os_info.is_macos: cfg = ("{python} configure.py" + " --deployment-target=10.12" + " -b {prefix}/bin" + " -d {prefix}/lib-dynload" + " -e {prefix}/include" + " -v {prefix}/share/sip") if tools.os_info.is_linux: cfg = ("{python} configure.py" + " -b {prefix}/bin" + " -d {prefix}/site-packages" + " -e {prefix}/include" + " -v {prefix}/share/sip") self.run( cfg.format(prefix=tools.unix_path(self.package_folder), python=self.options.python)) self.run("make -j%d" % tools.cpu_count()) if tools.os_info.is_windows: self.run( ("{python} configure.py" + " -b {prefix}/bin" + " -d {prefix}/site-packages" + " -e {prefix}/include" + " -v {prefix}/share/sip").format( prefix=self.package_folder, python=self.options.python)) # cannot be bothered to fix build of siplib which we don't use anyway vcvarsall_cmd = tools.vcvars_command(self) with tools.chdir("sipgen"): self.run("{vcv} && nmake".format(vcv=vcvarsall_cmd))
def build_windows(self): with tools.chdir(os.path.join('sources', 'win32')): vcvars = tools.vcvars_command(self.settings) compiler = "msvc" if self.settings.compiler == "Visual Studio" else "gcc" debug = "yes" if self.settings.build_type == "Debug" else "no" includes = ";".join(self.deps_cpp_info["libiconv"].include_paths + self.deps_cpp_info["zlib"].include_paths) libs = ";".join(self.deps_cpp_info["libiconv"].lib_paths + self.deps_cpp_info["zlib"].lib_paths) configure_command = "%s && cscript configure.js " \ "zlib=1 compiler=%s cruntime=/%s debug=%s include=\"%s\" lib=\"%s\"" % ( vcvars, compiler, self.settings.compiler.runtime, debug, includes, libs) self.output.warn(configure_command) self.run(configure_command) # Fix library names because they can be not just zlib.lib tools.replace_in_file( "Makefile.msvc", "LIBS = $(LIBS) zlib.lib", "LIBS = $(LIBS) %s.lib" % self.deps_cpp_info['zlib'].libs[0]) tools.replace_in_file( "Makefile.msvc", "LIBS = $(LIBS) iconv.lib", "LIBS = $(LIBS) %s" % self.deps_cpp_info['libiconv'].libs[0]) if self.settings.compiler == "Visual Studio": self.run("%s && nmake /f Makefile.msvc" % (vcvars)) else: self.run("%s && make -f Makefile.mingw" % (vcvars))
def build(self): def add_cflag(value): tools.replace_in_file("Makefile", "CFLAGS = ", "CFLAGS = %s " % value) arch = self.settings.arch if self.settings.os == "Windows": with (tools.vcvars(self.settings)): nmake = tools.which('nmake') if not nmake: raise Exception( "This package needs 'nmake' in Windows in the path to build" ) else: make = tools.get_env("CONAN_MAKE_PROGRAM", tools.which("make") or tools.which('nmake')) if not make: raise Exception( "This package needs 'make' in Linux/Macos in the path to build" ) if self.settings.os == "Windows": if self.options.shared: self.output.warn( "shared option is disabled for Windows. Setting to false") self.options.shared = False with tools.chdir(self._source_subfolder): os.rename("makefile.u", "Makefile") if self.options.fPIC or self.options.shared: add_cflag('-fPIC') if self.settings.os == "Macos": if self.options.shared: # create the dynamic library; undefined dynamic lookup is needed # because the runtime will call Fortran _MAIN__ tools.replace_in_file("Makefile", "libf2c.so: $(OFILES)", "libf2c.dylib: $(OFILES)") tools.replace_in_file( "Makefile", "$(CC) -shared -o libf2c.so $(OFILES)", "$(CC) -dynamiclib -all_load -headerpad_max_install_names -undefined dynamic_lookup -single_module -o libf2c.dylib $(OFILES)" ) self._targets.append("libf2c.dylib") else: self._targets.append("libf2c.a") elif self.settings.os == "Linux": add_cflag('-DNON_UNIX_STDIO') if self.options.shared: self._targets.append("libf2c.so") else: self._targets.append("libf2c.a") if self.settings.os == "Windows": vcvars = tools.vcvars_command(self.settings) build_command = "nmake -f makefile.vc" self.run("%s && %s" % (vcvars, build_command)) else: self.run("%s arch=%s %s" % (make, arch, " ".join(self._targets)))
def build_windows(self): iconv_headers_paths = self.deps_cpp_info["winiconv"].include_paths[0] iconv_lib_paths= " ".join(['lib="%s"' % lib for lib in self.deps_cpp_info["winiconv"].lib_paths]) vc_command = vcvars_command(self.settings) compiler = "msvc" if self.settings.compiler == "Visual Studio" else self.settings.compiler == "gcc" debug = "yes" if self.settings.build_type == "Debug" else "no" configure_command = "%s && cd %s/win32 && cscript configure.js " \ "zlib=1 compiler=%s cruntime=/%s debug=%s include=\"%s\" %s" % (vc_command, self.ZIP_FOLDER_NAME, compiler, self.settings.compiler.runtime, debug, iconv_headers_paths, iconv_lib_paths) self.output.warn(configure_command) self.run(configure_command) makefile_path = os.path.join(self.ZIP_FOLDER_NAME, "win32", "Makefile.msvc") # Zlib library name is not zlib.lib always, it depends on configuration replace_in_file(makefile_path, "LIBS = $(LIBS) zlib.lib", "LIBS = $(LIBS) %s.lib" % self.deps_cpp_info["zlib"].libs[0]) make_command = "nmake /f Makefile.msvc" if self.settings.compiler == "Visual Studio" else "make -f Makefile.mingw" make_command = "%s && cd %s/win32 && %s" % (vc_command, self.ZIP_FOLDER_NAME, make_command) self.output.warn(make_command) self.run(make_command)
def get_make_install_cmd(self): if self.settings.os == 'Windows': vcvars = tools.vcvars_command(self.settings) make_install_cmd = vcvars + ' && nmake install' else: make_install_cmd = 'make install' return make_install_cmd
def windows_build(self): # Follow instructions in https://github.com/jtv/libpqxx/blob/master/win32/INSTALL.txt common_file = os.path.join(self.pq_source_dir, 'win32', 'common') with open(common_file, "w") as f: f.write('PGSQLSRC="{}"\n'.format( self.deps_cpp_info["postgresql"].rootpath)) f.write('PGSQLINC=$(PGSQLSRC)\include\n') f.write('LIBPQINC=$(PGSQLSRC)\include\n') f.write('LIBPQPATH=$(PGSQLSRC)\lib\n') f.write('LIBPQDLL=libpq.dll\n') f.write('LIBPQLIB=libpq.lib\n') f.write('LIBPQDPATH=$(PGSQLSRC)\lib\n') f.write('LIBPQDDLL=libpq.dll\n') f.write('LIBPQDLIB=libpq.lib\n') target_dir = os.path.join(self.pq_source_dir, 'include', 'pqxx') with tools.chdir( os.path.join(self.pq_source_dir, 'config', 'sample-headers', 'compiler', 'VisualStudio2013', 'pqxx')): shutil.copy('config-internal-compiler.h', target_dir + "/") shutil.copy('config-public-compiler.h', target_dir + "/") vcvars = tools.vcvars_command(self.settings) self.run(vcvars) env = VisualStudioBuildEnvironment(self) with tools.environment_append(env.vars): with tools.chdir(self.pq_source_dir): target = "DLL" if self.options.shared else "STATIC" target += str(self.settings.build_type).upper() command = 'nmake /f win32/vc-libpqxx.mak %s' % target self.output.info(command) self.run(command)
def build(self): if self.settings.os == "Windows" and self.version == "master": raise ConanException( "Trunk builds are not supported on Windows (cannot build directly from master git repository)." ) if self.settings.compiler == "Visual Studio": env = VisualStudioBuildEnvironment(self) with tools.environment_append(env.vars): version = min(12, int(self.settings.compiler.version.value)) version = 10 if version == 11 else version cd_build = "cd %s\\%s\\build\\vc%s" % ( self.conanfile_directory, self.source_directory, version) build_command = build_sln_command(self.settings, "glew.sln") vcvars = vcvars_command(self.settings) self.run( "%s && %s && %s" % (vcvars, cd_build, build_command.replace("x86", "Win32"))) else: if self.version == "master": self.run("make extensions") replace_in_file( "%s/build/cmake/CMakeLists.txt" % self.source_directory, "include(GNUInstallDirs)", """ include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake) conan_basic_setup() include(GNUInstallDirs) """) cmake = CMake(self) cmake.configure(source_dir="%s/build/cmake" % self.source_directory, defs={"BUILD_UTILS": "OFF"}) cmake.build()
def build(self): if self.settings.os == "Windows" and self.version == "master": raise ConanException("Trunk builds are not supported on Windows (cannot build directly from master git repository).") if self.settings.compiler == "Visual Studio": env = VisualStudioBuildEnvironment(self) with tools.environment_append(env.vars): version = min(12, int(self.settings.compiler.version.value)) version = 10 if version == 11 else version cd_build = "cd %s\\%s\\build\\vc%s" % (self.conanfile_directory, self.source_directory, version) build_command = build_sln_command(self.settings, "glew.sln") vcvars = vcvars_command(self.settings) self.run("%s && %s && %s" % (vcvars, cd_build, build_command.replace("x86", "Win32"))) else: if self.settings.os == "Windows": replace_in_file("%s/build/cmake/CMakeLists.txt" % self.source_directory, \ "if(WIN32 AND (NOT MSVC_VERSION LESS 1600)", \ "if(WIN32 AND MSVC AND (NOT MSVC_VERSION LESS 1600)") if self.version == "master": self.run("make extensions") cmake = CMake(self) cmake.configure(source_dir="%s/build/cmake" % self.source_directory, defs={"BUILD_UTILS": "OFF"}) cmake.build()
def _build_nmake(self, target="release"): opts = [] # https://core.tcl.tk/tips/doc/trunk/tip/477.md if not self.options.shared: opts.append("static") if self.settings.build_type == "Debug": opts.append("symbols") if "MD" in self.settings.compiler.runtime: opts.append("msvcrt") else: opts.append("nomsvcrt") if "d" not in self.settings.compiler.runtime: opts.append("unchecked") vcvars_command = tools.vcvars_command(self.settings) self.run( '{vcvars} && nmake -nologo -f "{cfgdir}/makefile.vc" shell INSTALLDIR="{pkgdir}" OPTS={opts} {target}' .format( vcvars=vcvars_command, cfgdir=self._get_configure_dir("win"), pkgdir=self.package_folder, opts=",".join(opts), target=target, ), cwd=self._get_configure_dir("win"), )
def build(self): if self.settings.os == "Windows": PATH = "{0};{1}".format(self.env.get("PYTHON_DIR"), os.environ["PATH"]) else: PATH = "{0}:{1}".format(os.path.join(self.env.get("PYTHON_DIR"), "bin"), os.environ["PATH"]) with tools.chdir(self._source_subfolder): with tools.environment_append({"PATH": PATH}): self.run("python --version") self.run("python configure.py --sip-module={module} {static}" "--bindir={bindir} --destdir={destdir} --incdir={incdir} " "--sipdir={sipdir} --pyidir={pyidir}".format( module="PyQt5.sip", static="--static " if not self.options.shared else '', bindir=os.path.join(self.build_folder, "bin"), destdir=os.path.join(self.build_folder, "site-packages"), incdir=os.path.join(self.build_folder, "include"), sipdir=os.path.join(self.build_folder, "sip"), pyidir=os.path.join(self.build_folder, "site-packages", "PyQt5"), ), run_environment=True) if self.settings.os == "Windows": vcvars = tools.vcvars_command(self.settings) self.run("{0} && nmake".format(vcvars)) self.run("{0} && nmake install".format(vcvars)) else: self.run("make", run_environment=True) self.run("make install", run_environment=True)
def build(self): if self.settings.os == "Windows" and self.version == "master": raise ConanException( "Trunk builds are not supported on Windows (cannot build directly from master git repository)." ) if self.settings.compiler == "Visual Studio": env = VisualStudioBuildEnvironment(self) with tools.environment_append(env.vars): version = min(12, int(self.settings.compiler.version.value)) version = 10 if version == 11 else version cd_build = "cd %s\\%s\\build\\vc%s" % ( self.conanfile_directory, self.source_directory, version) build_command = build_sln_command(self.settings, "glew.sln") vcvars = vcvars_command(self.settings) self.run( "%s && %s && %s" % (vcvars, cd_build, build_command.replace("x86", "Win32"))) else: if self.settings.os == "Windows": replace_in_file("%s/build/cmake/CMakeLists.txt" % self.source_directory, \ "if(WIN32 AND (NOT MSVC_VERSION LESS 1600)", \ "if(WIN32 AND MSVC AND (NOT MSVC_VERSION LESS 1600)") if self.version == "master": self.run("make extensions") cmake = CMake(self) cmake.configure(source_dir="%s/build/cmake" % self.source_directory, defs={"BUILD_UTILS": "OFF"}) cmake.build()
def _build_msvc(self): env_build = VisualStudioBuildEnvironment(self) with tools.environment_append(env_build.vars): vcvars = tools.vcvars_command(self.settings) with tools.chdir("CPP/7zip"): self.run("%s && nmake /f makefile PLATFORM=%s" % ( vcvars, self._msvc_platforms[str(self.settings.arch_build)]))
def boostrap(self): with_toolset = { "apple-clang": "darwin" }.get(str(self.settings.compiler), str(self.settings.compiler)) command = "bootstrap" if self.settings.os == "Windows" \ else "./bootstrap.sh --with-toolset=%s" % with_toolset if self.settings.os == "Windows" and self.settings.compiler == "Visual Studio": command = "%s && %s" % (tools.vcvars_command( self.settings), command) flags = [] if self.settings.os == "Windows" and self.settings.compiler == "gcc": command += " mingw" flags.append("--layout=system") try: self.run("cd %s && %s" % (self.FOLDER_NAME, command)) except: self.run("cd %s && type bootstrap.log" % self.FOLDER_NAME if self.settings.os == "Windows" else "cd %s && cat bootstrap.log" % self.FOLDER_NAME) raise return flags
def vcvars_constrained_test(self): if platform.system() != "Windows": return text = """os: [Windows] compiler: Visual Studio: version: ["14"] """ settings = Settings.loads(text) settings.os = "Windows" settings.compiler = "Visual Studio" with self.assertRaisesRegexp(ConanException, "compiler.version setting required for vcvars not defined"): tools.vcvars_command(settings) settings.compiler.version = "14" cmd = tools.vcvars_command(settings) self.assertIn("vcvarsall.bat", cmd) with tools.environment_append({"VisualStudioVersion": "12"}): with self.assertRaisesRegexp(ConanException, "Error, Visual environment already set to 12"): tools.vcvars_command(settings)
def vcvars_echo_test(self): if platform.system() != "Windows": return settings = Settings.loads(default_settings_yml) settings.os = "Windows" settings.compiler = "Visual Studio" settings.compiler.version = "14" cmd = tools.vcvars_command(settings) output = TestBufferConanOutput() runner = TestRunner(output) runner(cmd + " && set vs140comntools") self.assertIn("vcvarsall.bat", str(output)) self.assertIn("VS140COMNTOOLS=", str(output)) with tools.environment_append({"VisualStudioVersion": "14"}): output = TestBufferConanOutput() runner = TestRunner(output) cmd = tools.vcvars_command(settings) runner(cmd + " && set vs140comntools") self.assertNotIn("vcvarsall.bat", str(output)) self.assertIn("Conan:vcvars already set", str(output)) self.assertIn("VS140COMNTOOLS=", str(output))
def test_arch_override(self): if platform.system() != "Windows": return settings = Settings.loads(default_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'mips64' command = tools.vcvars_command(settings, arch='x86') self.assertIn('vcvarsall.bat', command) self.assertIn('x86', command) command = tools.vcvars_command(settings, arch='x86_64') self.assertIn('vcvarsall.bat', command) self.assertIn('amd64', command) command = tools.vcvars_command(settings, arch='armv7') self.assertIn('vcvarsall.bat', command) self.assertNotIn('arm64', command) self.assertIn('arm', command) command = tools.vcvars_command(settings, arch='armv8') self.assertIn('vcvarsall.bat', command) self.assertIn('arm64', command) with self.assertRaises(ConanException): tools.vcvars_command(settings, arch='mips')
def _build_msvc(self, args): build_command = find_executable("jom.exe") if build_command: build_args = ["-j", str(cpu_count())] else: build_command = "nmake.exe" build_args = [] self.output.info("Using '%s %s' to build" % (build_command, " ".join(build_args))) env = {} env.update({'PATH': ['%s/qtbase/bin' % self.conanfile_directory, '%s/gnuwin32/bin' % self.conanfile_directory, '%s/qtrepotools/bin' % self.conanfile_directory]}) # it seems not enough to set the vcvars for older versions if self.settings.compiler == "Visual Studio": if self.settings.compiler.version == "14": env.update({'QMAKESPEC': 'win32-msvc2015'}) args += ["-platform win32-msvc2015"] if self.settings.compiler.version == "12": env.update({'QMAKESPEC': 'win32-msvc2013'}) args += ["-platform win32-msvc2013"] if self.settings.compiler.version == "11": env.update({'QMAKESPEC': 'win32-msvc2012'}) args += ["-platform win32-msvc2012"] if self.settings.compiler.version == "10": env.update({'QMAKESPEC': 'win32-msvc2010'}) args += ["-platform win32-msvc2010"] env_build = VisualStudioBuildEnvironment(self) env.update(env_build.vars) # Workaround for conan-io/conan#1408 for name, value in env.items(): if not value: del env[name] with tools.environment_append(env): vcvars = tools.vcvars_command(self.settings) args += ["-opengl %s" % self.options.opengl] if self.options.openssl == "no": args += ["-no-openssl"] elif self.options.openssl == "yes": args += ["-openssl"] else: args += ["-openssl-linked"] self.run("cd %s && %s && set" % (self.source_dir, vcvars)) self.run("cd %s && %s && configure %s" % (self.source_dir, vcvars, " ".join(args))) self.run("cd %s && %s && %s %s" % (self.source_dir, vcvars, build_command, " ".join(build_args))) self.run("cd %s && %s && %s install" % (self.source_dir, vcvars, build_command))
def test_81(self): if platform.system() != "Windows": return settings = Settings.loads(default_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '8.1' command = tools.vcvars_command(settings) self.assertIn('vcvarsall.bat', command) self.assertIn('x86', command) self.assertIn('store', command) self.assertIn('8.1', command)
def test_10(self): if platform.system() != "Windows": return sdk_version = tools.find_windows_10_sdk() if not sdk_version: return settings = Settings.loads(default_settings_yml) settings.compiler = 'Visual Studio' settings.compiler.version = '14' settings.arch = 'x86' settings.os = 'WindowsStore' settings.os.version = '10.0' command = tools.vcvars_command(settings) self.assertIn('vcvarsall.bat', command) self.assertIn('x86', command) self.assertIn('store', command) self.assertIn(sdk_version, command)
def build(self): if self.settings.os == "Linux" or self.settings.os == "Macos": autotools = AutoToolsBuildEnvironment(self) env_vars = autotools.vars.copy() # required to correctly find static libssl on Linux if self.options.with_openssl and self.settings.os == "Linux": env_vars['OPENSSL_LIBADD'] = '-ldl' # disable rpath build tools.replace_in_file(os.path.join(self._source_subfolder, "configure"), r"-install_name \$rpath/", "-install_name ") # compose configure options configure_args = [] if not self.options.shared: configure_args.append("--disable-shared") configure_args.append("--enable-openssl" if self.options.with_openssl else "--disable-openssl") if self.options.disable_threads: configure_args.append("--disable-thread-support") with tools.environment_append(env_vars): with tools.chdir(self._source_subfolder): # set LD_LIBRARY_PATH with tools.environment_append(RunEnvironment(self).vars): autotools.configure(args=configure_args) autotools.make() elif self.settings.os == "Windows": vcvars = tools.vcvars_command(self.settings) suffix = '' if self.options.with_openssl: suffix = "OPENSSL_DIR=" + self.deps_cpp_info['OpenSSL'].rootpath # add runtime directives to runtime-unaware nmakefile tools.replace_in_file(os.path.join(self._source_subfolder, "Makefile.nmake"), 'LIBFLAGS=/nologo', 'LIBFLAGS=/nologo\n' 'CFLAGS=$(CFLAGS) /%s' % str(self.settings.compiler.runtime)) # do not build tests. static_libs is the only target, no shared libs at all make_command = "nmake %s -f Makefile.nmake static_libs" % suffix with tools.chdir(self._source_subfolder): self.run("%s && %s" % (vcvars, make_command))
def command_line_env(self): if self.os == "Linux" or self.os == "Macos" or self.os == "FreeBSD" or self.os == "SunOS": if self.compiler == "gcc" or "clang" in str(self.compiler) or "sun-cc" in str(self.compiler): return self._gcc_env() elif self.os == "Windows": commands = [] commands.append("@echo off") vcvars = "" if self.compiler == "Visual Studio": cl_args = " ".join(['/I"%s"' % lib for lib in self._deps_cpp_info.include_paths]) lib_paths = ";".join(['%s' % lib for lib in self._deps_cpp_info.lib_paths]) commands.append('if defined LIB (SET "LIB=%LIB%;{0}") else (SET "LIB={0}")'. format(lib_paths)) commands.append('if defined CL (SET "CL=%CL% {0}") else (SET "CL={0}")'. format(cl_args)) vcvars = tools.vcvars_command(self._settings) if vcvars: vcvars += " && " elif self.compiler == "gcc": include_paths = ";".join(['%s' % lib for lib in self._deps_cpp_info.include_paths]) commands.append('if defined C_INCLUDE_PATH (SET "C_INCLUDE_PATH=%C_INCLUDE_PATH%;{0}")' ' else (SET "C_INCLUDE_PATH={0}")'.format(include_paths)) commands.append('if defined CPLUS_INCLUDE_PATH ' '(SET "CPLUS_INCLUDE_PATH=%CPLUS_INCLUDE_PATH%;{0}")' ' else (SET "CPLUS_INCLUDE_PATH={0}")'.format(include_paths)) lib_paths = ";".join([lib for lib in self._deps_cpp_info.lib_paths]) commands.append('if defined LIBRARY_PATH (SET "LIBRARY_PATH=%LIBRARY_PATH%;{0}")' ' else (SET "LIBRARY_PATH={0}")'.format(lib_paths)) commands.extend(get_setenv_variables_commands(self._deps_env_info, "SET")) save("_conan_env.bat", "\r\n".join(commands)) command = "%scall _conan_env.bat" % vcvars return command return " && ".join(get_setenv_variables_commands(self._deps_env_info))
def _append_vs_if_needed(self, command): if self._compiler == "Visual Studio" and self.backend == "ninja": command = "%s && %s" % (tools.vcvars_command(self._conanfile.settings), command) return command