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

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

file(`SIZE`_ <filename> <out-var>)

`Path Conversion`_

file(`RELATIVE_PATH`_ <out-var> <directory> <file>)

.. code-block:: cmake

Note that this command returns the raw symlink path and does not resolve

.. code-block:: cmake

if(NOT IS_ABSOLUTE "${result}")

set(result "${dir}/${result}")

endif()

.. code-block:: cmake

[RESULT <result>] [COPY_ON_ERROR] [SYMBOLIC])

Specifying ``COPY_ON_ERROR`` enables copying the file as a fallback if

Path Conversion

^^^^^^^^^^^^^^^

NAME = File name without directory

EXT = File name longest extension (.b.c from d/a.b.c)

NAME_WE = File name without directory or longest extension

NAME_WLE = File name without directory or last extension

PATH = Legacy alias for DIRECTORY (use for CMake <= 2.8.11)

Paths are returned with forward slashes and have no trailing slashes.

.. code-block:: cmake

* The :module:`ExternalProject` module :command:`ExternalProject_Add` command

gained ``LOG_PATCH`` to optionally log the patch step.

learned to apply ``SOURCE_SUBDIR`` when ``BUILD_IN_SOURCE`` is also used.

The ``BUILD_COMMAND`` is run in the given ``SOURCE_SUBDIR`` of the

``SOURCE_DIR``.

CMake does not explicitly specify these directories on compiler

command lines for language ``<LANG>``. This prevents system include

directories from being treated as user include directories on some

set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_XL "XL C")

list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS MSVC )

set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_MSVC "Microsoft")

list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TI )

file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log

"Parsed ${lang} implicit include dir info from above output: rv=${rv}\n${log}\n\n")

if("${rv}" STREQUAL "done")

# We parsed implicit include directories, so override the default initializer.

set(_CMAKE_${lang}_IMPLICIT_INCLUDE_DIRECTORIES_INIT "${implicit_incdirs}")

endif()

endif()

# Test whether an MSVC-like command-line option works.

RESULT_VARIABLE _clang_result

OUTPUT_VARIABLE _clang_stdout

ERROR_VARIABLE _clang_stderr)

function(_DetermineVSServicePack_FastCheckVersionWithCompiler _SUCCESS_VAR _VERSION_VAR)

if(EXISTS ${CMAKE_CXX_COMPILER})

execute_process(

ERROR_VARIABLE _output

OUTPUT_QUIET

)

When enabled, the output of the test step is logged to files.

``LOG_MERGED_STDOUTERR <bool>``

``LOG_OUTPUT_ON_FAILURE <bool>``

This option only has an effect if at least one of the other ``LOG_<step>``

foreach(compiler IN LISTS _boost_COMPILER)

list(APPEND _boost_RELEASE_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG} )

endforeach()

list(APPEND _boost_RELEASE_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_ABI_TAG}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} )

foreach(compiler IN LISTS _boost_COMPILER)

list(APPEND _boost_RELEASE_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} )

endforeach()

list(APPEND _boost_RELEASE_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_RELEASE_STATIC_ABI_TAG} )

endif()

endforeach()

foreach(compiler IN LISTS _boost_COMPILER)

list(APPEND _boost_DEBUG_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG} )

endforeach()

list(APPEND _boost_DEBUG_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component} )

foreach(compiler IN LISTS _boost_COMPILER)

list(APPEND _boost_DEBUG_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${compiler}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} )

endforeach()

list(APPEND _boost_DEBUG_NAMES

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG}${_boost_ARCHITECTURE_TAG}-${Boost_LIB_VERSION}

${Boost_LIB_PREFIX}${Boost_NAMESPACE}_${component}${_boost_MULTITHREADED}${_boost_DEBUG_STATIC_ABI_TAG} )

endif()

endforeach()

/lib /lib32 /lib64 /usr/lib /usr/lib32 /usr/lib64

)

# Default per-language values. These may be later replaced after

# parsing the implicit directory information from compiler output.

set(_CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES_INIT

${CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES}

)

set(_CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES_INIT

${CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES}

)

set(_CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES_INIT

${CMAKE_CUDA_IMPLICIT_INCLUDE_DIRECTORIES}

)

# Enable use of lib32 and lib64 search path variants by default.

