You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2123 lines
65 KiB
2123 lines
65 KiB
#!/bin/sh
|
|
# Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
# file Copyright.txt or https://cmake.org/licensing for details.
|
|
|
|
die() {
|
|
echo "$@" 1>&2 ; exit 1
|
|
}
|
|
|
|
# Compile flag extraction function.
|
|
cmake_extract_standard_flags()
|
|
{
|
|
id="${1:-*}"
|
|
lang="${2}"
|
|
ver="${3}"
|
|
sed -n "s/ *set *( *CMAKE_${lang}${ver}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \
|
|
"${cmake_source_dir}/Modules/Compiler/"${id}-${lang}.cmake \
|
|
2>/dev/null | tr ';' ' '
|
|
# Clang's CXX compiler flags are in the common module.
|
|
sed -n "s/ *set *( *CMAKE_\\\${lang}${ver}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \
|
|
"${cmake_source_dir}/Modules/Compiler/Clang.cmake" \
|
|
2>/dev/null | tr ';' ' '
|
|
}
|
|
|
|
# Version number extraction function.
|
|
cmake_version_component()
|
|
{
|
|
sed -n "
|
|
/^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\)).*/\1/;p;}
|
|
" "${cmake_source_dir}/Source/CMakeVersion.cmake"
|
|
}
|
|
|
|
# Install destination extraction function.
|
|
cmake_install_dest_default()
|
|
{
|
|
sed -n '
|
|
/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT.*) # '"${2}"'$/ {
|
|
s/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT *"\([^"]*\)").*$/\1/
|
|
s/${CMake_VERSION_MAJOR}/'"${cmake_version_major}"'/
|
|
s/${CMake_VERSION_MINOR}/'"${cmake_version_minor}"'/
|
|
s/${CMake_VERSION_PATCH}/'"${cmake_version_patch}"'/
|
|
p
|
|
q
|
|
}
|
|
' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake"
|
|
}
|
|
|
|
cmake_toupper()
|
|
{
|
|
echo "$1" | tr '[a-z]' '[A-Z]'
|
|
}
|
|
|
|
# Detect system and directory information.
|
|
cmake_system=`uname`
|
|
cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd`
|
|
cmake_binary_dir=`pwd`
|
|
|
|
# Load version information.
|
|
cmake_version_major="`cmake_version_component MAJOR`"
|
|
cmake_version_minor="`cmake_version_component MINOR`"
|
|
cmake_version_patch="`cmake_version_component PATCH`"
|
|
cmake_version="${cmake_version_major}.${cmake_version_minor}.${cmake_version_patch}"
|
|
cmake_version_rc="`cmake_version_component RC`"
|
|
if test "$cmake_version_rc" != ""; then
|
|
cmake_version="${cmake_version}-rc${cmake_version_rc}"
|
|
fi
|
|
|
|
cmake_copyright="`grep '^Copyright .* Kitware' "${cmake_source_dir}/Copyright.txt"`"
|
|
|
|
cmake_bin_dir_keyword="OTHER"
|
|
cmake_data_dir_keyword="OTHER"
|
|
cmake_doc_dir_keyword="OTHER"
|
|
cmake_man_dir_keyword="OTHER"
|
|
cmake_xdgdata_dir_keyword="OTHER"
|
|
cmake_bin_dir=""
|
|
cmake_data_dir=""
|
|
cmake_doc_dir=""
|
|
cmake_man_dir=""
|
|
cmake_xdgdata_dir=""
|
|
cmake_init_file=""
|
|
cmake_bootstrap_system_libs=""
|
|
cmake_bootstrap_qt_gui=""
|
|
cmake_bootstrap_qt_qmake=""
|
|
cmake_bootstrap_debugger=""
|
|
cmake_sphinx_info=""
|
|
cmake_sphinx_man=""
|
|
cmake_sphinx_html=""
|
|
cmake_sphinx_qthelp=""
|
|
cmake_sphinx_latexpdf=""
|
|
cmake_sphinx_build=""
|
|
cmake_sphinx_flags=""
|
|
|
|
# Determine whether this is a Cygwin environment.
|
|
if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then
|
|
cmake_system_cygwin=true
|
|
cmake_doc_dir_keyword="CYGWIN"
|
|
cmake_man_dir_keyword="CYGWIN"
|
|
else
|
|
cmake_system_cygwin=false
|
|
fi
|
|
|
|
# Determine whether this is a MSYS environment.
|
|
if echo "${cmake_system}" | grep MSYS >/dev/null 2>&1; then
|
|
cmake_system_msys=true
|
|
cmake_doc_dir_keyword="MSYS"
|
|
cmake_man_dir_keyword="MSYS"
|
|
else
|
|
cmake_system_msys=false
|
|
fi
|
|
|
|
# Determine whether this is a MinGW environment.
|
|
if echo "${cmake_system}" | grep 'MINGW' >/dev/null 2>&1; then
|
|
cmake_system_mingw=true
|
|
else
|
|
cmake_system_mingw=false
|
|
fi
|
|
|
|
# Determine whether this is OS X
|
|
if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then
|
|
cmake_system_darwin=true
|
|
else
|
|
cmake_system_darwin=false
|
|
fi
|
|
|
|
# Determine whether this is BeOS
|
|
if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then
|
|
cmake_system_beos=true
|
|
cmake_doc_dir_keyword="HAIKU"
|
|
cmake_man_dir_keyword="HAIKU"
|
|
else
|
|
cmake_system_beos=false
|
|
fi
|
|
|
|
# Determine whether this is Haiku
|
|
if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then
|
|
cmake_system_haiku=true
|
|
cmake_doc_dir_keyword="HAIKU"
|
|
cmake_man_dir_keyword="HAIKU"
|
|
else
|
|
cmake_system_haiku=false
|
|
fi
|
|
|
|
# Determine whether this is OpenVMS
|
|
if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then
|
|
cmake_system_openvms=true
|
|
else
|
|
cmake_system_openvms=false
|
|
fi
|
|
|
|
# Determine whether this is HP-UX
|
|
if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then
|
|
die 'CMake no longer compiles on HP-UX. See
|
|
|
|
https://gitlab.kitware.com/cmake/cmake/-/issues/17137
|
|
|
|
Use CMake 3.9 or lower instead.'
|
|
cmake_system_hpux=true
|
|
else
|
|
cmake_system_hpux=false
|
|
fi
|
|
|
|
# Determine whether this is AIX
|
|
if echo "${cmake_system}" | grep AIX >/dev/null 2>&1; then
|
|
cmake_system_aix=true
|
|
else
|
|
cmake_system_aix=false
|
|
fi
|
|
|
|
# Determine whether this is Linux
|
|
if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then
|
|
cmake_system_linux=true
|
|
else
|
|
cmake_system_linux=false
|
|
fi
|
|
|
|
# Determine whether this is a PA-RISC machine
|
|
# This only works for Linux or HP-UX, not other PA-RISC OSs (BSD maybe?). Also
|
|
# may falsely detect parisc on HP-UX m68k
|
|
cmake_machine_parisc=false
|
|
if ${cmake_system_linux}; then
|
|
if uname -m | grep parisc >/dev/null 2>&1; then
|
|
cmake_machine_parisc=true
|
|
fi
|
|
elif ${cmake_system_hpux}; then
|
|
if uname -m | grep ia64 >/dev/null 2>&1; then : ; else
|
|
cmake_machine_parisc=true
|
|
fi
|
|
fi
|
|
|
|
# Choose the generator to use for bootstrapping.
|
|
if ${cmake_system_mingw}; then
|
|
# Bootstrapping from an MSYS prompt.
|
|
cmake_bootstrap_generator="MSYS Makefiles"
|
|
else
|
|
# Bootstrapping from a standard UNIX prompt.
|
|
cmake_bootstrap_generator="Unix Makefiles"
|
|
fi
|
|
|
|
# Choose tools and extensions for this platform.
|
|
if ${cmake_system_openvms}; then
|
|
_tmp="_tmp"
|
|
_cmk="_cmk"
|
|
_diff=`which diff`
|
|
else
|
|
_tmp=".tmp"
|
|
_cmk=".cmk"
|
|
_diff="diff"
|
|
fi
|
|
|
|
# Construct bootstrap directory name.
|
|
cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}"
|
|
|
|
# Helper function to fix windows paths.
|
|
case "${cmake_system}" in
|
|
*MINGW*)
|
|
cmake_fix_slashes()
|
|
{
|
|
cmd //c echo "$(echo "$1" | sed 's/\\/\//g')" | sed 's/^"//;s/" *$//'
|
|
}
|
|
;;
|
|
*)
|
|
cmake_fix_slashes()
|
|
{
|
|
echo "$1" | sed 's/\\/\//g'
|
|
}
|
|
;;
|
|
esac
|
|
|
|
# Choose the default install prefix.
|
|
if ${cmake_system_mingw}; then
|
|
if test "x${PROGRAMFILES}" != "x"; then
|
|
cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"`
|
|
elif test "x${ProgramFiles}" != "x"; then
|
|
cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"`
|
|
elif test "x${SYSTEMDRIVE}" != "x"; then
|
|
cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"`
|
|
elif test "x${SystemDrive}" != "x"; then
|
|
cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"`
|
|
else
|
|
cmake_default_prefix="c:/Program Files/CMake"
|
|
fi
|
|
elif ${cmake_system_haiku}; then
|
|
cmake_default_prefix=`finddir B_COMMON_DIRECTORY`
|
|
else
|
|
cmake_default_prefix="/usr/local"
|
|
fi
|
|
|
|
# Lookup default install destinations.
|
|
cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`"
|
|
cmake_data_dir_default="`cmake_install_dest_default DATA ${cmake_data_dir_keyword}`"
|
|
cmake_doc_dir_default="`cmake_install_dest_default DOC ${cmake_doc_dir_keyword}`"
|
|
cmake_man_dir_default="`cmake_install_dest_default MAN ${cmake_man_dir_keyword}`"
|
|
cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`"
|
|
|
|
CMAKE_KNOWN_C_COMPILERS="cc gcc clang xlc icx tcc"
|
|
CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icpx"
|
|
CMAKE_KNOWN_MAKE_PROCESSORS="gmake make smake"
|
|
CMAKE_KNOWN_NINJA_PROCESSORS="ninja-build ninja samu"
|
|
|
|
CMAKE_PROBLEMATIC_FILES="\
|
|
CMakeCache.txt \
|
|
CMakeSystem.cmake \
|
|
CMakeCCompiler.cmake \
|
|
CMakeCXXCompiler.cmake \
|
|
*/CMakeSystem.cmake \
|
|
*/CMakeCCompiler.cmake \
|
|
*/CMakeCXXCompiler.cmake \
|
|
Source/cmConfigure.h \
|
|
Source/CTest/Curl/config.h \
|
|
Utilities/cmThirdParty.h \
|
|
Utilities/cmcurl/lib/curl_config.h \
|
|
Utilities/cmlibarchive/config.h \
|
|
Utilities/cmliblzma/config.h \
|
|
Utilities/cmnghttp2/config.h \
|
|
"
|
|
|
|
CMAKE_UNUSED_SOURCES="\
|
|
cmGlobalXCodeGenerator \
|
|
cmLocalXCodeGenerator \
|
|
cmXCodeObject \
|
|
cmXCode21Object \
|
|
cmSourceGroup \
|
|
"
|
|
|
|
CMAKE_CXX_SOURCES="\
|
|
cmAddCompileDefinitionsCommand \
|
|
cmAddCustomCommandCommand \
|
|
cmAddCustomTargetCommand \
|
|
cmAddDefinitionsCommand \
|
|
cmAddDependenciesCommand \
|
|
cmAddExecutableCommand \
|
|
cmAddLibraryCommand \
|
|
cmAddSubDirectoryCommand \
|
|
cmAddTestCommand \
|
|
cmArgumentParser \
|
|
cmBinUtilsLinker \
|
|
cmBinUtilsLinuxELFGetRuntimeDependenciesTool \
|
|
cmBinUtilsLinuxELFLinker \
|
|
cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool \
|
|
cmBinUtilsMacOSMachOGetRuntimeDependenciesTool \
|
|
cmBinUtilsMacOSMachOLinker \
|
|
cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool \
|
|
cmBinUtilsWindowsPEGetRuntimeDependenciesTool \
|
|
cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool \
|
|
cmBinUtilsWindowsPELinker \
|
|
cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool \
|
|
cmBlockCommand \
|
|
cmBreakCommand \
|
|
cmBuildCommand \
|
|
cmCMakeLanguageCommand \
|
|
cmCMakeMinimumRequired \
|
|
cmList \
|
|
cmCMakePath \
|
|
cmCMakePathCommand \
|
|
cmCMakePolicyCommand \
|
|
cmCPackPropertiesGenerator \
|
|
cmCacheManager \
|
|
cmCommand \
|
|
cmCommandArgumentParserHelper \
|
|
cmCommands \
|
|
cmCommonTargetGenerator \
|
|
cmComputeComponentGraph \
|
|
cmComputeLinkDepends \
|
|
cmComputeLinkInformation \
|
|
cmComputeTargetDepends \
|
|
cmConsoleBuf \
|
|
cmConditionEvaluator \
|
|
cmConfigureFileCommand \
|
|
cmContinueCommand \
|
|
cmCoreTryCompile \
|
|
cmCreateTestSourceList \
|
|
cmCryptoHash \
|
|
cmCustomCommand \
|
|
cmCustomCommandGenerator \
|
|
cmCustomCommandLines \
|
|
cmCxxModuleMapper \
|
|
cmCxxModuleUsageEffects \
|
|
cmDefinePropertyCommand \
|
|
cmDefinitions \
|
|
cmDocumentationFormatter \
|
|
cmELF \
|
|
cmEnableLanguageCommand \
|
|
cmEnableTestingCommand \
|
|
cmEvaluatedTargetProperty \
|
|
cmExecProgramCommand \
|
|
cmExecuteProcessCommand \
|
|
cmExpandedCommandArgument \
|
|
cmExperimental \
|
|
cmExportBuildFileGenerator \
|
|
cmExportFileGenerator \
|
|
cmExportInstallFileGenerator \
|
|
cmExportSet \
|
|
cmExportTryCompileFileGenerator \
|
|
cmExprParserHelper \
|
|
cmExternalMakefileProjectGenerator \
|
|
cmFileCommand \
|
|
cmFileCommand_ReadMacho \
|
|
cmFileCopier \
|
|
cmFileInstaller \
|
|
cmFileSet \
|
|
cmFileTime \
|
|
cmFileTimeCache \
|
|
cmFileTimes \
|
|
cmFindBase \
|
|
cmFindCommon \
|
|
cmFindFileCommand \
|
|
cmFindLibraryCommand \
|
|
cmFindPackageCommand \
|
|
cmFindPackageStack \
|
|
cmFindPathCommand \
|
|
cmFindProgramCommand \
|
|
cmForEachCommand \
|
|
cmFunctionBlocker \
|
|
cmFunctionCommand \
|
|
cmFSPermissions \
|
|
cmGeneratedFileStream \
|
|
cmGeneratorExpression \
|
|
cmGeneratorExpressionContext \
|
|
cmGeneratorExpressionDAGChecker \
|
|
cmGeneratorExpressionEvaluationFile \
|
|
cmGeneratorExpressionEvaluator \
|
|
cmGeneratorExpressionLexer \
|
|
cmGeneratorExpressionNode \
|
|
cmGeneratorExpressionParser \
|
|
cmGeneratorTarget \
|
|
cmGeneratorTarget_CompatibleInterface \
|
|
cmGeneratorTarget_IncludeDirectories \
|
|
cmGeneratorTarget_Link \
|
|
cmGeneratorTarget_LinkDirectories \
|
|
cmGeneratorTarget_Options \
|
|
cmGeneratorTarget_Sources \
|
|
cmGeneratorTarget_TargetPropertyEntry \
|
|
cmGeneratorTarget_TransitiveProperty \
|
|
cmGetCMakePropertyCommand \
|
|
cmGetDirectoryPropertyCommand \
|
|
cmGetFilenameComponentCommand \
|
|
cmGetPipes \
|
|
cmGetPropertyCommand \
|
|
cmGetSourceFilePropertyCommand \
|
|
cmGetTargetPropertyCommand \
|
|
cmGetTestPropertyCommand \
|
|
cmGlobalCommonGenerator \
|
|
cmGlobalGenerator \
|
|
cmGlobVerificationManager \
|
|
cmHexFileConverter \
|
|
cmIfCommand \
|
|
cmImportedCxxModuleInfo \
|
|
cmIncludeCommand \
|
|
cmIncludeGuardCommand \
|
|
cmIncludeDirectoryCommand \
|
|
cmIncludeRegularExpressionCommand \
|
|
cmInstallCommand \
|
|
cmInstallCommandArguments \
|
|
cmInstallCxxModuleBmiGenerator \
|
|
cmInstallDirectoryGenerator \
|
|
cmInstallExportGenerator \
|
|
cmInstallFileSetGenerator \
|
|
cmInstallFilesCommand \
|
|
cmInstallFilesGenerator \
|
|
cmInstallGenerator \
|
|
cmInstallGetRuntimeDependenciesGenerator \
|
|
cmInstallImportedRuntimeArtifactsGenerator \
|
|
cmInstallRuntimeDependencySet \
|
|
cmInstallRuntimeDependencySetGenerator \
|
|
cmInstallScriptGenerator \
|
|
cmInstallSubdirectoryGenerator \
|
|
cmInstallTargetGenerator \
|
|
cmInstallTargetsCommand \
|
|
cmInstalledFile \
|
|
cmJSONHelpers \
|
|
cmJSONState \
|
|
cmLDConfigLDConfigTool \
|
|
cmLDConfigTool \
|
|
cmLinkDirectoriesCommand \
|
|
cmLinkItem \
|
|
cmLinkItemGraphVisitor \
|
|
cmLinkLineComputer \
|
|
cmLinkLineDeviceComputer \
|
|
cmListCommand \
|
|
cmListFileCache \
|
|
cmLocalCommonGenerator \
|
|
cmLocalGenerator \
|
|
cmMSVC60LinkLineComputer \
|
|
cmMacroCommand \
|
|
cmMakeDirectoryCommand \
|
|
cmMakefile \
|
|
cmMarkAsAdvancedCommand \
|
|
cmMathCommand \
|
|
cmMessageCommand \
|
|
cmMessenger \
|
|
cmNewLineStyle \
|
|
cmOSXBundleGenerator \
|
|
cmOptionCommand \
|
|
cmOrderDirectories \
|
|
cmOutputConverter \
|
|
cmParseArgumentsCommand \
|
|
cmPathLabel \
|
|
cmPolicies \
|
|
cmProcessOutput \
|
|
cmProjectCommand \
|
|
cmValue \
|
|
cmPropertyDefinition \
|
|
cmPropertyMap \
|
|
cmGccDepfileLexerHelper \
|
|
cmGccDepfileReader \
|
|
cmReturnCommand \
|
|
cmPlaceholderExpander \
|
|
cmPlistParser \
|
|
cmRulePlaceholderExpander \
|
|
cmRuntimeDependencyArchive \
|
|
cmScriptGenerator \
|
|
cmSearchPath \
|
|
cmSeparateArgumentsCommand \
|
|
cmSetCommand \
|
|
cmSetDirectoryPropertiesCommand \
|
|
cmSetPropertyCommand \
|
|
cmSetSourceFilesPropertiesCommand \
|
|
cmSetTargetPropertiesCommand \
|
|
cmSetTestsPropertiesCommand \
|
|
cmSiteNameCommand \
|
|
cmSourceFile \
|
|
cmSourceFileLocation \
|
|
cmStandardLevelResolver \
|
|
cmState \
|
|
cmStateDirectory \
|
|
cmStateSnapshot \
|
|
cmString \
|
|
cmStringAlgorithms \
|
|
cmStringReplaceHelper \
|
|
cmStringCommand \
|
|
cmSubcommandTable \
|
|
cmSubdirCommand \
|
|
cmSystemTools \
|
|
cmTarget \
|
|
cmTargetCompileDefinitionsCommand \
|
|
cmTargetCompileFeaturesCommand \
|
|
cmTargetCompileOptionsCommand \
|
|
cmTargetIncludeDirectoriesCommand \
|
|
cmTargetLinkLibrariesCommand \
|
|
cmTargetLinkOptionsCommand \
|
|
cmTargetPrecompileHeadersCommand \
|
|
cmTargetPropCommandBase \
|
|
cmTargetPropertyComputer \
|
|
cmTargetSourcesCommand \
|
|
cmTargetTraceDependencies \
|
|
cmTest \
|
|
cmTestGenerator \
|
|
cmTimestamp \
|
|
cmTransformDepfile \
|
|
cmTryCompileCommand \
|
|
cmTryRunCommand \
|
|
cmUnsetCommand \
|
|
cmUVHandlePtr \
|
|
cmUVProcessChain \
|
|
cmVersion \
|
|
cmWhileCommand \
|
|
cmWindowsRegistry \
|
|
cmWorkingDirectory \
|
|
cmXcFramework \
|
|
cmake \
|
|
cmakemain \
|
|
cmcmd \
|
|
cm_fileno \
|
|
"
|
|
|
|
if ${cmake_system_darwin}; then
|
|
CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
|
|
cmMachO \
|
|
"
|
|
fi
|
|
|
|
if ${cmake_system_mingw}; then
|
|
CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
|
|
cmGlobalMSYSMakefileGenerator \
|
|
cmGlobalMinGWMakefileGenerator \
|
|
cmVSSetupHelper \
|
|
"
|
|
fi
|
|
|
|
CMAKE_STD_CXX_HEADERS="\
|
|
filesystem \
|
|
memory \
|
|
optional \
|
|
shared_mutex \
|
|
string_view \
|
|
utility \
|
|
"
|
|
CMAKE_STD_CXX_SOURCES="\
|
|
fs_path \
|
|
string_view \
|
|
"
|
|
|
|
LexerParser_CXX_SOURCES="\
|
|
cmCommandArgumentLexer \
|
|
cmCommandArgumentParser \
|
|
cmExprLexer \
|
|
cmExprParser \
|
|
cmGccDepfileLexer \
|
|
"
|
|
|
|
LexerParser_C_SOURCES="\
|
|
cmListFileLexer \
|
|
"
|
|
|
|
if ${cmake_system_mingw}; then
|
|
KWSYS_C_SOURCES="\
|
|
EncodingC \
|
|
ProcessWin32 \
|
|
String \
|
|
System \
|
|
Terminal"
|
|
else
|
|
KWSYS_C_SOURCES="\
|
|
EncodingC \
|
|
ProcessUNIX \
|
|
String \
|
|
System \
|
|
Terminal"
|
|
fi
|
|
|
|
KWSYS_CXX_SOURCES="\
|
|
Directory \
|
|
EncodingCXX \
|
|
FStream \
|
|
Glob \
|
|
RegularExpression \
|
|
Status \
|
|
SystemTools"
|
|
|
|
KWSYS_FILES="\
|
|
Directory.hxx \
|
|
Encoding.h \
|
|
Encoding.hxx \
|
|
FStream.hxx \
|
|
Glob.hxx \
|
|
Process.h \
|
|
RegularExpression.hxx \
|
|
Status.hxx \
|
|
String.h \
|
|
System.h \
|
|
SystemTools.hxx \
|
|
Terminal.h"
|
|
|
|
LIBRHASH_C_SOURCES="\
|
|
librhash/algorithms.c \
|
|
librhash/byte_order.c \
|
|
librhash/hex.c \
|
|
librhash/md5.c \
|
|
librhash/rhash.c \
|
|
librhash/sha1.c \
|
|
librhash/sha256.c \
|
|
librhash/sha3.c \
|
|
librhash/sha512.c \
|
|
librhash/util.c \
|
|
"
|
|
|
|
JSONCPP_CXX_SOURCES="\
|
|
src/lib_json/json_reader.cpp \
|
|
src/lib_json/json_value.cpp \
|
|
src/lib_json/json_writer.cpp \
|
|
"
|
|
|
|
if ${cmake_system_mingw}; then
|
|
LIBUV_C_SOURCES="\
|
|
src/fs-poll.c \
|
|
src/idna.c
|
|
src/inet.c \
|
|
src/threadpool.c \
|
|
src/strscpy.c \
|
|
src/strtok.c \
|
|
src/timer.c \
|
|
src/uv-common.c \
|
|
src/win/async.c \
|
|
src/win/core.c \
|
|
src/win/detect-wakeup.c \
|
|
src/win/dl.c \
|
|
src/win/error.c \
|
|
src/win/fs-event.c \
|
|
src/win/fs.c \
|
|
src/win/getaddrinfo.c \
|
|
src/win/getnameinfo.c \
|
|
src/win/handle.c \
|
|
src/win/loop-watcher.c \
|
|
src/win/pipe.c \
|
|
src/win/poll.c \
|
|
src/win/process-stdio.c \
|
|
src/win/process.c \
|
|
src/win/signal.c \
|
|
src/win/stream.c \
|
|
src/win/tcp.c \
|
|
src/win/thread.c \
|
|
src/win/tty.c \
|
|
src/win/udp.c \
|
|
src/win/util.c \
|
|
src/win/winapi.c \
|
|
src/win/winsock.c \
|
|
"
|
|
else
|
|
LIBUV_C_SOURCES="\
|
|
src/strscpy.c \
|
|
src/strtok.c \
|
|
src/timer.c \
|
|
src/uv-common.c \
|
|
src/unix/cmake-bootstrap.c \
|
|
src/unix/core.c \
|
|
src/unix/fs.c \
|
|
src/unix/loop.c \
|
|
src/unix/loop-watcher.c \
|
|
src/unix/no-fsevents.c \
|
|
src/unix/pipe.c \
|
|
src/unix/poll.c \
|
|
src/unix/posix-hrtime.c \
|
|
src/unix/posix-poll.c \
|
|
src/unix/process.c \
|
|
src/unix/signal.c \
|
|
src/unix/stream.c \
|
|
src/unix/tcp.c \
|
|
src/unix/tty.c \
|
|
"
|
|
fi
|
|
|
|
# Display CMake bootstrap usage
|
|
cmake_usage()
|
|
{
|
|
echo '
|
|
Usage: '"$0"' [<options>...] [-- <cmake-options>...]
|
|
Options: [defaults in brackets after descriptions]
|
|
Configuration:
|
|
--help print this message
|
|
--version only print version information
|
|
--verbose display more information
|
|
--parallel=n bootstrap cmake in parallel, where n is
|
|
number of nodes [1]
|
|
--generator=<generator> generator to use (MSYS Makefiles, Unix Makefiles,
|
|
or Ninja)
|
|
--enable-ccache Enable ccache when building cmake
|
|
--init=FILE load FILE as script to populate cache
|
|
--system-libs use all system-installed third-party libraries
|
|
(for use only by package maintainers)
|
|
--no-system-libs use all cmake-provided third-party libraries
|
|
(default)
|
|
--system-cppdap use system-installed cppdap library
|
|
--no-system-cppdap use cmake-provided cppdap library (default)
|
|
--system-curl use system-installed curl library (default on macOS)
|
|
--no-system-curl use cmake-provided curl library (default elsewhere)
|
|
--system-expat use system-installed expat library
|
|
--no-system-expat use cmake-provided expat library (default)
|
|
--system-jsoncpp use system-installed jsoncpp library
|
|
--no-system-jsoncpp use cmake-provided jsoncpp library (default)
|
|
--system-zlib use system-installed zlib library
|
|
--no-system-zlib use cmake-provided zlib library (default)
|
|
--system-bzip2 use system-installed bzip2 library
|
|
--no-system-bzip2 use cmake-provided bzip2 library (default)
|
|
--system-liblzma use system-installed liblzma library
|
|
--no-system-liblzma use cmake-provided liblzma library (default)
|
|
--system-nghttp2 use system-installed nghttp2 library
|
|
--no-system-nghttp2 use cmake-provided nghttp2 library (default)
|
|
--system-zstd use system-installed zstd library
|
|
--no-system-zstd use cmake-provided zstd library (default)
|
|
--system-libarchive use system-installed libarchive library
|
|
--no-system-libarchive use cmake-provided libarchive library (default)
|
|
--system-librhash use system-installed librhash library
|
|
--no-system-librhash use cmake-provided librhash library (default)
|
|
--system-libuv use system-installed libuv library
|
|
--no-system-libuv use cmake-provided libuv library (default)
|
|
|
|
--bootstrap-system-libuv use system-installed libuv library for bootstrap
|
|
--bootstrap-system-jsoncpp use system-installed jsoncpp library for bootstrap
|
|
--bootstrap-system-librhash use system-installed librhash library for bootstrap
|
|
|
|
--qt-gui build the Qt-based GUI (requires Qt >= 4.2)
|
|
--no-qt-gui do not build the Qt-based GUI (default)
|
|
--qt-qmake=<qmake> use <qmake> as the qmake executable to find Qt
|
|
|
|
--debugger enable debugger support (default if supported)
|
|
--no-debugger disable debugger support
|
|
|
|
--sphinx-info build Info manual with Sphinx
|
|
--sphinx-man build man pages with Sphinx
|
|
--sphinx-html build html help with Sphinx
|
|
--sphinx-qthelp build qch help with Sphinx
|
|
--sphinx-latexpdf build PDF with Sphinx using LaTeX
|
|
--sphinx-build=<sb> use <sb> as the sphinx-build executable
|
|
--sphinx-flags=<flags> pass <flags> to sphinx-build executable
|
|
|
|
Directory and file names:
|
|
--prefix=PREFIX install files in tree rooted at PREFIX
|
|
['"${cmake_default_prefix}"']
|
|
--bindir=DIR install binaries in PREFIX/DIR
|
|
['"${cmake_bin_dir_default}"']
|
|
--datadir=DIR install data files in PREFIX/DIR
|
|
['"${cmake_data_dir_default}"']
|
|
--docdir=DIR install documentation files in PREFIX/DIR
|
|
['"${cmake_doc_dir_default}"']
|
|
--mandir=DIR install man pages files in PREFIX/DIR/manN
|
|
['"${cmake_man_dir_default}"']
|
|
--xdgdatadir=DIR install XDG specific files in PREFIX/DIR
|
|
['"${cmake_xdgdata_dir_default}"']
|
|
'
|
|
exit 10
|
|
}
|
|
|
|
# Display CMake bootstrap usage
|
|
cmake_version_display()
|
|
{
|
|
echo "CMake ${cmake_version}, ${cmake_copyright}"
|
|
}
|
|
|
|
# Display CMake bootstrap error, display the log file and exit
|
|
cmake_error()
|
|
{
|
|
res=$1
|
|
shift 1
|
|
echo "---------------------------------------------"
|
|
echo "Error when bootstrapping CMake:"
|
|
echo "$*"
|
|
echo "---------------------------------------------"
|
|
if test -f cmake_bootstrap.log; then
|
|
echo "Log of errors: `pwd`/cmake_bootstrap.log"
|
|
#cat cmake_bootstrap.log
|
|
echo "---------------------------------------------"
|
|
fi
|
|
exit ${res}
|
|
}
|
|
|
|
cmake_generate_file_tmp ()
|
|
{
|
|
OUTFILE="$1"
|
|
TMPFILE="$2"
|
|
if "${_diff}" "$TMPFILE" "$OUTFILE" > /dev/null 2> /dev/null ; then
|
|
rm -f "$TMPFILE"
|
|
else
|
|
mv -f "$TMPFILE" "$OUTFILE"
|
|
fi
|
|
}
|
|
|
|
cmake_generate_file ()
|
|
{
|
|
OUTFILE="$1"
|
|
CONTENT="$2"
|
|
echo "$CONTENT" > "$OUTFILE.tmp"
|
|
cmake_generate_file_tmp "$OUTFILE" "$OUTFILE.tmp"
|
|
}
|
|
|
|
# Replace KWSYS_NAMESPACE with cmsys
|
|
cmake_replace_string ()
|
|
{
|
|
INFILE="$1"
|
|
OUTFILE="$2"
|
|
SEARCHFOR="$3"
|
|
REPLACEWITH="$4"
|
|
if test -f "${INFILE}" || ${cmake_system_openvms}; then
|
|
sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}"
|
|
if test -f "${OUTFILE}${_tmp}"; then
|
|
if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
|
|
#echo "Files are the same"
|
|
rm -f "${OUTFILE}${_tmp}"
|
|
else
|
|
mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
|
|
fi
|
|
fi
|
|
else
|
|
cmake_error 1 "Cannot find file ${INFILE}"
|
|
fi
|
|
}
|
|
|
|
cmake_kwsys_config_replace_string ()
|
|
{
|
|
INFILE="$1"
|
|
OUTFILE="$2"
|
|
shift 2
|
|
APPEND="$*"
|
|
if test -f "${INFILE}" || ${cmake_system_openvms}; then
|
|
echo "${APPEND}" > "${OUTFILE}${_tmp}"
|
|
sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g;
|
|
s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/g;
|
|
s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g;
|
|
s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g;
|
|
s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g;
|
|
s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g;
|
|
s/@KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/g;
|
|
s/@KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP@/${KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP}/g;
|
|
}" "${INFILE}" >> "${OUTFILE}${_tmp}"
|
|
if test -f "${OUTFILE}${_tmp}"; then
|
|
if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
|
|
#echo "Files are the same"
|
|
rm -f "${OUTFILE}${_tmp}"
|
|
else
|
|
mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
|
|
fi
|
|
fi
|
|
else
|
|
cmake_error 2 "Cannot find file ${INFILE}"
|
|
fi
|
|
}
|
|
# Write string into a file
|
|
cmake_report ()
|
|
{
|
|
FILE=$1
|
|
shift
|
|
echo "$*" >> ${FILE}
|
|
}
|
|
|
|
# Escape spaces in strings for artifacts
|
|
cmake_escape_artifact ()
|
|
{
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
echo $1 | sed "s/ /$ /g"
|
|
else
|
|
echo $1 | sed "s/ /\\\\ /g"
|
|
fi
|
|
}
|
|
|
|
# Escape spaces in strings for shell
|
|
cmake_escape_shell ()
|
|
{
|
|
echo $1 | sed "s/ /\\\\ /g"
|
|
}
|
|
|
|
# Encode object file names.
|
|
cmake_obj ()
|
|
{
|
|
echo $1 | sed 's/\//-/g' | sed 's/$/\.o/'
|
|
}
|
|
|
|
# Strip prefix from argument
|
|
cmake_arg ()
|
|
{
|
|
echo "$1" | sed "s/^${2-[^=]*=}//"
|
|
}
|
|
|
|
# Write message to the log
|
|
cmake_log ()
|
|
{
|
|
echo "$*" >> cmake_bootstrap.log
|
|
}
|
|
|
|
# Return temp file
|
|
cmake_tmp_file ()
|
|
{
|
|
echo "cmake_bootstrap_$$_test"
|
|
}
|
|
|
|
# Run a compiler test. First argument is compiler, second one are compiler
|
|
# flags, third one is test source file to be compiled
|
|
cmake_try_run ()
|
|
{
|
|
COMPILER=$1
|
|
FLAGS=$2
|
|
TESTFILE=$3
|
|
if test ! -f "${TESTFILE}"; then
|
|
echo "Test file ${TESTFILE} missing. Please verify your CMake source tree."
|
|
exit 4
|
|
fi
|
|
TMPFILE=`cmake_tmp_file`
|
|
echo "Try: ${COMPILER}"
|
|
echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}"
|
|
echo "---------- file -----------------------"
|
|
cat "${TESTFILE}"
|
|
echo "------------------------------------------"
|
|
${COMPILER} ${FLAGS} "${TESTFILE}" -o "${TMPFILE}"
|
|
RES=$?
|
|
if test "${RES}" -ne "0"; then
|
|
echo "Test failed to compile"
|
|
return 1
|
|
fi
|
|
if test ! -f "${TMPFILE}" && test ! -f "${TMPFILE}.exe"; then
|
|
echo "Test failed to produce executable"
|
|
return 2
|
|
fi
|
|
./${TMPFILE}
|
|
RES=$?
|
|
rm -f "${TMPFILE}"
|
|
if test "${RES}" -ne "0"; then
|
|
echo "Test produced non-zero return code"
|
|
return 3
|
|
fi
|
|
echo "Test succeeded"
|
|
return 0
|
|
}
|
|
|
|
# Run a make test. First argument is the make interpreter.
|
|
cmake_try_make ()
|
|
{
|
|
MAKE_PROC="$1"
|
|
MAKE_FLAGS="$2"
|
|
echo "Try: ${MAKE_PROC}"
|
|
"${MAKE_PROC}" ${MAKE_FLAGS}
|
|
RES=$?
|
|
if test "${RES}" -ne "0"; then
|
|
echo "${MAKE_PROC} does not work"
|
|
return 1
|
|
fi
|
|
if test ! -f "test" && test ! -f "test.exe"; then
|
|
echo "${COMPILER} does not produce output"
|
|
return 2
|
|
fi
|
|
./test
|
|
RES=$?
|
|
rm -f "test"
|
|
if test "${RES}" -ne "0"; then
|
|
echo "${MAKE_PROC} produces strange executable"
|
|
return 3
|
|
fi
|
|
echo "${MAKE_PROC} works"
|
|
return 0
|
|
}
|
|
|
|
# Parse arguments
|
|
cmake_verbose=
|
|
cmake_parallel_make=
|
|
cmake_ccache_enabled=
|
|
cmake_prefix_dir="${cmake_default_prefix}"
|
|
bootstrap_system_libuv=
|
|
bootstrap_system_jsoncpp=
|
|
bootstrap_system_librhash=
|
|
while test $# != 0; do
|
|
case "$1" in
|
|
--prefix=*) dir=`cmake_arg "$1"`
|
|
cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;;
|
|
--parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;;
|
|
--generator=*) cmake_bootstrap_generator=`cmake_arg "$1"` ;;
|
|
--bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;;
|
|
--datadir=*) cmake_data_dir=`cmake_arg "$1"` ;;
|
|
--docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;;
|
|
--mandir=*) cmake_man_dir=`cmake_arg "$1"` ;;
|
|
--xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;;
|
|
--init=*) cmake_init_file=`cmake_arg "$1"` ;;
|
|
--system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=1" ;;
|
|
--no-system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=0" ;;
|
|
--system-bzip2|--system-cppdap|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma|--system-nghttp2|--system-zstd|--system-libuv)
|
|
lib=`cmake_arg "$1" "--system-"`
|
|
cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;;
|
|
--no-system-bzip2|--no-system-cppdap|--no-system-curl|--no-system-expat|--no-system-jsoncpp|--no-system-libarchive|--no-system-librhash|--no-system-zlib|--no-system-liblzma|--no-system-nghttp2|--no-system-zstd|--no-system-libuv)
|
|
lib=`cmake_arg "$1" "--no-system-"`
|
|
cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;;
|
|
--bootstrap-system-libuv) bootstrap_system_libuv="1" ;;
|
|
--bootstrap-system-jsoncpp) bootstrap_system_jsoncpp="1" ;;
|
|
--bootstrap-system-librhash) bootstrap_system_librhash="1" ;;
|
|
--qt-gui) cmake_bootstrap_qt_gui="1" ;;
|
|
--no-qt-gui) cmake_bootstrap_qt_gui="0" ;;
|
|
--qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;;
|
|
--debugger) cmake_bootstrap_debugger="1" ;;
|
|
--no-debugger) cmake_bootstrap_debugger="0" ;;
|
|
--sphinx-info) cmake_sphinx_info="1" ;;
|
|
--sphinx-man) cmake_sphinx_man="1" ;;
|
|
--sphinx-html) cmake_sphinx_html="1" ;;
|
|
--sphinx-qthelp) cmake_sphinx_qthelp="1" ;;
|
|
--sphinx-latexpdf) cmake_sphinx_latexpdf="1" ;;
|
|
--sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;;
|
|
--sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;;
|
|
--help) cmake_usage ;;
|
|
--version) cmake_version_display ; exit 2 ;;
|
|
--verbose) cmake_verbose=TRUE ;;
|
|
--enable-ccache) cmake_ccache_enabled=TRUE ;;
|
|
CC=*) CC=`cmake_arg "$1"` ;;
|
|
CXX=*) CXX=`cmake_arg "$1"` ;;
|
|
CFLAGS=*) CFLAGS=`cmake_arg "$1"` ;;
|
|
CXXFLAGS=*) CXXFLAGS=`cmake_arg "$1"` ;;
|
|
LDFLAGS=*) LDFLAGS=`cmake_arg "$1"` ;;
|
|
--) shift; break ;;
|
|
*) die "Unknown option: $1" ;;
|
|
esac
|
|
shift
|
|
done
|
|
|
|
# Make sure the generator is valid
|
|
case "${cmake_bootstrap_generator}" in
|
|
'MSYS Makefiles'|'Unix Makefiles'|'Ninja') ;;
|
|
*) cmake_error 10 "Invalid generator: ${cmake_bootstrap_generator}"
|
|
esac
|
|
|
|
# If verbose, display some information about bootstrap
|
|
if test -n "${cmake_verbose}"; then
|
|
echo "---------------------------------------------"
|
|
echo "Source directory: ${cmake_source_dir}"
|
|
echo "Binary directory: ${cmake_binary_dir}"
|
|
echo "Prefix directory: ${cmake_prefix_dir}"
|
|
echo "System: ${cmake_system}"
|
|
echo "Generator: ${cmake_bootstrap_generator}"
|
|
if test "x${cmake_parallel_make}" != "x"; then
|
|
echo "Doing parallel make: ${cmake_parallel_make}"
|
|
fi
|
|
echo ""
|
|
fi
|
|
|
|
echo "---------------------------------------------"
|
|
# Get CMake version
|
|
echo "`cmake_version_display`"
|
|
|
|
# Check for in-source build
|
|
cmake_in_source_build=
|
|
if test -f "${cmake_binary_dir}/Source/cmake.cxx" &&
|
|
test -f "${cmake_binary_dir}/Source/cmake.h"; then
|
|
if test -n "${cmake_verbose}"; then
|
|
echo "Warning: This is an in-source build"
|
|
fi
|
|
cmake_in_source_build=TRUE
|
|
fi
|
|
|
|
# If this is not an in-source build, then Bootstrap stuff should not exist.
|
|
if test -z "${cmake_in_source_build}"; then
|
|
# Did somebody bootstrap in the source tree?
|
|
if test -d "${cmake_source_dir}/Bootstrap${_cmk}"; then
|
|
cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\".
|
|
Looks like somebody did bootstrap CMake in the source tree, but now you are
|
|
trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk}
|
|
directory from the source tree."
|
|
fi
|
|
# Is there a cache in the source tree?
|
|
for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do
|
|
if test -f "${cmake_source_dir}/${cmake_problematic_file}"; then
|
|
cmake_error 10 "Found \"${cmake_source_dir}/${cmake_problematic_file}\".
|
|
Looks like somebody tried to build CMake in the source tree, but now you are
|
|
trying to do bootstrap in the binary tree. Please remove \"${cmake_problematic_file}\"
|
|
from the source tree."
|
|
fi
|
|
done
|
|
fi
|
|
|
|
# Make bootstrap directory
|
|
test -d "${cmake_bootstrap_dir}" || mkdir "${cmake_bootstrap_dir}"
|
|
if test ! -d "${cmake_bootstrap_dir}"; then
|
|
cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake."
|
|
fi
|
|
cd "${cmake_bootstrap_dir}"
|
|
|
|
test -d "cmsys" || mkdir "cmsys"
|
|
if test ! -d "cmsys"; then
|
|
cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys"
|
|
fi
|
|
|
|
# Delete all the bootstrap files
|
|
rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log"
|
|
rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}"
|
|
rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}"
|
|
|
|
# If building in-source, remove any cmConfigure.h that may
|
|
# have been created by a previous run of the bootstrap cmake.
|
|
if test -n "${cmake_in_source_build}"; then
|
|
rm -f "${cmake_source_dir}/Source/cmConfigure.h"
|
|
fi
|
|
|
|
# If exist compiler flags, set them
|
|
cmake_c_flags=${CFLAGS}
|
|
cmake_cxx_flags=${CXXFLAGS}
|
|
cmake_ld_flags=${LDFLAGS}
|
|
|
|
# Add generator-specific files
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
|
|
cmFortranParserImpl \
|
|
cmGlobalNinjaGenerator \
|
|
cmLocalNinjaGenerator \
|
|
cmNinjaLinkLineComputer \
|
|
cmNinjaLinkLineDeviceComputer \
|
|
cmNinjaNormalTargetGenerator \
|
|
cmNinjaTargetGenerator \
|
|
cmNinjaUtilityTargetGenerator \
|
|
"
|
|
|
|
LexerParser_CXX_SOURCES="${LexerParser_CXX_SOURCES} \
|
|
cmFortranLexer \
|
|
cmFortranParser \
|
|
"
|
|
else
|
|
CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
|
|
cmDepends \
|
|
cmDependsC \
|
|
cmDependsCompiler \
|
|
cmGlobalUnixMakefileGenerator3 \
|
|
cmLocalUnixMakefileGenerator3 \
|
|
cmMakefileExecutableTargetGenerator \
|
|
cmMakefileLibraryTargetGenerator \
|
|
cmMakefileTargetGenerator \
|
|
cmMakefileUtilityTargetGenerator \
|
|
cmProcessTools \
|
|
"
|
|
fi
|
|
|
|
# Add Cygwin-specific flags
|
|
if ${cmake_system_cygwin} || ${cmake_system_msys}; then
|
|
cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import"
|
|
fi
|
|
|
|
# Add CoreFoundation framework on Darwin
|
|
if ${cmake_system_darwin}; then
|
|
cmake_ld_flags="${LDFLAGS} -framework CoreFoundation"
|
|
fi
|
|
|
|
# Add BeOS toolkits...
|
|
if ${cmake_system_beos}; then
|
|
cmake_ld_flags="${LDFLAGS} -lroot -lbe"
|
|
fi
|
|
|
|
# Add Haiku toolkits...
|
|
if ${cmake_system_haiku}; then
|
|
cmake_ld_flags="${LDFLAGS} -lroot -lbe"
|
|
fi
|
|
|
|
# Add AIX arch-specific link flags.
|
|
if ${cmake_system_aix}; then
|
|
if uname -p | grep powerpc >/dev/null 2>&1; then
|
|
cmake_ld_flags="${LDFLAGS} -Wl,-bbigtoc"
|
|
fi
|
|
fi
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Detect known toolchains on some platforms.
|
|
cmake_toolchains=''
|
|
case "${cmake_system}" in
|
|
*AIX*) cmake_toolchains='XL GNU' ;;
|
|
*CYGWIN*) cmake_toolchains='GNU' ;;
|
|
*MSYS*) cmake_toolchains='GNU' ;;
|
|
*Darwin*) cmake_toolchains='Clang GNU' ;;
|
|
*Linux*) cmake_toolchains='GNU Clang XL PGI PathScale' ;;
|
|
*MINGW*) cmake_toolchains='GNU' ;;
|
|
esac
|
|
|
|
# Toolchain compiler name table.
|
|
cmake_toolchain_Clang_CC='clang'
|
|
cmake_toolchain_Clang_CXX='clang++'
|
|
cmake_toolchain_GNU_CC='gcc'
|
|
cmake_toolchain_GNU_CXX='g++'
|
|
cmake_toolchain_PGI_CC='pgcc'
|
|
cmake_toolchain_PGI_CXX='pgCC'
|
|
cmake_toolchain_PathScale_CC='pathcc'
|
|
cmake_toolchain_PathScale_CXX='pathCC'
|
|
cmake_toolchain_XL_CC='xlc'
|
|
cmake_toolchain_XL_CXX='xlC'
|
|
|
|
cmake_toolchain_try()
|
|
{
|
|
tc="$1"
|
|
TMPFILE=`cmake_tmp_file`
|
|
|
|
eval "tc_CC=\${cmake_toolchain_${tc}_CC}"
|
|
echo 'int main() { return 0; }' > "${TMPFILE}.c"
|
|
cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1
|
|
tc_result_CC="$?"
|
|
rm -f "${TMPFILE}.c"
|
|
test "${tc_result_CC}" = "0" || return 1
|
|
|
|
eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}"
|
|
echo 'int main() { return 0; }' > "${TMPFILE}.cpp"
|
|
cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1
|
|
tc_result_CXX="$?"
|
|
rm -f "${TMPFILE}.cpp"
|
|
test "${tc_result_CXX}" = "0" || return 1
|
|
|
|
cmake_toolchain="$tc"
|
|
}
|
|
|
|
cmake_toolchain_detect()
|
|
{
|
|
cmake_toolchain=
|
|
for tc in ${cmake_toolchains}; do
|
|
echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1
|
|
cmake_toolchain_try "$tc" &&
|
|
echo "Found $tc toolchain" &&
|
|
break
|
|
done
|
|
}
|
|
|
|
if test -z "${CC}" && test -z "${CXX}"; then
|
|
cmake_toolchain_detect
|
|
fi
|
|
|
|
thread_flags=''
|
|
case "${cmake_system}" in
|
|
*AIX*) thread_flags='-pthread' ;;
|
|
esac
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Test C compiler
|
|
cmake_c_compiler=
|
|
|
|
# If CC is set, use that for compiler, otherwise use list of known compilers
|
|
if test -n "${cmake_toolchain}"; then
|
|
eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}"
|
|
else
|
|
cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}"
|
|
fi
|
|
|
|
cmake_c_compiler_try_set()
|
|
{
|
|
test_compiler="$1"
|
|
test_thread_flags="$2"
|
|
|
|
# Check if C compiler works
|
|
TMPFILE=`cmake_tmp_file`
|
|
echo '
|
|
#ifdef __cplusplus
|
|
# error "The CMAKE_C_COMPILER is set to a C++ compiler"
|
|
#endif
|
|
|
|
#if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
|
|
#error "On AIX with GNU we need the -pthread flag."
|
|
#endif
|
|
|
|
#if defined(__sun) && __STDC_VERSION__ < 199901L
|
|
#error "On Solaris we need C99."
|
|
#endif
|
|
|
|
#if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
|
|
#error "On HP-UX we need GCC 4.9 or higher."
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
|
|
int main(int argc, char* argv[])
|
|
{
|
|
printf("%d%c", (argv != 0), (char)0x0a);
|
|
return argc - 1;
|
|
}
|
|
' > "${TMPFILE}.c"
|
|
for std in 11 99 90; do
|
|
std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`"
|
|
for std_flag in '' $std_flags; do
|
|
for thread_flag in '' $test_thread_flags; do
|
|
echo "Checking whether '${test_compiler} ${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
|
|
if cmake_try_run "${test_compiler}" "${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \
|
|
"${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then
|
|
cmake_c_compiler="${test_compiler}"
|
|
cmake_c_flags="${cmake_c_flags} ${std_flag} ${thread_flag}"
|
|
rm -f "${TMPFILE}.c"
|
|
return 0
|
|
fi
|
|
done
|
|
done
|
|
done
|
|
rm -f "${TMPFILE}.c"
|
|
return 1
|
|
}
|
|
|
|
if test -n "${CC}"; then
|
|
cmake_c_compiler_try_set "${CC}" "${thread_flags}"
|
|
else
|
|
for compiler in ${cmake_c_compilers}; do
|
|
if cmake_c_compiler_try_set "${compiler}" "${thread_flags}"; then
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if test -z "${cmake_c_compiler}"; then
|
|
cmake_error 6 "Cannot find appropriate C compiler on this system.
|
|
Please specify one using environment variable CC.
|
|
See cmake_bootstrap.log for compilers attempted.
|
|
"
|
|
fi
|
|
echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}"
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Test CXX compiler
|
|
cmake_cxx_compiler=
|
|
|
|
# On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler.
|
|
|
|
# If CC is set, use that for compiler, otherwise use list of known compilers
|
|
if test -n "${cmake_toolchain}"; then
|
|
eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}"
|
|
else
|
|
cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}"
|
|
fi
|
|
|
|
# Check if C++ compiler works
|
|
cmake_cxx_compiler_try_set()
|
|
{
|
|
test_compiler="$1"
|
|
test_thread_flags="$2"
|
|
|
|
TMPFILE=`cmake_tmp_file`
|
|
echo '
|
|
#include <iostream>
|
|
#include <memory>
|
|
#include <unordered_map>
|
|
|
|
#if __cplusplus < 201103L
|
|
#error "Compiler is not in a mode aware of C++11."
|
|
#endif
|
|
|
|
#if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
|
|
#error "On AIX with GNU we need the -pthread flag."
|
|
#endif
|
|
|
|
#if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5140
|
|
#error "SunPro <= 5.13 mode not supported due to bug in move semantics."
|
|
#endif
|
|
|
|
#if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
|
|
#error "On HP-UX we need GCC 4.9 or higher."
|
|
#endif
|
|
|
|
#if __cplusplus > 201103L
|
|
#include <iterator>
|
|
int check_cxx14()
|
|
{
|
|
int a[] = { 0, 1, 2 };
|
|
auto ai = std::cbegin(a);
|
|
|
|
int b[] = { 2, 1, 0 };
|
|
auto bi = std::cend(b);
|
|
|
|
return *ai + *(bi - 1);
|
|
}
|
|
#else
|
|
int check_cxx14()
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#if (__cplusplus >= 201703L || defined(__INTEL_COMPILER) && defined(__cpp_deduction_guides))
|
|
#include <optional>
|
|
template <typename T,
|
|
typename std::invoke_result<decltype(&T::get), T>::type = nullptr>
|
|
typename T::pointer get_ptr(T& item)
|
|
{
|
|
return item.get();
|
|
}
|
|
|
|
int check_cxx17()
|
|
{
|
|
// Intel compiler do not handle correctly 'decltype' inside 'invoke_result'
|
|
std::unique_ptr<int> u(new int(0));
|
|
get_ptr(u);
|
|
std::optional<int> oi = 0;
|
|
return oi.value();
|
|
}
|
|
#else
|
|
int check_cxx17()
|
|
{
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
class Class
|
|
{
|
|
public:
|
|
int Get() const { return this->Member; }
|
|
private:
|
|
int Member = 1;
|
|
};
|
|
int main()
|
|
{
|
|
auto const c = std::unique_ptr<Class>(new Class);
|
|
std::cout << c->Get() << check_cxx14() << check_cxx17() << std::endl;
|
|
return 0;
|
|
}
|
|
' > "${TMPFILE}.cxx"
|
|
for std in 17 14 11; do
|
|
std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" CXX \"${std}\"`"
|
|
for std_flag in '' $std_flags; do
|
|
for thread_flag in '' $test_thread_flags; do
|
|
echo "Checking whether '${test_compiler} ${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
|
|
if cmake_try_run "${test_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \
|
|
"${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
cmake_cxx_compiler="${test_compiler}"
|
|
cmake_cxx_flags="${cmake_cxx_flags} ${std_flag} ${thread_flag} "
|
|
rm -f "${TMPFILE}.cxx"
|
|
return 0
|
|
fi
|
|
done
|
|
done
|
|
done
|
|
rm -f "${TMPFILE}.cxx"
|
|
return 1
|
|
}
|
|
|
|
if test -n "${CXX}"; then
|
|
cmake_cxx_compiler_try_set "${CXX}" "${thread_flags}"
|
|
else
|
|
for compiler in ${cmake_cxx_compilers}; do
|
|
if cmake_cxx_compiler_try_set "${compiler}" "${thread_flags}"; then
|
|
break
|
|
fi
|
|
done
|
|
fi
|
|
|
|
if test -z "${cmake_cxx_compiler}"; then
|
|
cmake_error 7 "Cannot find a C++ compiler that supports both C++11 and the specified C++ flags.
|
|
Please specify one using environment variable CXX.
|
|
The C++ flags are \"$cmake_cxx_flags\".
|
|
They can be changed using the environment variable CXXFLAGS.
|
|
See cmake_bootstrap.log for compilers attempted."
|
|
fi
|
|
echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}"
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Test CXX features
|
|
|
|
cmake_cxx_features="make_unique filesystem"
|
|
|
|
for feature in ${cmake_cxx_features}; do
|
|
eval "cmake_have_cxx_${feature}=0"
|
|
echo "Checking whether '${cmake_cxx_compiler} ${cmake_cxx_flags} ${cmake_ld_flags}' supports '${feature}'." >> cmake_bootstrap.log 2>&1
|
|
if cmake_try_run "${cmake_cxx_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags}" \
|
|
"${cmake_source_dir}/Source/Checks/cm_cxx_${feature}.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
eval "cmake_have_cxx_${feature}=1"
|
|
fi
|
|
done
|
|
|
|
cmake_have_cxx_features=""
|
|
for feature in ${cmake_cxx_features}; do
|
|
feature_variable="cmake_have_cxx_${feature}"
|
|
eval "feature_value=\${${feature_variable}}"
|
|
if test "${feature_value}" -eq "1"; then
|
|
cmake_have_cxx_features="${cmake_have_cxx_features} -DCMake_HAVE_CXX_`cmake_toupper ${feature}`=${feature_value}"
|
|
fi
|
|
done
|
|
|
|
cmake_generate_file "${cmake_bootstrap_dir}/cmSTL.hxx" ""
|
|
|
|
|
|
#-----------------------------------------------------------------------------
|
|
# Test Make
|
|
|
|
cmake_make_processor=
|
|
cmake_make_flags=
|
|
|
|
# If MAKE is set, use that for make processor, otherwise use list of known make
|
|
if test -n "${MAKE}"; then
|
|
cmake_make_processors="${MAKE}"
|
|
elif test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
cmake_make_processors="${CMAKE_KNOWN_NINJA_PROCESSORS}"
|
|
else
|
|
cmake_make_processors="${CMAKE_KNOWN_MAKE_PROCESSORS}"
|
|
fi
|
|
|
|
TMPFILE="`cmake_tmp_file`_dir"
|
|
rm -rf "${cmake_bootstrap_dir}/${TMPFILE}"
|
|
mkdir "${cmake_bootstrap_dir}/${TMPFILE}"
|
|
cd "${cmake_bootstrap_dir}/${TMPFILE}"
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
echo '
|
|
rule cc
|
|
command = '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o $out $in
|
|
build test: cc test.c
|
|
'>"build.ninja"
|
|
else
|
|
echo '
|
|
test: test.c
|
|
'"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c
|
|
'>"Makefile"
|
|
fi
|
|
echo '
|
|
#include <stdio.h>
|
|
int main(){ printf("1%c", (char)0x0a); return 0; }
|
|
' > "test.c"
|
|
cmake_original_make_flags="${cmake_make_flags}"
|
|
if test "x${cmake_parallel_make}" != "x"; then
|
|
cmake_make_flags="${cmake_make_flags} -j ${cmake_parallel_make}"
|
|
fi
|
|
for a in ${cmake_make_processors}; do
|
|
if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then
|
|
cmake_make_processor="${a}"
|
|
fi
|
|
done
|
|
cmake_full_make_flags="${cmake_make_flags}"
|
|
if test "x${cmake_original_make_flags}" != "x${cmake_make_flags}"; then
|
|
if test -z "${cmake_make_processor}"; then
|
|
cmake_make_flags="${cmake_original_make_flags}"
|
|
for a in ${cmake_make_processors}; do
|
|
if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then
|
|
cmake_make_processor="${a}"
|
|
fi
|
|
done
|
|
fi
|
|
fi
|
|
cd "${cmake_bootstrap_dir}"
|
|
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
mf_str=Ninja
|
|
else
|
|
mf_str=Makefile
|
|
fi
|
|
if test -z "${cmake_make_processor}"; then
|
|
cmake_error 8 "Cannot find appropriate ${mf_str} processor on this system.
|
|
Please specify one using environment variable MAKE."
|
|
fi
|
|
rm -rf "${cmake_bootstrap_dir}/${TMPFILE}"
|
|
echo "${mf_str} processor on this system is: ${cmake_make_processor}"
|
|
if test "x${cmake_full_make_flags}" != "x${cmake_make_flags}"; then
|
|
echo "---------------------------------------------"
|
|
echo "${mf_str} processor ${cmake_make_processor} does not support parallel build"
|
|
echo "---------------------------------------------"
|
|
fi
|
|
|
|
# Test for kwsys features
|
|
KWSYS_NAME_IS_KWSYS=0
|
|
KWSYS_BUILD_SHARED=0
|
|
KWSYS_LFS_AVAILABLE=0
|
|
KWSYS_LFS_REQUESTED=0
|
|
KWSYS_STL_HAS_WSTRING=0
|
|
KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=0
|
|
KWSYS_CXX_HAS_SETENV=0
|
|
KWSYS_CXX_HAS_UNSETENV=0
|
|
KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0
|
|
KWSYS_CXX_HAS_UTIMENSAT=0
|
|
KWSYS_CXX_HAS_UTIMES=0
|
|
KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP=1
|
|
|
|
if cmake_try_run "${cmake_cxx_compiler}" \
|
|
"${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_SETENV" \
|
|
"${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
KWSYS_CXX_HAS_SETENV=1
|
|
echo "${cmake_cxx_compiler} has setenv"
|
|
else
|
|
echo "${cmake_cxx_compiler} does not have setenv"
|
|
fi
|
|
|
|
if cmake_try_run "${cmake_cxx_compiler}" \
|
|
"${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_UNSETENV" \
|
|
"${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
KWSYS_CXX_HAS_UNSETENV=1
|
|
echo "${cmake_cxx_compiler} has unsetenv"
|
|
else
|
|
echo "${cmake_cxx_compiler} does not have unsetenv"
|
|
fi
|
|
|
|
if cmake_try_run "${cmake_cxx_compiler}" \
|
|
"${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H" \
|
|
"${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=1
|
|
echo "${cmake_cxx_compiler} has environ in stdlib.h"
|
|
else
|
|
echo "${cmake_cxx_compiler} does not have environ in stdlib.h"
|
|
fi
|
|
|
|
if cmake_try_run "${cmake_cxx_compiler}" \
|
|
"${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_STL_HAS_WSTRING" \
|
|
"${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
KWSYS_STL_HAS_WSTRING=1
|
|
echo "${cmake_cxx_compiler} has stl wstring"
|
|
else
|
|
echo "${cmake_cxx_compiler} does not have stl wstring"
|
|
fi
|
|
|
|
if cmake_try_run "${cmake_cxx_compiler}" \
|
|
"${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H" \
|
|
"${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
|
|
KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=1
|
|
echo "${cmake_cxx_compiler} has <ext/stdio_filebuf.h>"
|
|
else
|
|
echo "${cmake_cxx_compiler} does not have <ext/stdio_filebuf.h>"
|
|
fi
|
|
|
|
if test -n "${cmake_ccache_enabled}"; then
|
|
echo "Building CMake with ccache"
|
|
cmake_c_compiler="ccache ${cmake_c_compiler}"
|
|
cmake_cxx_compiler="ccache ${cmake_cxx_compiler}"
|
|
fi
|
|
|
|
# Just to be safe, let us store compiler and flags to the header file
|
|
|
|
cmake_bootstrap_version='$Revision$'
|
|
cmake_compiler_settings_comment="/*
|
|
* Generated by ${cmake_source_dir}/bootstrap
|
|
* Version: ${cmake_bootstrap_version}
|
|
*
|
|
* Source directory: ${cmake_source_dir}
|
|
* Binary directory: ${cmake_bootstrap_dir}
|
|
*
|
|
* C compiler: ${cmake_c_compiler}
|
|
* C flags: ${cmake_c_flags}
|
|
*
|
|
* C++ compiler: ${cmake_cxx_compiler}
|
|
* C++ flags: ${cmake_cxx_flags}
|
|
*
|
|
* Make: ${cmake_make_processor}
|
|
*
|
|
* Sources:
|
|
* ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES}
|
|
* STD Sources:
|
|
* ${CMAKE_STD_CXX_HEADERS} ${CMAKE_STD_CXX_SOURCES}
|
|
* LexerParser Sources:
|
|
* ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES}
|
|
* kwSys Sources:
|
|
* ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES}
|
|
* libuv Sources:
|
|
* ${LIBUV_C_SOURCES}
|
|
* jsoncpp Sources:
|
|
* ${JSONCPP_CXX_SOURCES}
|
|
* librhash Sources:
|
|
* ${LIBRHASH_C_SOURCES}
|
|
*/
|
|
"
|
|
|
|
cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}"
|
|
|
|
# When bootstrapping on MinGW with MSYS we must convert the source
|
|
# directory to a windows path.
|
|
if ${cmake_system_mingw}; then
|
|
CMAKE_BOOTSTRAP_SOURCE_DIR=`cd "${cmake_source_dir}"; pwd -W`
|
|
CMAKE_BOOTSTRAP_BINARY_DIR=`cd "${cmake_binary_dir}"; pwd -W`
|
|
else
|
|
CMAKE_BOOTSTRAP_SOURCE_DIR="${cmake_source_dir}"
|
|
CMAKE_BOOTSTRAP_BINARY_DIR="${cmake_binary_dir}"
|
|
fi
|
|
|
|
# Write CMake version
|
|
cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MAJOR ${cmake_version_major}"
|
|
cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MINOR ${cmake_version_minor}"
|
|
cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_PATCH ${cmake_version_patch}"
|
|
cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION \"${cmake_version}\""
|
|
cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_SOURCE_DIR \"${CMAKE_BOOTSTRAP_SOURCE_DIR}\""
|
|
cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_BINARY_DIR \"${CMAKE_BOOTSTRAP_BINARY_DIR}\""
|
|
cmake_report cmConfigure.h${_tmp} "#define CMake_DEFAULT_RECURSION_LIMIT 400"
|
|
cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insalled\""
|
|
cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\""
|
|
cmake_report cmConfigure.h${_tmp} "#define CM_FALLTHROUGH"
|
|
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_NINJA"
|
|
else
|
|
cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_MAKEFILES"
|
|
fi
|
|
|
|
if ${cmake_system_darwin}; then
|
|
cmake_report cmConfigure.h${_tmp} "#define CMake_USE_MACH_PARSER"
|
|
fi
|
|
|
|
if ${cmake_system_mingw}; then
|
|
cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(NOMINMAX)"
|
|
cmake_report cmConfigure.h${_tmp} "# define NOMINMAX"
|
|
cmake_report cmConfigure.h${_tmp} "#endif"
|
|
cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(KWSYS_ENCODING_DEFAULT_CODEPAGE)"
|
|
cmake_report cmConfigure.h${_tmp} "# define KWSYS_ENCODING_DEFAULT_CODEPAGE CP_UTF8"
|
|
cmake_report cmConfigure.h${_tmp} "#endif"
|
|
fi
|
|
|
|
# Regenerate configured headers
|
|
for h in Configure VersionConfig; do
|
|
if "${_diff}" cm${h}.h cm${h}.h${_tmp} > /dev/null 2> /dev/null; then
|
|
rm -f cm${h}.h${_tmp}
|
|
else
|
|
mv -f cm${h}.h${_tmp} cm${h}.h
|
|
fi
|
|
done
|
|
|
|
# Prepare KWSYS
|
|
cmsys_header_files="cmsys/Configure.h cmsys/Configure.hxx"
|
|
cmake_kwsys_config_replace_string \
|
|
"${cmake_source_dir}/Source/kwsys/Configure.hxx.in" \
|
|
"${cmake_bootstrap_dir}/cmsys/Configure.hxx" \
|
|
"${cmake_compiler_settings_comment}"
|
|
cmake_kwsys_config_replace_string \
|
|
"${cmake_source_dir}/Source/kwsys/Configure.h.in" \
|
|
"${cmake_bootstrap_dir}/cmsys/Configure.h" \
|
|
"${cmake_compiler_settings_comment}"
|
|
|
|
for a in ${KWSYS_FILES}; do
|
|
cmake_replace_string "${cmake_source_dir}/Source/kwsys/${a}.in" \
|
|
"${cmake_bootstrap_dir}/cmsys/${a}" KWSYS_NAMESPACE cmsys
|
|
cmsys_header_files="${cmsys_header_files} cmsys/${a}"
|
|
done
|
|
|
|
echo "#pragma once" > "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
|
|
if test "x${bootstrap_system_libuv}" != "x"; then
|
|
echo "#define CMAKE_USE_SYSTEM_LIBUV" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
|
|
fi
|
|
if test "x${bootstrap_system_jsoncpp}" != "x"; then
|
|
echo "#define CMAKE_USE_SYSTEM_JSONCPP" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
|
|
fi
|
|
if test "x${bootstrap_system_librhash}" != "x"; then
|
|
echo "#define CMAKE_USE_SYSTEM_LIBRHASH" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
|
|
fi
|
|
cmake_generate_file_tmp "${cmake_bootstrap_dir}/cmThirdParty.h" "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
|
|
|
|
# Generate Makefile
|
|
dep="cmConfigure.h ${cmsys_header_files}"
|
|
for h in "${cmake_source_dir}"/Source/*.hxx; do
|
|
dep="${dep} `cmake_escape_artifact \"${h}\"`"
|
|
done
|
|
for h in "${cmake_source_dir}"/Source/*.h; do
|
|
dep="${dep} `cmake_escape_artifact \"${h}\"`"
|
|
done
|
|
for h in ${CMAKE_STD_CXX_HEADERS}; do
|
|
dep="${dep} `cmake_escape_artifact \"${cmake_source_dir}\"`/Utilities/std/cm/${h}"
|
|
done
|
|
objs=""
|
|
for a in ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES} ${CMAKE_STD_CXX_SOURCES} ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES} ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES}; do
|
|
objs="${objs} ${a}.o"
|
|
done
|
|
if test "x${bootstrap_system_libuv}" = "x"; then
|
|
for a in ${LIBUV_C_SOURCES}; do
|
|
objs="${objs} uv-`cmake_obj ${a}`"
|
|
done
|
|
fi
|
|
if test "x${bootstrap_system_librhash}" = "x"; then
|
|
for a in ${LIBRHASH_C_SOURCES}; do
|
|
objs="${objs} rhash-`cmake_obj ${a}`"
|
|
done
|
|
fi
|
|
if test "x${bootstrap_system_jsoncpp}" = "x"; then
|
|
for a in ${JSONCPP_CXX_SOURCES}; do
|
|
objs="${objs} jsoncpp-`cmake_obj ${a}`"
|
|
done
|
|
fi
|
|
|
|
libs=""
|
|
|
|
uv_c_flags=""
|
|
if ${cmake_system_mingw}; then
|
|
uv_c_flags="${uv_c_flags} -DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0600"
|
|
libs="${libs} -lws2_32 -lpsapi -liphlpapi -lshell32 -luserenv -lole32 -loleaut32"
|
|
else
|
|
case "${cmake_system}" in
|
|
*AIX*)
|
|
uv_c_flags="${uv_c_flags} -D_ALL_SOURCE -D_XOPEN_SOURCE=500 -D_LINUX_SOURCE_COMPAT"
|
|
libs="${libs} -lperfstat"
|
|
;;
|
|
*Darwin*)
|
|
uv_c_flags="${uv_c_flags} -D_DARWIN_USE_64_BIT_INODE=1 -D_DARWIN_UNLIMITED_SELECT=1"
|
|
;;
|
|
*HP-UX*)
|
|
uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE_EXTENDED"
|
|
;;
|
|
*Linux*)
|
|
uv_c_flags="${uv_c_flags} -D_GNU_SOURCE"
|
|
libs="${libs} -ldl -lrt"
|
|
;;
|
|
*kFreeBSD*)
|
|
libs="${libs} -lkvm -lfreebsd-glue"
|
|
;;
|
|
*BSD*)
|
|
libs="${libs} -lkvm"
|
|
;;
|
|
*SunOS*)
|
|
uv_c_flags="${uv_c_flags} -D__EXTENSIONS__ -D_XOPEN_SOURCE=600"
|
|
libs="${libs} -lkstat -lnsl -lsendfile -lsocket -lrt"
|
|
;;
|
|
*QNX*)
|
|
uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE=700"
|
|
libs="${libs} -lsocket"
|
|
;;
|
|
esac
|
|
fi
|
|
if test "x${bootstrap_system_libuv}" = "x"; then
|
|
uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/include"`"
|
|
if ${cmake_system_mingw}; then
|
|
uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/win"`"
|
|
else
|
|
uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/unix"`"
|
|
fi
|
|
uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src"`"
|
|
else
|
|
if test `which pkg-config`; then
|
|
use_uv_flags="`pkg-config --cflags libuv`"
|
|
use_uv_ldflags="`pkg-config --libs libuv`"
|
|
cmake_c_flags="${cmake_c_flags} ${use_uv_flags}"
|
|
cmake_cxx_flags="${cmake_cxx_flags} ${use_uv_flags}"
|
|
else
|
|
use_librhash_ldflags="-luv"
|
|
fi
|
|
libs="${libs} ${use_uv_ldflags}"
|
|
fi
|
|
|
|
librhash_c_flags="-DNO_IMPORT_EXPORT"
|
|
if test "x${bootstrap_system_librhash}" != "x"; then
|
|
if test `which pkg-config`; then
|
|
use_librhash_flags="`pkg-config --cflags librhash`"
|
|
use_librhash_ldflags="`pkg-config --libs librhash`"
|
|
cmake_c_flags="${cmake_c_flags} ${use_librhash_flags}"
|
|
cmake_cxx_flags="${cmake_cxx_flags} ${use_librhash_flags}"
|
|
else
|
|
use_librhash_ldflags="-lrhash"
|
|
fi
|
|
libs="${libs} ${use_librhash_ldflags}"
|
|
fi
|
|
|
|
jsoncpp_cxx_flags=
|
|
if test "x${bootstrap_system_jsoncpp}" = "x"; then
|
|
jsoncpp_cxx_flags="${jsoncpp_cxx_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmjsoncpp/include"`"
|
|
else
|
|
if test `which pkg-config`; then
|
|
use_jsoncpp_flags="`pkg-config --cflags jsoncpp`"
|
|
use_jsoncpp_ldflags="`pkg-config --libs jsoncpp`"
|
|
cmake_cxx_flags="${cmake_cxx_flags} ${use_jsoncpp_flags}"
|
|
else
|
|
use_librhash_ldflags="-ljsoncpp"
|
|
fi
|
|
libs="${libs} ${use_jsoncpp_ldflags}"
|
|
fi
|
|
|
|
if test "x${cmake_ansi_cxx_flags}" != "x"; then
|
|
cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}"
|
|
fi
|
|
|
|
system_flags=''
|
|
case "${cmake_system}" in
|
|
# Ensure filesystem access uses 64-bit offsets even on 32-bit hosts.
|
|
*Linux*) system_flags='-D_FILE_OFFSET_BITS=64' ;;
|
|
esac
|
|
if test "x${system_flags}" != "x"; then
|
|
cmake_c_flags="${cmake_c_flags} ${system_flags}"
|
|
cmake_cxx_flags="${cmake_cxx_flags} ${system_flags}"
|
|
fi
|
|
|
|
if test "x${cmake_c_flags}" != "x"; then
|
|
cmake_c_flags="${cmake_c_flags} "
|
|
fi
|
|
|
|
if test "x${cmake_cxx_flags}" != "x"; then
|
|
cmake_cxx_flags="${cmake_cxx_flags} "
|
|
fi
|
|
|
|
write_source_rule() {
|
|
lang="$1"
|
|
obj="$2"
|
|
src="$3"
|
|
src_flags="$4"
|
|
|
|
if test "${lang}" = "c"; then
|
|
ninja_rule=cc
|
|
compiler="${cmake_c_compiler}"
|
|
flags="${cmake_c_flags}"
|
|
elif test "${lang}" = "cxx"; then
|
|
ninja_rule=cxx
|
|
compiler="${cmake_cxx_compiler}"
|
|
flags="${cmake_cxx_flags}"
|
|
fi
|
|
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
echo "build ${obj} : ${ninja_rule} ${src} | ${dep}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo " srcflags = ${src_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
else
|
|
echo "${obj} : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile"
|
|
echo " ${compiler} ${flags} ${src_flags} -c ${src} -o ${obj}" >> "${cmake_bootstrap_dir}/Makefile"
|
|
fi
|
|
}
|
|
|
|
cmake_c_flags_String="-DKWSYS_STRING_C"
|
|
if ${cmake_system_mingw}; then
|
|
cmake_c_flags_EncodingC="-DKWSYS_ENCODING_DEFAULT_CODEPAGE=CP_ACP"
|
|
cmake_cxx_flags_EncodingCXX="${cmake_c_flags_EncodingC}"
|
|
cmake_cxx_flags_cmProcessOutput="${cmake_c_flags_EncodingC}"
|
|
fi
|
|
cmake_cxx_flags_SystemTools="
|
|
-DKWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV}
|
|
-DKWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV}
|
|
-DKWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H}
|
|
-DKWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT}
|
|
-DKWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES}
|
|
"
|
|
cmake_c_flags="${cmake_c_flags} \
|
|
-DCMAKE_BOOTSTRAP \
|
|
-I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`"
|
|
cmake_cxx_flags="${cmake_cxx_flags} \
|
|
-DCMAKE_BOOTSTRAP \
|
|
${cmake_have_cxx_features} \
|
|
-I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Utilities/std\"` \
|
|
-I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`"
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
echo "cc = ${cmake_c_compiler}" > "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "cxx = ${cmake_cxx_compiler}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "cflags = ${cmake_c_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "cxxflags = ${cmake_cxx_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "ldflags = ${cmake_ld_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "rule cc" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo " command = \$cc \$cflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "rule cxx" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo " command = \$cxx \$cxxflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "rule link" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo " command = \$cxx \$ldflags \$cxxflags \$in \$libs -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo "build cmake: link ${objs}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
echo " libs = ${libs}" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
else
|
|
echo "cmake: ${objs}" > "${cmake_bootstrap_dir}/Makefile"
|
|
echo " ${cmake_cxx_compiler} ${cmake_ld_flags} ${cmake_cxx_flags} ${objs} ${libs} -o cmake" >> "${cmake_bootstrap_dir}/Makefile"
|
|
fi
|
|
for a in ${CMAKE_CXX_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.cxx"`
|
|
src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
|
|
write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
|
|
done
|
|
for a in ${CMAKE_C_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.c"`
|
|
write_source_rule "c" "${a}.o" "${src}" ""
|
|
done
|
|
for a in ${CMAKE_STD_CXX_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/std/cm/bits/${a}.cxx"`
|
|
src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
|
|
write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
|
|
done
|
|
for a in ${LexerParser_CXX_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.cxx"`
|
|
src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
|
|
write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
|
|
done
|
|
for a in ${LexerParser_C_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.c"`
|
|
write_source_rule "c" "${a}.o" "${src}" ""
|
|
done
|
|
for a in ${KWSYS_C_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.c"`
|
|
src_flags="`eval echo \\${cmake_c_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys"
|
|
write_source_rule "c" "${a}.o" "${src}" "${src_flags}"
|
|
done
|
|
for a in ${KWSYS_CXX_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.cxx"`
|
|
src_flags="`eval echo \\${cmake_cxx_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys"
|
|
write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
|
|
done
|
|
if test "x${bootstrap_system_libuv}" = "x"; then
|
|
for a in ${LIBUV_C_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibuv/${a}"`
|
|
write_source_rule "c" "uv-`cmake_obj ${a}`" "${src}" "${uv_c_flags}"
|
|
done
|
|
fi
|
|
if test "x${bootstrap_system_librhash}" = "x"; then
|
|
for a in ${LIBRHASH_C_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibrhash/${a}"`
|
|
write_source_rule "c" "rhash-`cmake_obj ${a}`" "${src}" "${librhash_c_flags}"
|
|
done
|
|
fi
|
|
if test "x${bootstrap_system_jsoncpp}" = "x"; then
|
|
for a in ${JSONCPP_CXX_SOURCES}; do
|
|
src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmjsoncpp/${a}"`
|
|
write_source_rule "cxx" "jsoncpp-`cmake_obj ${a}`" "${src}" "${jsoncpp_cxx_flags}"
|
|
done
|
|
fi
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
echo "
|
|
rule rebuild_cache
|
|
command = cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
|
|
generator = 1
|
|
build build.ninja : rebuild_cache
|
|
" >> "${cmake_bootstrap_dir}/build.ninja"
|
|
else
|
|
echo "
|
|
rebuild_cache:
|
|
cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
|
|
" >> "${cmake_bootstrap_dir}/Makefile"
|
|
fi
|
|
|
|
# Write our default settings to Bootstrap${_cmk}/InitialCacheFlags.cmake.
|
|
echo '
|
|
# Generated by '"${cmake_source_dir}"'/bootstrap
|
|
# Default cmake settings. These may be overridden any settings below.
|
|
set (CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build.") # not FORCE to preserve defaults specified elsewhere
|
|
set (CMAKE_INSTALL_PREFIX "'"${cmake_prefix_dir}"'" CACHE PATH "Install path prefix, prepended onto install directories." FORCE)
|
|
set (CMAKE_DOC_DIR "'"${cmake_doc_dir}"'" CACHE PATH "Install location for documentation (relative to prefix)." FORCE)
|
|
set (CMAKE_MAN_DIR "'"${cmake_man_dir}"'" CACHE PATH "Install location for man pages (relative to prefix)." FORCE)
|
|
set (CMAKE_BIN_DIR "'"${cmake_bin_dir}"'" CACHE PATH "Install location for binaries (relative to prefix)." FORCE)
|
|
set (CMAKE_DATA_DIR "'"${cmake_data_dir}"'" CACHE PATH "Install location for data (relative to prefix)." FORCE)
|
|
set (CMAKE_XDGDATA_DIR "'"${cmake_xdgdata_dir}"'" CACHE PATH "Install location for XDG specific files (relative to prefix)." FORCE)
|
|
' > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
|
|
# Add configuration settings given as command-line options.
|
|
if test "x${cmake_bootstrap_qt_gui}" != "x"; then
|
|
echo '
|
|
set (BUILD_QtDialog '"${cmake_bootstrap_qt_gui}"' CACHE BOOL "Build Qt dialog for CMake" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_bootstrap_qt_qmake}" != "x"; then
|
|
echo '
|
|
set (QT_QMAKE_EXECUTABLE "'"${cmake_bootstrap_qt_qmake}"'" CACHE FILEPATH "Location of Qt qmake" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_bootstrap_debugger}" != "x"; then
|
|
echo '
|
|
set (CMake_ENABLE_DEBUGGER '"${cmake_bootstrap_debugger}"' CACHE BOOL "Enable CMake debugger support" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_info}" != "x"; then
|
|
echo '
|
|
set (SPHINX_INFO "'"${cmake_sphinx_info}"'" CACHE BOOL "Build Info manual with Sphinx" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_man}" != "x"; then
|
|
echo '
|
|
set (SPHINX_MAN "'"${cmake_sphinx_man}"'" CACHE BOOL "Build man pages with Sphinx" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_html}" != "x"; then
|
|
echo '
|
|
set (SPHINX_HTML "'"${cmake_sphinx_html}"'" CACHE BOOL "Build html help with Sphinx" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_qthelp}" != "x"; then
|
|
echo '
|
|
set (SPHINX_QTHELP "'"${cmake_sphinx_qthelp}"'" CACHE BOOL "Build qch help with Sphinx" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_latexpdf}" != "x"; then
|
|
echo '
|
|
set (SPHINX_LATEXPDF "'"${cmake_sphinx_latexpdf}"'" CACHE BOOL "Build PDF help with Sphinx using LaTeX" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_build}" != "x"; then
|
|
echo '
|
|
set (SPHINX_EXECUTABLE "'"${cmake_sphinx_build}"'" CACHE FILEPATH "Location of Qt sphinx-build" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
if test "x${cmake_sphinx_flags}" != "x"; then
|
|
echo '
|
|
set (SPHINX_FLAGS [==['"${cmake_sphinx_flags}"']==] CACHE STRING "Flags to pass to sphinx-build" FORCE)
|
|
' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
|
|
# Add user-specified settings. Handle relative-path case for
|
|
# specification of cmake_init_file.
|
|
(
|
|
cd "${cmake_binary_dir}"
|
|
if test -f "${cmake_init_file}"; then
|
|
cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
|
|
fi
|
|
)
|
|
|
|
echo "---------------------------------------------"
|
|
|
|
# Run make to build bootstrap cmake
|
|
if test "${cmake_bootstrap_generator}" = "Ninja"; then
|
|
ninja_v=-v
|
|
else
|
|
ninja_v=
|
|
fi
|
|
if test "x${cmake_parallel_make}" != "x"; then
|
|
${cmake_make_processor} ${cmake_make_flags} ${ninja_v}
|
|
else
|
|
${cmake_make_processor} ${ninja_v}
|
|
fi
|
|
RES=$?
|
|
if test "${RES}" -ne "0"; then
|
|
cmake_error 9 "Problem while running ${cmake_make_processor}"
|
|
fi
|
|
cd "${cmake_binary_dir}"
|
|
|
|
# Set C, CXX, and MAKE environment variables, so that real real cmake will be
|
|
# build with same compiler and make
|
|
CC="${cmake_c_compiler}"
|
|
CXX="${cmake_cxx_compiler}"
|
|
MAKE="${cmake_make_processor}"
|
|
export CC
|
|
export CXX
|
|
export MAKE
|
|
export CFLAGS
|
|
export CXXFLAGS
|
|
export LDFLAGS
|
|
|
|
# Run bootstrap CMake to configure real CMake
|
|
cmake_options="-DCMAKE_BOOTSTRAP=1"
|
|
if test -n "${cmake_verbose}"; then
|
|
cmake_options="${cmake_options} -DCMAKE_VERBOSE_MAKEFILE=1"
|
|
fi
|
|
"${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" ${cmake_options} ${cmake_bootstrap_system_libs} "$@"
|
|
RES=$?
|
|
if test "${RES}" -ne "0"; then
|
|
cmake_error 11 "Problem while running initial CMake"
|
|
fi
|
|
|
|
echo "---------------------------------------------"
|
|
|
|
# And we are done. Now just run make
|
|
echo "CMake has bootstrapped. Now run ${cmake_make_processor}."
|