def test_vs_generator(self): settings = MockSettings({ "os": "Windows", "arch": "x86_64", "compiler": "Visual Studio" }) conanfile = ConanFileMock() conanfile.settings = settings settings.values['compiler.version'] = '15' assert get_generator(conanfile) == 'Visual Studio 15 2017' settings.values['compiler.version'] = '15.9' assert get_generator(conanfile) == 'Visual Studio 15 2017'
def __init__(self, conanfile, generator=None, cmake_system_name=True, parallel=True, build_type=None, toolset=None, make_program=None, set_cmake_flags=False, msbuild_verbosity=None, cmake_program=None): """ :param conanfile: Conanfile instance :param generator: Generator name to use or none to autodetect :param cmake_system_name: False to not use CMAKE_SYSTEM_NAME variable, True for auto-detect or directly a string with the system name :param parallel: Try to build with multiple cores if available :param build_type: Overrides default build type coming from settings :param toolset: Toolset name to use (such as llvm-vs2014) or none for default one, applies only to certain generators (e.g. Visual Studio) :param set_cmake_flags: whether or not to set CMake flags like CMAKE_CXX_FLAGS, CMAKE_C_FLAGS, etc. it's vital to set for certain projects (e.g. using CMAKE_SIZEOF_VOID_P or CMAKE_LIBRARY_ARCHITECTURE) :param msbuild_verbosity: verbosity level for MSBuild (in case of Visual Studio generator) :param cmake_program: Path to the custom cmake executable """ if not isinstance(conanfile, ConanFile): raise ConanException( "First argument of CMake() has to be ConanFile. Use CMake(self)" ) self._conanfile = conanfile self._settings = conanfile.settings self._build_type = build_type or conanfile.settings.get_safe( "build_type") self._cmake_program = os.getenv( "CONAN_CMAKE_PROGRAM") or cmake_program or "cmake" self.generator = generator or get_generator(conanfile.settings) if not self.generator: self._conanfile.output.warn( "CMake generator could not be deduced from settings") self.parallel = parallel # Initialize definitions (won't be updated if conanfile or any of these variables change) builder = CMakeDefinitionsBuilder(self._conanfile, cmake_system_name=cmake_system_name, make_program=make_program, parallel=parallel, generator=self.generator, set_cmake_flags=set_cmake_flags, forced_build_type=build_type, output=self._conanfile.output) # FIXME CONAN 2.0: CMake() interface should be always the constructor and self.definitions. # FIXME CONAN 2.0: Avoid properties and attributes to make the user interface more clear self.definitions = builder.get_definitions() self.toolset = toolset or get_toolset(self._settings) self.build_dir = None self.msbuild_verbosity = (os.getenv("CONAN_MSBUILD_VERBOSITY") or msbuild_verbosity or "minimal")
def _get_cmake_definitions(self): """ Detect all definitions conan sends to cmake by command line and convert them to cmake commands. Removes the CONAN_EXPORTED definition, so that users may check if conan has been invoked or not. :return: List of lines to print into a cmake file """ with get_env_context_manager(self.conanfile): ret = ["\t\t\"cmakeSettings\": {"] generator = get_generator(self.conanfile.settings) self.conanfile.install_folder = "" def_builder = CMakeDefinitionsBuilder(self.conanfile, generator=generator) definitions = def_builder.get_definitions(None) for name, value in definitions.items(): ret.append("\t\t\t\"{name}\": \"{value}\",".format( name=name, value=value)) deps = [] for _, dep_cpp_info in self.deps_build_info.dependencies: deps.append("\t\t\t\t\t" + DepsCppCmake(dep_cpp_info).rootpath) deps[:-1] = [line + "," for line in deps[:-1]] ret.append("\t\t\t\"CMAKE_PREFIX_PATH\": [") ret.extend(deps) ret.append("\t\t\t],") ret.append("\t\t\t\"CMAKE_MODULE_PATH\": [") ret.extend(deps) ret.append("\t\t\t]") return ret
def __init__(self, conanfile, generator=None, generator_platform=None, build_type=None, toolset=None, parallel=True): self._conanfile = conanfile self.fpic = self._deduce_fpic() self.vs_static_runtime = self._deduce_vs_static_runtime() self.parallel = parallel # To find the generated cmake_find_package finders self.cmake_prefix_path = "${CMAKE_BINARY_DIR}" self.cmake_module_path = "${CMAKE_BINARY_DIR}" self.generator = generator or get_generator(self._conanfile) self.generator_platform = (generator_platform or get_generator_platform( self._conanfile.settings, self.generator)) self.toolset = toolset or get_toolset(self._conanfile.settings, self.generator) self.variables = Variables() self.preprocessor_definitions = Variables() try: self._build_shared_libs = "ON" if self._conanfile.options.shared else "OFF" except ConanException: self._build_shared_libs = None self.set_libcxx, self.glibcxx = self._get_libcxx() self.parallel = None if parallel: if self.generator and "Visual Studio" in self.generator: self.parallel = "/MP%s" % cpu_count( output=self._conanfile.output) self.cppstd, self.cppstd_extensions = self._cppstd() self.skip_rpath = True if self._conanfile.settings.get_safe( "os") == "Macos" else False self.architecture = self._get_architecture() # TODO: I would want to have here the path to the compiler too build_type = build_type or self._conanfile.settings.get_safe( "build_type") self.build_type = build_type if not is_multi_configuration( self.generator) else None try: # This is only defined in the cache, not in the local flow self.install_prefix = self._conanfile.package_folder.replace( "\\", "/") except AttributeError: # FIXME: In the local flow, we don't know the package_folder self.install_prefix = None
def __init__( self, conanfile, generator=None, generator_platform=None, build_type=None, cmake_system_name=True, toolset=None, parallel=True, make_program=None, # cmake_program=None, # TODO: cmake program should be considered in the environment ): self._conanfile = conanfile self._fpic = self._deduce_fpic() self._vs_static_runtime = self._deduce_vs_static_runtime() self._set_rpath = True self._set_std = True self._set_libcxx = True # To find the generated cmake_find_package finders self._cmake_prefix_path = "${CMAKE_BINARY_DIR}" self._cmake_module_path = "${CMAKE_BINARY_DIR}" self._generator = generator or get_generator(self._conanfile) self._generator_platform = (generator_platform or get_generator_platform( self._conanfile.settings, self._generator)) self._toolset = toolset or get_toolset(self._conanfile.settings, self._generator) self._build_type = build_type or self._conanfile.settings.get_safe( "build_type") builder = CMakeDefinitionsBuilder(self._conanfile, cmake_system_name=cmake_system_name, make_program=make_program, parallel=parallel, generator=self._generator, set_cmake_flags=False, output=self._conanfile.output) self.definitions = Definitions() self.definitions.update(builder.get_definitions()) # FIXME: Removing too many things. We want to bring the new logic for the toolchain here # so we don't mess with the common code. self.definitions.pop("CMAKE_BUILD_TYPE", None) self.definitions.pop("CONAN_IN_LOCAL_CACHE", None) self.definitions.pop("CMAKE_PREFIX_PATH", None) self.definitions.pop("CMAKE_MODULE_PATH", None) self.definitions.pop("CONAN_LINK_RUNTIME", None) for install in ("PREFIX", "BINDIR", "SBINDIR", "LIBEXECDIR", "LIBDIR", "INCLUDEDIR", "OLDINCLUDEDIR", "DATAROOTDIR"): self.definitions.pop("CMAKE_INSTALL_%s" % install, None)
def test_vs_generator(compiler, version, expected): settings = MockSettings({ "os": "Windows", "arch": "x86_64", "compiler": compiler }) conanfile = ConanFileMock() conanfile.settings = settings settings.values['compiler.version'] = version assert get_generator(conanfile) == expected
def __init__(self, conanfile, generator=None, cmake_system_name=True, parallel=True, build_type=None, toolset=None, make_program=None, set_cmake_flags=False): """ :param settings_or_conanfile: Conanfile instance (or settings for retro compatibility) :param generator: Generator name to use or none to autodetect :param cmake_system_name: False to not use CMAKE_SYSTEM_NAME variable, True for auto-detect or directly a string with the system name :param parallel: Try to build with multiple cores if available :param build_type: Overrides default build type comming from settings :param toolset: Toolset name to use (such as llvm-vs2014) or none for default one, applies only to certain generators (e.g. Visual Studio) :param set_cmake_flags: whether or not to set CMake flags like CMAKE_CXX_FLAGS, CMAKE_C_FLAGS, etc. it's vital to set for certain projects (e.g. using CMAKE_SIZEOF_VOID_P or CMAKE_LIBRARY_ARCHITECTURE) """ if not isinstance(conanfile, ConanFile): raise ConanException( "First argument of CMake() has to be ConanFile. Use CMake(self)" ) self._settings = conanfile.settings self._conanfile = conanfile self.generator = generator or get_generator(self._settings) self.toolset = toolset or get_toolset(self._settings) self.build_dir = None self.parallel = parallel self._set_cmake_flags = set_cmake_flags self._cmake_system_name = cmake_system_name self._make_program = make_program # Initialize definitions (won't be updated if conanfile or any of these variables change) builder = CMakeDefinitionsBuilder( self._conanfile, cmake_system_name=self._cmake_system_name, make_program=self._make_program, parallel=self.parallel, generator=self.generator, set_cmake_flags=self._set_cmake_flags) self.definitions = builder.get_definitions() if build_type is None: self.build_type = self._settings.get_safe("build_type") else: self.build_type = build_type
def __init__(self, conanfile, generator=None, generator_platform=None, build_type=None, toolset=None, parallel=True): super(CMakeGenericToolchain, self).__init__(conanfile) self.fpic = self._deduce_fpic() self.vs_static_runtime = self._deduce_vs_static_runtime() self.parallel = parallel self.generator = generator or get_generator(self._conanfile) self.generator_platform = (generator_platform or get_generator_platform( self._conanfile.settings, self.generator)) self.toolset = toolset or get_toolset(self._conanfile.settings, self.generator) if (self.generator is not None and "Ninja" in self.generator and "Visual" in self._conanfile.settings.compiler): self.compiler = "cl" else: self.compiler = None # compiler defined by default try: self._build_shared_libs = "ON" if self._conanfile.options.shared else "OFF" except ConanException: self._build_shared_libs = None self.set_libcxx, self.glibcxx = self._get_libcxx() self.parallel = None if parallel: if self.generator and "Visual Studio" in self.generator: self.parallel = "/MP%s" % cpu_count( output=self._conanfile.output) self.cppstd, self.cppstd_extensions = self._cppstd() self.skip_rpath = True if self._conanfile.settings.get_safe( "os") == "Macos" else False self.architecture = self._get_architecture() # TODO: I would want to have here the path to the compiler too build_type = build_type or self._conanfile.settings.get_safe( "build_type") self.build_type = build_type if not is_multi_configuration( self.generator) else None
def __init__(self, conanfile, generator=None, build_folder=None, parallel=True, msbuild_verbosity="minimal"): _validate_recipe(conanfile) # assert generator is None, "'generator' is handled by the toolchain" self._generator = generator or get_generator(conanfile) self._is_multiconfiguration = is_multi_configuration(self._generator) # Store a reference to useful data self._conanfile = conanfile self._parallel = parallel self._msbuild_verbosity = msbuild_verbosity self._build_folder = build_folder self._cmake_program = "cmake" # Path to CMake should be handled by environment
def _get_cmake_definitions(self): """ Detect all definitions conan sends to cmake by command line and convert them to cmake commands. Removes the CONAN_EXPORTED definition, so that users may check if conan has been invoked or not. :return: string to print into a cmake file """ with get_env_context_manager(self.conanfile): ret = [] build_type = self.conanfile.settings.get_safe("build_type") generator = get_generator(self.conanfile.settings) def_builder = CMakeDefinitionsBuilder(self.conanfile, generator=generator, forced_build_type=build_type) cmake_version = self.get_version() definitions = def_builder.get_definitions(cmake_version) if "CONAN_EXPORTED" in definitions: del definitions["CONAN_EXPORTED"] for name, value in definitions.items(): value = _cmake_escape_backslash(value) ret.append("set({name} {value})".format(name=name, value=value)) return os.linesep.join(ret)
def __init__(self, conanfile, generator=None, cmake_system_name=True, parallel=True, build_type=None, toolset=None, make_program=None, set_cmake_flags=False, msbuild_verbosity="minimal", cmake_program=None, generator_platform=None, append_vcvars=False): """ :param conanfile: Conanfile instance :param generator: Generator name to use or none to autodetect :param cmake_system_name: False to not use CMAKE_SYSTEM_NAME variable, True for auto-detect or directly a string with the system name :param parallel: Try to build with multiple cores if available :param build_type: Overrides default build type coming from settings :param toolset: Toolset name to use (such as llvm-vs2014) or none for default one, applies only to certain generators (e.g. Visual Studio) :param set_cmake_flags: whether or not to set CMake flags like CMAKE_CXX_FLAGS, CMAKE_C_FLAGS, etc. it's vital to set for certain projects (e.g. using CMAKE_SIZEOF_VOID_P or CMAKE_LIBRARY_ARCHITECTURE) :param msbuild_verbosity: verbosity level for MSBuild (in case of Visual Studio generator) :param cmake_program: Path to the custom cmake executable :param generator_platform: Generator platform name or none to autodetect (-A cmake option) """ self._append_vcvars = append_vcvars self._conanfile = conanfile self._settings = conanfile.settings self._build_type = build_type or conanfile.settings.get_safe( "build_type") self._cmake_program = os.getenv( "CONAN_CMAKE_PROGRAM") or cmake_program or "cmake" self.generator_platform = generator_platform self.generator = generator or get_generator(conanfile) if not self.generator: self._conanfile.output.warn( "CMake generator could not be deduced from settings") self.parallel = parallel # Initialize definitions (won't be updated if conanfile or any of these variables change) builder = CMakeDefinitionsBuilder(self._conanfile, cmake_system_name=cmake_system_name, make_program=make_program, parallel=parallel, generator=self.generator, set_cmake_flags=set_cmake_flags, forced_build_type=build_type, output=self._conanfile.output) # FIXME CONAN 2.0: CMake() interface should be always the constructor and self.definitions. # FIXME CONAN 2.0: Avoid properties and attributes to make the user interface more clear try: cmake_version = self.get_version() self.definitions = builder.get_definitions(cmake_version) except ConanException: self.definitions = builder.get_definitions(None) self.definitions["CONAN_EXPORTED"] = "1" if hasattr(self._conanfile, 'settings_build'): # https://github.com/conan-io/conan/issues/9202 if self._conanfile.settings_build.get_safe("os") == "Macos" and \ self._conanfile.settings.get_safe("os") == "iOS": self.definitions["CMAKE_FIND_ROOT_PATH_MODE_INCLUDE"] = "BOTH" self.definitions["CMAKE_FIND_ROOT_PATH_MODE_LIBRARY"] = "BOTH" self.definitions["CMAKE_FIND_ROOT_PATH_MODE_PACKAGE"] = "BOTH" self.toolset = toolset or get_toolset(self._settings, self.generator) self.build_dir = None self.msbuild_verbosity = os.getenv( "CONAN_MSBUILD_VERBOSITY") or msbuild_verbosity
def test_cmake_default_generator_linux(self): settings = MockSettings({"os_build": "Linux"}) generator = get_generator(settings) self.assertEquals("Unix Makefiles", generator) self._test_default_generator_cmake(settings, "Unix Makefiles")
def test_default_generator_windows(self): settings = MockSettings({"os_build": "Windows"}) generator = get_generator(settings) self.assertEquals("MinGW Makefiles", generator) self._test_default_generator_cmake(settings, "MinGW Makefiles")