set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB32_PATHS TRUE)

set_property(GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS TRUE)

bool required)

{

// Find the default version of the Windows 10 SDK.

std::ostringstream e;

e << "Could not find an appropriate version of the Windows 10 SDK"

<< " installed on this machine";

mf->IssueMessage(MessageType::FATAL_ERROR, e.str());

return false;

}

if (!cmSystemTools::VersionCompareEqual(this->WindowsTargetPlatformVersion,

this->SystemVersion)) {

std::ostringstream e;

}

mf->AddDefinition("CMAKE_VS_WINDOWS_TARGET_PLATFORM_VERSION",

this->WindowsTargetPlatformVersion.c_str());

}

bool cmGlobalVisualStudio14Generator::SelectWindowsStoreToolset(

virtual bool SelectWindows10SDK(cmMakefile* mf, bool required);

// Used to verify that the Desktop toolset for the current generator is

// installed on the machine.

bool IsWindowsDesktopToolsetInstalled() const override;

// If the Win 8.1 SDK is installed then we can select a SDK matching

// the target Windows version.

if (this->IsWin81SDKInstalled()) {

return cmGlobalVisualStudio14Generator::InitializeWindows(mf);

}

// Otherwise we must choose a Win 10 SDK even if we are not targeting

return result;

}

// Implicit include directories

std::vector<std::string> implicitDirs;

std::set<std::string> implicitSet;

return (implicitSet.find(dir) == implicitSet.end());

};

{

// Raw list of implicit include directories

// Load implicit include directories for this language.

}

// The Platform/UnixPaths module used to hard-code /usr/include for C, CXX,

}

for (std::string const& i : impDirVec) {

}

}

}

MoveSystemIncludesToEnd(result, config, lang, target);

// Append standard include directories for this language.

}

// Append compiler implicit include directories

#include "cmAlgorithms.h"

#include "cmCustomCommandLines.h"

#include "cmGeneratorTarget.h"

#include "cmLocalGenerator.h"

#include "cmMakefile.h"

#include "cmMessageType.h"

#include "cmState.h"

#include "cmStateTypes.h"

#include "cmSystemTools.h"

}

}

bool cmQtAutoGenGlobalInitializer::generate()

{

return (InitializeCustomTargets() && SetupCustomTargets());

#include <map>

#include <memory> // IWYU pragma: keep

#include <string>

#include <vector>

class cmLocalGenerator;

void AddToGlobalAutoRcc(cmLocalGenerator* localGen,

std::string const& targetName);

private:

std::vector<std::unique_ptr<cmQtAutoGenInitializer>> Initializers_;

std::map<cmLocalGenerator*, std::string> GlobalAutoGenTargets_;

std::map<cmLocalGenerator*, std::string> GlobalAutoRccTargets_;

};

#endif

return res;

}

const std::string& executable, bool ignoreMissingTarget, std::string* output)

{

const std::string upperExecutable = cmSystemTools::UpperCase(executable);

if (!result.empty()) {

cmGeneratorExpression ge(lfbt);

std::unique_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(result);

return std::make_pair(true, result);

}

// Find executable

{

const std::string targetName =

if (targetName.empty()) {

err = "The AUTO" + upperExecutable + " feature ";

err += "supports only Qt 4, Qt 5 and Qt 6.";

} else {

cmGeneratorTarget* tgt = localGen->FindGeneratorTargetToUse(targetName);

if (tgt != nullptr) {

if (tgt->IsImported()) {

// Test executable

if (err.empty()) {

}

// Print error

if (!err.empty()) {

std::string msg = "AutoGen (";

msg += "): ";

msg += err;

cmSystemTools::Error(msg);

bool cmQtAutoGenInitializer::GetMocExecutable()

{

this->Moc.Executable = result.second;

return result.first;

}

bool cmQtAutoGenInitializer::GetUicExecutable()

{

this->Uic.Executable = result.second;

return result.first;

}

bool cmQtAutoGenInitializer::GetRccExecutable()

{

std::string stdOut;

this->Rcc.Executable = result.second;

if (!result.first) {

return false;

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

std::string& errorMessage);

private:

cmQtAutoGenGlobalInitializer* GlobalInitializer;

cmGeneratorTarget* Target;