- .cmake_doc_artifacts

- .run_only_for_package

extends:

- .rsync_upload

- .run_only_for_package

needs:

- prep:doc-package

extends:

- .rsync_upload

- .run_only_for_package

needs:

- prep:doc-package

extends:

- .rsync_upload

- .run_only_for_package

needs:

- prep:doc-package

extends:

- .rsync_upload

- .run_only_for_package

needs:

- prep:doc-package

extends:

- .rsync_upload

- .run_only_for_package

set(CMake_TEST_WIX_NO_VERIFY "ON" CACHE BOOL "")

set(CMake_TEST_GUI "ON" CACHE BOOL "")

include("${CMAKE_CURRENT_LIST_DIR}/configure_windows_common.cmake")

"^ExternalProjectUpdateSetup$")

endif ()

string(REPLACE ";" "|" test_exclusions "${test_exclusions}")

if (test_exclusions)

set(test_exclusions "(${test_exclusions})")

if(SPHINX_QTHELP)

list(APPEND _CPACK_IFW_COMPONENTS_ALL sphinx-qthelp)

endif()

if(CMake_BUILD_DEVELOPER_REFERENCE)

if(CMake_BUILD_DEVELOPER_REFERENCE_HTML)

list(APPEND _CPACK_IFW_COMPONENTS_ALL cmake-developer-reference-html)

# Distributed under the OSI-approved BSD 3-Clause License. See accompanying

# file Copyright.txt or https://cmake.org/licensing for details.

set(CMAKE_USER_MAKE_RULES_OVERRIDE_C ${CMAKE_CURRENT_SOURCE_DIR}/Source/Modules/OverrideC.cmake)

set(CMAKE_USER_MAKE_RULES_OVERRIDE_CXX ${CMAKE_CURRENT_SOURCE_DIR}/Source/Modules/OverrideCXX.cmake)

project(CMake)

|FIND_XXX| (

<VAR>

name | |NAMES|

[PATH_SUFFIXES suffix1 [suffix2 ...]]

[DOC "cache documentation string"]

[REQUIRED]

`Filesystem`_

file({`GLOB`_ | `GLOB_RECURSE`_} <out-var> [...] [<globbing-expr>...])

file({`REMOVE`_ | `REMOVE_RECURSE`_ } [<files>...])

file(`MAKE_DIRECTORY`_ [<dir>...])

file({`COPY`_ | `INSTALL`_} <file>... DESTINATION <dir> [...])

.. code-block:: cmake

Move a file or directory within a filesystem from ``<oldname>`` to

``<newname>``, replacing the destination atomically.

.. _REMOVE:

.. _REMOVE_RECURSE:

- Default: ``CPACK_PACKAGE_FILE_NAME-<component>``

.. variable:: CPACK_COMMAND_HDIUTIL

Path to the ``hdiutil(1)`` command used to operate on disk image files on

.. versionadded:: 3.20

If set, trim down the size of the control to the size of the branding text string.

native build system to choose a compiler or SDK. See the

:variable:`CMAKE_GENERATOR_PLATFORM` variable for details.

``-Wno-dev``

Suppress developer warnings.

PATHS ${PC_Foo_LIBRARY_DIRS}

)

If you have a good way of getting the version (from a header file, for

example), you can use that information to set ``Foo_VERSION`` (although

note that find modules have traditionally used ``Foo_VERSION_STRING``,

:ref:`Target Usage Requirements` this is the consuming target rather

than the target specifying the requirement.

.. genex:: $<INSTALL_PREFIX>

Content of the install prefix when the target is exported via

to determine whether to report an error on use of deprecated macros or

functions.

Policies Introduced by CMake 3.20

=================================

specified, it must be inherited from the ``inherits`` preset (unless this

preset is ``hidden``).

``cmakeExecutable``

An optional string representing the path to the CMake executable to use

},

"cmakeMinimumRequired": { "$ref": "#/definitions/cmakeMinimumRequired"},

"vendor": { "$ref": "#/definitions/vendor" },

},

"additionalProperties": false

},

"properties": {

"version": {

"const": 2,

"description": "A required integer representing the version of the JSON schema."

},

"cmakeMinimumRequired": { "$ref": "#/definitions/cmakeMinimumRequired"},

"vendor": { "$ref": "#/definitions/vendor" },

"buildPresets": { "$ref": "#/definitions/buildPresets"},

"testPresets": { "$ref": "#/definitions/testPresets"}

},

"description": "An optional map containing vendor-specific information. CMake does not interpret the contents of this field except to verify that it is a map if it does exist. However, the keys should be a vendor-specific domain name followed by a /-separated path. For example, the Example IDE 1.0 could use example.com/ExampleIDE/1.0. The value of each field can be anything desired by the vendor, though will typically be a map.",

"properties": {}

},

"type": "array",

"description": "An optional array of configure preset objects.",

"items": {

},

"additionalProperties": false

}

},

"required": [

"name"

``c_std_11``

Compiler mode is at least C 11.

``c_function_prototypes``

Function prototypes, as defined in ``ISO/IEC 9899:1990``.

have no notion of a C standard level, such as Microsoft Visual C++ before

VS 16.7, this property has no effect.

If the value requested does not result in a compile flag being added for

the compiler in use, a previous standard flag will be added instead. This

This file should include the adjacent "dev.txt" file

in development versions but not in release versions.

Releases

========

set(CMAKE_ASM_NASM_COMPILE_OBJECT "<CMAKE_ASM_NASM_COMPILER> <INCLUDES> <FLAGS> -f ${CMAKE_ASM_NASM_OBJECT_FORMAT} -o <OBJECT> <SOURCE>")

endif()

# Load the generic ASMInformation file:

set(ASM_DIALECT "_NASM")

include(CMakeASMInformation)

set(CMAKE_C90_COMPILE_FEATURES "@CMAKE_C90_COMPILE_FEATURES@")

set(CMAKE_C99_COMPILE_FEATURES "@CMAKE_C99_COMPILE_FEATURES@")

set(CMAKE_C11_COMPILE_FEATURES "@CMAKE_C11_COMPILE_FEATURES@")

set(CMAKE_C_PLATFORM_ID "@CMAKE_C_PLATFORM_ID@")

set(CMAKE_C_SIMULATE_ID "@CMAKE_C_SIMULATE_ID@")

@CMAKE_C_COMPILER_ID_PLATFORM_CONTENT@

@CMAKE_C_COMPILER_ID_ERROR_FOR_TEST@

# define C_DIALECT "90"

# else

# define C_DIALECT

# endif

#elif __STDC_VERSION__ >= 201000L

# define C_DIALECT "11"

#elif __STDC_VERSION__ >= 199901L

set(CMAKE_INCLUDE_FLAG_CUDA "-I")

# Set implicit links early so compiler-specific modules can use them.

foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})

endforeach()

foreach(lib ${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES})

if(${lib} MATCHES "/")

else()

endif()

endforeach()

# create a shared library

if(NOT CMAKE_CUDA_CREATE_SHARED_LIBRARY)

set(CMAKE_CUDA_CREATE_SHARED_LIBRARY

endif()

# create a shared module copy the shared library rule by default

# compile a cu file into an executable

if(NOT CMAKE_CUDA_LINK_EXECUTABLE)

set(CMAKE_CUDA_LINK_EXECUTABLE

endif()

# Add implicit host link directories that contain device libraries

# to the device link line.

endif()

if(EXISTS "${dir}/libcurand_static.a")

endif()

endforeach()

#These are used when linking relocatable (dc) cuda code

if(NOT CMAKE_CUDA_DEVICE_LINK_LIBRARY)

set(CMAKE_CUDA_DEVICE_LINK_LIBRARY

endif()

if(NOT CMAKE_CUDA_DEVICE_LINK_EXECUTABLE)

set(CMAKE_CUDA_DEVICE_LINK_EXECUTABLE

endif()

# Used when device linking is handled by CMake.

set(CMAKE_CUDA_DEVICE_LINK_COMPILE "<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <FLAGS> -D__CUDA_INCLUDE_COMPILER_INTERNAL_HEADERS__ -D__NV_EXTRA_INITIALIZATION=\"\" -D__NV_EXTRA_FINALIZATION=\"\" -DREGISTERLINKBINARYFILE=\\\"<REGISTER_FILE>\\\" -DFATBINFILE=\\\"<FATBINARY>\\\" ${_CMAKE_COMPILE_AS_CUDA_FLAG} -c \"${CMAKE_CUDA_COMPILER_TOOLKIT_LIBRARY_ROOT}/bin/crt/link.stub\" -o <OBJECT>")

endif()

set(CMAKE_CUDA_INFORMATION_LOADED 1)

set(CMAKE_C90_COMPILE_FEATURES)

set(CMAKE_C99_COMPILE_FEATURES)

set(CMAKE_C11_COMPILE_FEATURES)

include("${CMAKE_ROOT}/Modules/Internal/FeatureTesting.cmake")

return()

endif()

if (CMAKE_C99_COMPILE_FEATURES AND CMAKE_C11_COMPILE_FEATURES)

list(REMOVE_ITEM CMAKE_C11_COMPILE_FEATURES ${CMAKE_C99_COMPILE_FEATURES})

endif()

${CMAKE_C90_COMPILE_FEATURES}

${CMAKE_C99_COMPILE_FEATURES}

${CMAKE_C11_COMPILE_FEATURES}

)

endif()

set(CMAKE_C90_COMPILE_FEATURES ${CMAKE_C90_COMPILE_FEATURES} PARENT_SCOPE)

set(CMAKE_C99_COMPILE_FEATURES ${CMAKE_C99_COMPILE_FEATURES} PARENT_SCOPE)

set(CMAKE_C11_COMPILE_FEATURES ${CMAKE_C11_COMPILE_FEATURES} PARENT_SCOPE)

message(CHECK_PASS "done")

if(CPP_CACHE_ENTRIES)

set(items ${CPP_CACHE_ENTRIES})

set(mode ${mode} CACHE_ENTRIES)

endif()

if(NOT mode)

# Define to allow compile features to be automatically determined

macro(cmake_record_c_compile_features)

set(_result 0)

if(_result EQUAL 0 AND DEFINED CMAKE_C11_STANDARD_COMPILE_OPTION)

if(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT)

_has_compiler_features_c(11)

endif()

endif()

set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")

set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")

set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")

set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")

set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")

set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")

set(CMAKE_C11_STANDARD_COMPILE_OPTION "")

set(CMAKE_C11_EXTENSION_COMPILE_OPTION "")

endif()

endif()

endif()

set(_CMAKE_CUDA_DEVICE_CODE "-fgpu-rdc -c")

# RulePlaceholderExpander expands crosscompile variables like sysroot and target only for CMAKE_<LANG>_COMPILER. Override the default.

set(CMAKE_CUDA_RUNTIME_LIBRARY_DEFAULT "STATIC")

set(CMAKE_CUDA_RUNTIME_LIBRARY_LINK_OPTIONS_STATIC "cudadevrt;cudart_static")

set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu1x")

endif()

set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")

set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")

else()

# clang-cl doesn't have any of these

set(CMAKE_C90_STANDARD_COMPILE_OPTION "")

set(CMAKE_C11_STANDARD_COMPILE_OPTION "")

set(CMAKE_C11_EXTENSION_COMPILE_OPTION "")

endif()

if(NOT "x${CMAKE_C_SIMULATE_ID}" STREQUAL "xMSVC")

else()

set(CMAKE_C_STANDARD_DEFAULT "")

endif()

set(success 1)

if(found)

message(STATUS "Downloaded object: \"${obj}\"")

elseif(EXISTS "${staged}")

set(obj "${staged}")

FetchContent_Declare(

googletest

GIT_REPOSITORY https://github.com/google/googletest.git

)

For most typical cases, populating the content can then be done with a single

FetchContent_Declare(

googletest

GIT_REPOSITORY https://github.com/google/googletest.git

)

FetchContent_Declare(

myCompanyIcons

URL https://intranet.mycompany.com/assets/iconset_1.12.tar.gz

)

FetchContent_Declare(

SVN_REVISION -r12345

)

Populating The Content

""""""""""""""""""""""

FetchContent_Declare(

googletest

GIT_REPOSITORY https://github.com/google/googletest.git

)

FetchContent_Declare(

Catch2

GIT_REPOSITORY https://github.com/catchorg/Catch2.git

)

# After the following call, the CMake targets defined by googletest and

FetchContent_Declare(

protobuf

GIT_REPOSITORY https://github.com/protocolbuffers/protobuf.git

SOURCE_SUBDIR cmake

)

set(protobuf_BUILD_TESTS OFF)

FetchContent_Declare(

projE

GIT_REPOSITORY git@mycompany.com:git/projE.git

)

# Order is important, see notes in the discussion further below

(adds ``-DBOOST_ALL_NO_LIB``).

``Boost::dynamic_linking``

(adds ``-DBOOST_ALL_DYN_LINK``).

Implicit dependencies such as ``Boost::filesystem`` requiring

#]=======================================================================]

cmake_policy(PUSH)

cmake_policy(SET CMP0057 NEW) # if IN_LIST

# For backwards compatibility support

The iconv libraries to be linked.

.. variable:: Iconv_IS_BUILT_IN

A variable indicating whether iconv support is stemming from the

On POSIX platforms, iconv might be part of the C library and the cache

variables ``Iconv_INCLUDE_DIR`` and ``Iconv_LIBRARY`` might be empty.

#]=======================================================================]

include(${CMAKE_CURRENT_LIST_DIR}/CMakePushCheckState.cmake)

mark_as_advanced(Iconv_INCLUDE_DIR)

mark_as_advanced(Iconv_LIBRARY)

include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)

if(NOT Iconv_IS_BUILT_IN)

else()

find_package_handle_standard_args(Iconv REQUIRED_VARS Iconv_LIBRARY)

endif()

Find the Gettext libintl headers and libraries.

This module reports information about the Gettext libintl

.. versionadded:: 3.20

This module defines :prop_tgt:`IMPORTED` target ``Intl::Intl``.

.. note::

On some platforms, such as Linux with GNU libc, the gettext

case.

.. note::

If you wish to use the Gettext tools (``msgmerge``,

``msgfmt``, etc.), use :module:`FindGettext`.

#]=======================================================================]

mark_as_advanced(Intl_INCLUDE_DIR)

# Find all Intl libraries

if(NOT Intl_IS_BUILTIN)

endif()

include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)

FIND_PACKAGE_HANDLE_STANDARD_ARGS(Intl

FOUND_VAR Intl_FOUND

FAIL_MESSAGE "Failed to find Gettext libintl")

if(Intl_FOUND)

set(Intl_INCLUDE_DIRS "${Intl_INCLUDE_DIR}")

# Detect the Fortran/C interface on the first run or when the

# configuration changes.

)

message(CHECK_START "Detecting Fortran/C Interface")

else()

string(CONCAT ctest_include_content

"if(EXISTS \"$<TARGET_FILE:${TARGET}>\")" "\n"

" include(\"${_GOOGLETEST_DISCOVER_TESTS_SCRIPT}\")" "\n"

" gtest_discover_tests_impl(" "\n"

" TEST_EXECUTABLE" " [==[" "$<TARGET_FILE:${TARGET}>" "]==]" "\n"

include(Platform/Darwin)

foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})

endforeach()

foreach(lib ${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES})

if(${lib} MATCHES "/")

else()

endif()

endforeach()

set(CMAKE_SHARED_LIBRARY_CREATE_CUDA_FLAGS "-shared -Wl,-headerpad_max_install_names")

set(CMAKE_SHARED_MODULE_CREATE_CUDA_FLAGS "-shared -Wl,-headerpad_max_install_names")

set(CMAKE_CUDA_COMPILE_WHOLE_COMPILATION

"<CMAKE_CUDA_COMPILER> ${_CMAKE_CUDA_EXTRA_FLAGS} <DEFINES> <INCLUDES> <FLAGS> ${_CMAKE_COMPILE_AS_CUDA_FLAG} -c <SOURCE> -o <OBJECT> -Xcompiler=-Fd<TARGET_COMPILE_PDB>,-FS")

foreach(dir ${CMAKE_CUDA_HOST_IMPLICIT_LINK_DIRECTORIES})

endforeach()

foreach(lib ${CMAKE_CUDA_HOST_IMPLICIT_LINK_LIBRARIES})

endforeach()

set(CMAKE_CUDA_LINK_EXECUTABLE

set(_CMAKE_VS_LINK_DLL "<CMAKE_COMMAND> -E vs_link_dll --intdir=<OBJECT_DIR> --rc=<CMAKE_RC_COMPILER> --mt=<CMAKE_MT> --manifests <MANIFESTS> -- ")

set(_CMAKE_VS_LINK_EXE "<CMAKE_COMMAND> -E vs_link_exe --intdir=<OBJECT_DIR> --rc=<CMAKE_RC_COMPILER> --mt=<CMAKE_MT> --manifests <MANIFESTS> -- ")

set(CMAKE_CUDA_CREATE_SHARED_LIBRARY

set(CMAKE_CUDA_CREATE_SHARED_MODULE ${CMAKE_CUDA_CREATE_SHARED_LIBRARY})

set(CMAKE_CUDA_CREATE_STATIC_LIBRARY "<CMAKE_AR> ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")

set(CMAKE_CUDA_LINKER_SUPPORTS_PDB ON)

set(CMAKE_CUDA_LINK_EXECUTABLE

unset(_CMAKE_VS_LINK_EXE)

# Add implicit host link directories that contain device libraries

# to the device link line.

endif()

if(EXISTS "${dir}/curand_static.lib")

endif()

endforeach()

set(CMAKE_CUDA_DEVICE_LINK_LIBRARY

set(CMAKE_CUDA_DEVICE_LINK_EXECUTABLE

string(REPLACE "/D" "-D" _PLATFORM_DEFINES_CUDA "${_PLATFORM_DEFINES}${_PLATFORM_DEFINES_CXX}")

endif()

unset(_cmp0092)

string(APPEND CMAKE_CUDA_FLAGS_INIT " ${PLATFORM_DEFINES_CUDA} -D_WINDOWS -Xcompiler=\"${_W3}${_FLAGS_CXX}\"")

string(APPEND CMAKE_CUDA_FLAGS_DEBUG_INIT " -Xcompiler=\"${_MDd}-Zi -Ob0 -Od ${_RTC1}\"")

string(APPEND CMAKE_CUDA_FLAGS_RELEASE_INIT " -Xcompiler=\"${_MD}-O2 -Ob2\" -DNDEBUG")

initialized with the value of this variable.

#]=======================================================================]

set(SWIG_CXX_EXTENSION "cxx")

set(SWIG_EXTRA_LIBRARIES "")

if (APPLE)

set_target_properties (${target_name} PROPERTIES SUFFIX ".jnilib")

endif()

set_target_properties(${target_name} PROPERTIES PREFIX "")

endif()

elseif (swig_lowercase_language STREQUAL "lua")

endif()

endif()

endfunction()

cmVisualStudioGeneratorOptions.cxx

cmVisualStudio10TargetGenerator.h

cmVisualStudio10TargetGenerator.cxx

cmLocalVisualStudio10Generator.cxx

cmLocalVisualStudio10Generator.h

cmGlobalVisualStudio10Generator.h

# CMake version number components.

set(CMake_VERSION_MAJOR 3)

set(CMake_VERSION_MINOR 20)

set(CMake_VERSION_IS_DIRTY 0)

# Start with the full version number used in tags. It has no dev info.

? this->GetOption("CPACK_DMG_FORMAT")

: "UDZO";

// Get optional arguments ...

std::string cpack_license_file =

this->GetOption("CPACK_RESOURCE_FILE_LICENSE")

temp_image_command << " -ov";

temp_image_command << " -srcfolder \"" << staging.str() << "\"";

temp_image_command << " -volname \"" << cpack_dmg_volume_name << "\"";

temp_image_command << " -format " << temp_image_format;

temp_image_command << " \"" << temp_image << "\"";

for (std::string const& gf : this->files) {

bool skip = false;

std::string inFile = gf;

inFile += '/';

}

for (cmsys::RegularExpression& reg : ignoreFilesRegex) {

}

#endif

if (nsisPath.empty()) {

cmCPackLogger(

using ArchToolsetStrategy = cmCMakePresetsFile::ArchToolsetStrategy;

constexpr int MIN_VERSION = 1;

struct CMakeVersion

{

.Bind("toolset"_s, ToolsetHelper, false)

.Bind("binaryDir"_s, &ConfigurePreset::BinaryDir, PresetStringHelper,

false)

.Bind<std::string>("cmakeExecutable"_s, nullptr, PresetStringHelper, false)

.Bind("cacheVariables"_s, &ConfigurePreset::CacheVariables,

VariablesHelper, false)

out->BinaryDir = cmSystemTools::CollapseFullPath(binaryDir);

cmSystemTools::ConvertToUnixSlashes(out->BinaryDir);

for (auto& variable : out->CacheVariables) {

if (variable.second) {

CHECK_EXPAND(out, variable.second->Value, macroExpanders)

preset.ToolsetStrategy = parent.ToolsetStrategy;

}

InheritString(preset.BinaryDir, parent.BinaryDir);

InheritOptionalValue(preset.WarnDev, parent.WarnDev);

InheritOptionalValue(preset.ErrorDev, parent.ErrorDev);

InheritOptionalValue(preset.WarnDeprecated, parent.WarnDeprecated);

"support.";

case ReadFileResult::INVALID_CONFIGURE_PRESET:

return "Invalid \"configurePreset\" field";

}

return "Unknown error";

.second) {

return ReadFileResult::DUPLICATE_PRESETS;

}

this->ConfigurePresetOrder.push_back(preset.Name);

}

INVALID_MACRO_EXPANSION,

BUILD_TEST_PRESETS_UNSUPPORTED,

INVALID_CONFIGURE_PRESET,

};

enum class ArchToolsetStrategy

std::string Toolset;

cm::optional<ArchToolsetStrategy> ToolsetStrategy;

std::string BinaryDir;

std::map<std::string, cm::optional<CacheVariable>> CacheVariables;

}

}

if (parseState == ParseMode::Valid) {

parseState = this->StoreCall(std::string(possible_value),

std::forward<CallState>(state)...)

? ParseMode::Valid

this->AddTargetItem(lib, tgt);

this->AddLibraryRuntimeInfo(lib.Value, tgt);

}

} else {

// This is not a CMake target. Use the name given.

void cmComputeLinkInformation::AddSharedDepItem(BT<std::string> const& item,

const cmGeneratorTarget* tgt)

{

// If dropping shared library dependencies, ignore them.

if (this->SharedDependencyMode == SharedDepModeNone) {

return;

}

}

void cmComputeLinkInformation::ComputeLinkTypeInfo()

{

// Check whether archives may actually be shared libraries.

std::string GetRPathString(bool for_install) const;

std::string GetChrpathString() const;

std::set<cmGeneratorTarget const*> const& GetSharedLibrariesLinked() const;

std::string const& GetLibLinkFileFlag() const

{

void AddItem(BT<std::string> const& item, const cmGeneratorTarget* tgt);

void AddSharedDepItem(BT<std::string> const& item,

cmGeneratorTarget const* tgt);

// Output information.

ItemVector Items;

std::vector<std::string> FrameworkPaths;

std::vector<std::string> RuntimeSearchPath;

std::set<cmGeneratorTarget const*> SharedLibrariesLinked;

// Context information.

cmGeneratorTarget const* const Target;

std::replace(func_name.begin(), func_name.end(), ' ', '_');

std::replace(func_name.begin(), func_name.end(), '/', '_');

std::replace(func_name.begin(), func_name.end(), ':', '_');

tests_func_name.push_back(func_name);

}

std::string functionMapCode;

// Isolate the file policy level.

// Support CMake versions as far back as 2.6 but also support using NEW

// and increased from time to time). This reduces the opportunity for CMake

// warnings when an older export file is later used with newer CMake

// versions.

/* clang-format off */

os << "cmake_policy(PUSH)\n"

/* clang-format on */

}

lg->GetIncludeDirectories(includes, target, language, config);

std::string includesString =

return includesString;

}

bool HandleRename(std::vector<std::string> const& args,

cmExecutionStatus& status)

{

return false;

}

cmStrCat(status.GetMakefile().GetCurrentSourceDirectory(), '/', args[2]);

}

return false;

}

}

bool HandleRemoveImpl(std::vector<std::string> const& args, bool recurse,

{ "GLOB_RECURSE"_s, HandleGlobRecurseCommand },

{ "MAKE_DIRECTORY"_s, HandleMakeDirectoryCommand },

{ "RENAME"_s, HandleRename },

{ "REMOVE"_s, HandleRemove },

{ "REMOVE_RECURSE"_s, HandleRemoveRecurse },

{ "COPY"_s, HandleCopyCommand },

#include <utility>

#include <cm/iterator>

#include <cm/string_view>

#include <cm/vector>

#include <cmext/algorithm>

#include "cmsys/String.h"

#include "cmAlgorithms.h"

#include "cmGeneratorExpression.h"

#include "cmGeneratorExpressionContext.h"

#include "cmGeneratorExpressionDAGChecker.h"

type != cmStateEnums::OBJECT_LIBRARY) {

std::ostringstream e;

e << "Objects of target \"" << tgtName

reportError(context, content->GetOriginalExpression(), e.str());

return std::string();

}

}

} targetObjectsNode;

static const struct CompileFeaturesNode : public cmGeneratorExpressionNode

{

CompileFeaturesNode() {} // NOLINT(modernize-use-equals-default)

{ "TARGET_EXISTS", &targetExistsNode },

{ "TARGET_NAME_IF_EXISTS", &targetNameIfExistsNode },

{ "TARGET_GENEX_EVAL", &targetGenexEvalNode },

{ "GENEX_EVAL", &genexEvalNode },

{ "BUILD_INTERFACE", &buildInterfaceNode },

{ "INSTALL_INTERFACE", &installInterfaceNode },

return location;

}

std::vector<cmCustomCommand> const& cmGeneratorTarget::GetPreBuildCommands()

const

{

#include <utility>

#include <vector>

#include "cmLinkItem.h"

#include "cmListFileCache.h"

#include "cmPolicies.h"

bool CanCompileSources() const;

const std::string& GetLocation(const std::string& config) const;

std::vector<cmCustomCommand> const& GetPreBuildCommands() const;

std::vector<cmCustomCommand> const& GetPreLinkCommands() const;

std::vector<cmCustomCommand> const& GetPostBuildCommands() const;

#include <cm/iterator>

#include <cm/memory>

#include <cmext/algorithm>

#include <cmext/memory>

codecvt::Encoding cmGlobalNinjaGenerator::GetMakefileEncoding() const

{

}

void cmGlobalNinjaGenerator::GetDocumentation(cmDocumentationEntry& entry)

this->NinjaSupportsMetadataOnRegeneration = !cmSystemTools::VersionCompare(

cmSystemTools::OP_LESS, this->NinjaVersion.c_str(),

RequiredNinjaVersionForMetadataOnRegeneration().c_str());

}

bool cmGlobalNinjaGenerator::CheckLanguages(

{

return "1.10.2";

}

bool SupportsConsolePool() const;

bool SupportsImplicitOuts() const;

bool SupportsManifestRestat() const;

std::string GetEditCacheCommand() const override;

bool FindMakeProgram(cmMakefile* mf) override;

void CheckNinjaFeatures();

bool CheckLanguages(std::vector<std::string> const& languages,

cmMakefile* mf) const override;

bool CheckFortran(cmMakefile* mf) const;

bool NinjaSupportsUnconditionalRecompactTool = false;

bool NinjaSupportsMultipleOutputs = false;

bool NinjaSupportsMetadataOnRegeneration = false;

bool DiagnosedCxxModuleSupport = false;

return ret;

}

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::LoadFlagTable(

{

std::string filename;

} else {

} else {

}

}

}

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetClFlagTable() const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetCSharpFlagTable()

const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetRcFlagTable() const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetLibFlagTable() const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetLinkFlagTable() const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetCudaFlagTable() const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetCudaHostFlagTable()

const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetMasmFlagTable() const

{

}

cmIDEFlagTable const* cmGlobalVisualStudio10Generator::GetNasmFlagTable() const

{

}

#include <memory>

#include <set>

#include "cmGlobalVisualStudio8Generator.h"

/** \class cmGlobalVisualStudio10Generator

* \brief Write a Unix makefiles.

std::string const& GetMSBuildCommand();

std::string const& defaultName,

std::string const& table) const;

std::string MSBuildCommand;

bool MSBuildCommandInitialized;

std::set<std::string> AndroidExecutableWarnings;

virtual std::string FindMSBuildCommand();

std::string FindDevEnvCommand() override;

bool ParseGeneratorToolset(std::string const& ts, cmMakefile* mf);

std::string CustomVCTargetsPath;

std::string VCTargetsPath;

bool FindVCTargetsPath(cmMakefile* mf);

includes, genexInterpreter.Evaluate(*cincludes, INCLUDE_DIRECTORIES),

*sf);

}

cmXCodeObject* buildFile =

this->CreateXCodeBuildFileFromPath(sf->ResolveFullPath(), gtgt, lang, sf);

// GNU assembly files (#16449)

for (auto const& language : languages) {

std::string includeFlags = this->CurrentLocalGenerator->GetIncludeFlags(

if (!includeFlags.empty()) {

cflags[language] += " " + includeFlags;

#include <algorithm>

#include <cassert>

#include <cstdio>

#include <functional>

#include <iterator>

#include <set>

namespace {

bool FilterRegex(std::vector<std::string> const& args, bool includeMatches,

std::string const& listName,

std::vector<std::string>& varArgsExpanded,

const char* sep = "";

size_t nitem = varArgsExpanded.size();

for (cc = 2; cc < args.size() - 1; cc++) {

value += sep;

sep = ";";

if (item < 0) {

const std::string& listName = args[1];

// expand the variable

std::vector<std::string> varArgsExpanded;

if ((!GetList(varArgsExpanded, listName, status.GetMakefile()) ||

varArgsExpanded.empty()) &&

return true;

}

using size_type = decltype(varArgsExpanded)::size_type;

std::vector<size_t> removed;

size_t nitem = varArgsExpanded.size();

for (cc = 2; cc < args.size(); ++cc) {

if (item < 0) {

item = static_cast<int>(nitem) + item;

}

}

std::string cmLocalGenerator::ConvertToIncludeReference(

{

return this->ConvertToOutputForExisting(path, format);

}

std::string cmLocalGenerator::GetIncludeFlags(

{

if (lang.empty()) {

return "";

flagUsed = true;

}

std::string includePath =

if (quotePaths && !includePath.empty() && includePath.front() != '\"') {

includeFlags << "\"";

}

}

file << "foreach(retry RANGE 1 30)\n";

file << " execute_process(COMMAND ${CMAKE_COMMAND} -E copy";

file << " \"" << from_file << "\""

<< " \"" << to_dir << "\" RESULT_VARIABLE result "

cmGeneratorTarget* target,

const std::string& config,

const std::string& lang);

//! Get the include flags for the current makefile and language

using GeneratorTargetVector =

std::vector<std::unique_ptr<cmGeneratorTarget>>;

bool GetRealDependency(const std::string& name, const std::string& config,

std::string& dep);

/** Called from command-line hook to clear dependencies. */

virtual void ClearDependencies(cmMakefile* /* mf */, bool /* verbose */) {}

cmProp GetRuleLauncher(cmGeneratorTarget* target, const std::string& prop);

protected:

//! put all the libraries for a target on into the given stream

void OutputLinkLibraries(cmComputeLinkInformation* pcli,

cmLinkLineComputer* linkLineComputer,

// contains any non-ASCII characters and dependency checking will fail.

// As a workaround, leave the msvc_deps_prefix UTF-8 encoded even though

// the rest of the file is ANSI encoded.

this->GetRulesFileStream().WriteRaw(showIncludesPrefix);

} else {

this->GetRulesFileStream() << showIncludesPrefix;

}

#else

// Virtual protected methods.

std::string cmLocalNinjaGenerator::ConvertToIncludeReference(

{

return this->ConvertToOutputFormat(

cmSystemTools::CollapseFullPath(path, this->GetCurrentBinaryDirectory()),

format);

#include "cmListFileCache.h"

#include "cmLocalCommonGenerator.h"

#include "cmNinjaTypes.h"

#include "cmOutputConverter.h"

protected:

std::string ConvertToIncludeReference(

private:

cmGeneratedFileStream& GetImplFileStream(const std::string& config) const;

// Deprecate old policies, especially those that require a lot

// of code to maintain the old behavior.

!(this->GetCMakeInstance()->GetIsInTryCompile() &&

(

// Policies set by cmCoreTryCompile::TryCompileCode.

vars.Target = target.c_str();

vars.LinkLibraries = linkLibs.c_str();

vars.ObjectsQuoted = buildObjs.c_str();

if (this->GeneratorTarget->HasSOName(this->GetConfigName())) {

vars.SONameFlag = this->Makefile->GetSONameFlag(linkLanguage);

}

vars.LinkFlags = linkFlags.c_str();

vars.Defines = definesString.c_str();

std::string includesString = this->LocalGenerator->GetIncludeFlags(

this->LocalGenerator->AppendFlags(includesString,

"$(" + lang + "_INCLUDES)");

vars.Includes = includesString.c_str();

lang, this->GetConfigName());

std::string includeFlags = this->LocalGenerator->GetIncludeFlags(

if (includeFlags.empty()) {

return;

}

if (genTarget->HasSOName(config)) {

vars["SONAME_FLAG"] =

this->GetMakefile()->GetSONameFlag(this->TargetLinkLanguage(config));

if (genTarget->GetType() == cmStateEnums::SHARED_LIBRARY) {

std::string install_dir =

this->GetGeneratorTarget()->GetInstallNameDirForBuildTree(config);

}

if (gt->HasSOName(config)) {

vars["SONAME_FLAG"] = mf->GetSONameFlag(this->TargetLinkLanguage(config));

if (targetType == cmStateEnums::SHARED_LIBRARY) {

std::string install_dir = gt->GetInstallNameDirForBuildTree(config);

if (!install_dir.empty()) {

language, config);

// Add include directory flags.

std::string includeFlags = this->LocalGenerator->GetIncludeFlags(

if (this->GetGlobalGenerator()->IsGCCOnWindows()) {

std::replace(includeFlags.begin(), includeFlags.end(), '\\', '/');

}

}

std::string includesString = this->LocalGenerator->GetIncludeFlags(

this->LocalGenerator->AppendFlags(includesString,

this->GetIncludes(language, config));

cmSystemTools::GetParentDirectory(source->GetFullPath()));

std::string sourceDirectoryFlag = this->LocalGenerator->GetIncludeFlags(

vars["INCLUDES"] = cmStrCat(sourceDirectoryFlag, ' ', vars["INCLUDES"]);

}

3, 20, 0, cmPolicies::WARN) \

SELECT(POLICY, CMP0120, \

"The WriteCompilerDetectionHeader module is removed.", 3, 20, 0, \

#define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1)

#define CM_FOR_EACH_POLICY_ID(POLICY) \

if (!uicOpts.empty()) {

this->Uic.UiFiles.emplace_back(fullPath, cmExpandedList(uicOpts));

}

} else {

// Register skipped .ui file

this->Uic.SkipUi.insert(fullPath);

autogenByproducts.push_back(this->Moc.CompilationFileGenex);

}

// Compose target comment

std::string autogenComment;

{

std::vector<UiFileT> UiFiles;

ConfigStrings<std::vector<std::string>> Options;

std::vector<std::string> SearchPaths;

} Uic;

/** rcc variables. */

};

// Vicinity of the source

if (!includePrefix.empty()) {

if (findUi(cmStrCat(sourceDirPrefix, includePrefix, this->UiName))) {

return true;

}

}

// Additional AUTOUIC search paths

auto const& searchPaths = this->UicConst().SearchPaths;

if (!searchPaths.empty()) {

std::unordered_map<std::string, StanardLevelComputer> StandardComputerMapping =

{

{ "C",

{ "CXX",

StanardLevelComputer{

"CXX", std::vector<int>{ 98, 11, 14, 17, 20, 23 },

# include <unistd.h>

# include <sys/time.h>

#endif

#if defined(_WIN32) && \

# define environ (*_NSGetEnviron())

#endif

bool cmSystemTools::s_RunCommandHideConsole = false;

bool cmSystemTools::s_DisableRunCommandOutput = false;

bool cmSystemTools::s_ErrorOccured = false;

#ifdef _WIN32

namespace {

{

// Not only ignore any previous error, but clear any memory of it.

SetLastError(0);

}

}

#endif

bool cmSystemTools::RenameFile(const std::string& oldname,

const std::string& newname)

{

#ifdef _WIN32

# ifndef INVALID_FILE_ATTRIBUTES

# define INVALID_FILE_ATTRIBUTES ((DWORD)-1)

oldname_wstr, FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);

DWORD move_last_error = 0;

move_last_error = GetLastError();

// There was no error ==> the operation is not yet complete.

// 3) Windows Explorer has an associated directory already opened.

if (move_last_error != ERROR_ACCESS_DENIED &&

move_last_error != ERROR_SHARING_VIOLATION) {

}

DWORD const attrs = GetFileAttributesW(newname_wstr.c_str());

save_restore_file_attributes.SetPath(newname_wstr);

}

SetLastError(move_last_error);

#else

#endif

}

static bool SimpleGlob(const std::string& glob,

std::vector<std::string>& files, int type = 0);

/** Rename a file or directory within a single disk volume (atomic

if possible). */

static bool RenameFile(const std::string& oldname,

const std::string& newname);

//! Rename a file if contents are different, delete the source otherwise

static void MoveFileIfDifferent(const std::string& source,

#include "cm_sys_stat.h"

#include "cmCMakePresetsFile.h"

#include "cmCommandLineArgument.h"

#include "cmCommands.h"

return true;

};

std::vector<CommandArgument> arguments = {

CommandArgument{ "-D", "-D must be followed with VAR=VALUE.",

CommandArgument::Values::One, DefineLambda },

state->ReadListFile(args, path);

return true;

} },

CommandArgument{ "-P", "-P must be followed by a file name.",

CommandArgument::Values::One, ScriptLambda },

CommandArgument{ "--find-package", CommandArgument::Values::Zero,

[&](std::string const&, cmake*) -> bool {

findPackageMode = true;

this->GlobalGenerator->CreateGenerationObjects();

const auto& lg = this->GlobalGenerator->LocalGenerators[0];

std::string includeFlags =

std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS");

printf("%s %s\n", includeFlags.c_str(), definitions.c_str());

CommandArgument::Values::One, PlatformLambda },

CommandArgument{ "-T", "No toolset specified for -T",

CommandArgument::Values::One, ToolsetLamda },

CommandArgument{ "--check-build-system", CommandArgument::Values::Two,

[](std::string const& value, cmake* state) -> bool {

this->UnprocessedPresetVariables = expandedPreset->CacheVariables;

this->UnprocessedPresetEnvironment = expandedPreset->Environment;

if (!expandedPreset->ArchitectureStrategy ||

expandedPreset->ArchitectureStrategy ==

cmCMakePresetsFile::ArchToolsetStrategy::Set) {

"Specify toolset name if supported by generator." }, \

{ "-A <platform-name>", \

"Specify platform name if supported by generator." }, \

{ "-Wdev", "Enable developer warnings." }, \

{ "-Wno-dev", "Suppress developer warnings." }, \

{ "-Werror=dev", "Make developer warnings errors." }, \

F(c_std_90) \

F(c_std_99) \

F(c_std_11) \

FOR_EACH_C90_FEATURE(F) \

FOR_EACH_C99_FEATURE(F) \

FOR_EACH_C11_FEATURE(F)

delete[] buf;

if (srchHandle == -1) {

}

// Loop through names

delete[] buf;

if (srchHandle == -1) {

return 0;

}

Glob();

~Glob();

//! Find all files that match the pattern.

bool FindFiles(const std::string& inexpr, GlobMessages* messages = nullptr);

std::vector<std::string> VisitedSymlinks;

bool ListDirs;

bool RecurseListDirs;

};

} // namespace @KWSYS_NAMESPACE@

return _wchdir(KWSYS_NAMESPACE::Encoding::ToWide(dir).c_str());

}

inline void Realpath(const std::string& path, std::string& resolved_path,

{

std::wstring tmp = KWSYS_NAMESPACE::Encoding::ToWide(path);

wchar_t* ptemp;

return false;

}

{

// Open files

kwsys::ifstream fin(source.c_str(), std::ios::in | std::ios::binary);

* - The underlying filesystem does not support file cloning

* - An unspecified error occurred

*/

{

#if defined(__linux) && defined(FICLONE)

int in = open(source.c_str(), O_RDONLY);

SystemTools::MakeDirectory(destination_dir);

// if cloning did not succeed, fall back to blockwise copy

return false;

}

}

const std::string& path2);

/**

* Return true if the two files are the same file

*/

static bool SameFile(const std::string& file1, const std::string& file2);

include(${CMAKE_CURRENT_SOURCE_DIR}/CheckSwift.cmake)

# Fake a user home directory to avoid polluting the real one.

set(TEST_HOME "${CMake_BINARY_DIR}/Tests/CMakeFiles/TestHome")

file(MAKE_DIRECTORY "${TEST_HOME}")

file(WRITE "${TEST_HOME}/.cvspass" ":pserver:anoncvs@www.cmake.org:/cvsroot/KWSys A\n")

set(TEST_HOME_ENV_CODE "# Fake a user home directory to avoid polluting the real one.

# But provide original ENV{HOME} value in ENV{CTEST_REAL_HOME} for tests that

# need access to the real HOME directory.

set(ENV{CTEST_REAL_HOME} \"\$ENV{HOME}\")

endif()

set(ENV{HOME} \"${TEST_HOME}\")

# some old versions of make simply cannot handle spaces in paths

if (MAKE_IS_GNU OR

CMAKE_MAKE_PROGRAM MATCHES "nmake|gmake|wmake" OR

set(MAKE_SUPPORTS_SPACES 1)

else()

set(MAKE_SUPPORTS_SPACES 0)

${build_generator_args}

--build-project Framework

--build-options

"-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/Framework/Install"

--test-command bar)

list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Framework")

${build_generator_args}

--build-project LibName

--build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"

--test-command foobar

)

list(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/LibName")

if (std_flag_idx EQUAL -1)

add_executable(default_dialect_C default_dialect.c)

target_compile_definitions(default_dialect_C PRIVATE

DEFAULT_C11=$<EQUAL:${CMAKE_C_STANDARD_DEFAULT},11>

DEFAULT_C99=$<EQUAL:${CMAKE_C_STANDARD_DEFAULT},99>

DEFAULT_C90=$<EQUAL:${CMAKE_C_STANDARD_DEFAULT},90>

# if __STDC_VERSION__ < 201112L

# error Unexpected value for __STDC_VERSION__.

# endif

set(proj TutorialStep5-Local-TestAfterInstall)

ExternalProject_Add(${proj}

URL "${CMAKE_CURRENT_SOURCE_DIR}/Step5"

CMAKE_CACHE_DEFAULT_ARGS -DUSE_MYMATH:BOOL=OFF

TEST_AFTER_INSTALL 1

LOG_TEST 1

set(proj TutorialStep5-Local-TestExcludeFromMainBefore)

ExternalProject_Add(${proj}

URL "${CMAKE_CURRENT_SOURCE_DIR}/Step5"

CMAKE_CACHE_DEFAULT_ARGS -DUSE_MYMATH:BOOL=OFF

TEST_BEFORE_INSTALL 1

TEST_EXCLUDE_FROM_MAIN 1

set(proj TutorialStep5-Local-TestExcludeFromMainAfter)

ExternalProject_Add(${proj}

URL "${CMAKE_CURRENT_SOURCE_DIR}/Step5"

CMAKE_CACHE_DEFAULT_ARGS -DUSE_MYMATH:BOOL=OFF

TEST_AFTER_INSTALL 1

TEST_EXCLUDE_FROM_MAIN 1

# configure a FindFoo.cmake so it knows where the library can be found

configure_file(FindFoo.cmake.in ${CMAKE_CURRENT_BINARY_DIR}/FindFoo.cmake @ONLY)

endif()

# now set up the test:

CMAKE_CXX_COMPILER = "@CMAKE_CXX_COMPILER@"

CMAKE_CXX_COMPILER_ID = "@CMAKE_CXX_COMPILER_ID@"

CMAKE_CXX_FLAGS = @CMAKE_CXX_FLAGS@

CMAKE_FOO = $(CMAKE) --find-package -DCMAKE_MODULE_PATH=$(CMAKE_CURRENT_BINARY_DIR) -DNAME=Foo -DLANGUAGE=CXX -DCOMPILER_ID=$(CMAKE_CXX_COMPILER_ID)

main.o: clean main.cpp

@$(CMAKE_FOO) -DMODE=COMPILE >$(tmp)

@foo="`cat $(tmp)`"; \

@cat $(tmp)

@sh $(tmp)

@rm -f $(tmp)

pngtest: main.o

@$(CMAKE_FOO) -DMODE=LINK >$(tmp)

@foo="`cat $(tmp)`"; \

@cat $(tmp)

@sh $(tmp)

@rm -f $(tmp)

cmake_minimum_required (VERSION 3.9)

project(FortranModules Fortran)

if(NOT DEFINED CMake_TEST_NESTED_MAKE_PROGRAM AND NOT CMAKE_GENERATOR MATCHES "Visual Studio")

set(CMake_TEST_NESTED_MAKE_PROGRAM "${CMAKE_MAKE_PROGRAM}")

endif()

target_link_libraries(barStatic fooStatic)

endif()

add_library(space SHARED space.c)

set_target_properties(space PROPERTIES

FRAMEWORK TRUE

add_executable(verFoobar foobar.c)

target_link_libraries(verFoobar verFoo)

ADD_AUTOGEN_TEST(RerunMocOnMissingDependency)

ADD_AUTOGEN_TEST(RerunRccConfigChange)

ADD_AUTOGEN_TEST(RerunRccDepends)

ADD_AUTOGEN_TEST(SameName sameName)

ADD_AUTOGEN_TEST(StaticLibraryCycle slc)

ADD_AUTOGEN_TEST(UicInclude uicInclude)

run_cmake(CMP0041-OLD)

run_cmake(CMP0041-NEW)

run_cmake(CMP0041-WARN)

run_cmake(CMP0041-tid-OLD)

run_cmake(CMP0041-tid-NEW)

run_cmake(CMP0041-tid-WARN)