blob: 115c35437a10c43bb132b4c85dcb6ae3a799d42a [file] [log] [blame]
#!/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 \
cmFileCopier \
cmFileInstaller \
cmFileSet \
cmFileTime \
cmFileTimeCache \
cmFileTimes \
cmFindBase \
cmFindCommon \
cmFindFileCommand \
cmFindLibraryCommand \
cmFindPackageCommand \
cmFindPathCommand \
cmFindProgramCommand \
cmForEachCommand \
cmFunctionBlocker \
cmFunctionCommand \
cmFSPermissions \
cmGeneratedFileStream \
cmGeneratorExpression \
cmGeneratorExpressionContext \
cmGeneratorExpressionDAGChecker \
cmGeneratorExpressionEvaluationFile \
cmGeneratorExpressionEvaluator \
cmGeneratorExpressionLexer \
cmGeneratorExpressionNode \
cmGeneratorExpressionParser \
cmGeneratorTarget \
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 \
cmTest \
cmTestGenerator \
cmTimestamp \
cmTransformDepfile \
cmTryCompileCommand \
cmTryRunCommand \
cmUnsetCommand \
cmUVHandlePtr \
cmUVProcessChain \
cmVersion \
cmWhileCommand \
cmWindowsRegistry \
cmWorkingDirectory \
cmXcFramework \
cmake \
cmakemain \
cmcmd \
cm_fileno \
"
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 \
"
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
--no-system-curl use cmake-provided curl library (default)
--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_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`"
cmake_c_flags="${cmake_c_flags} ${use_uv_flags}"
cmake_cxx_flags="${cmake_cxx_flags} ${use_uv_flags}"
fi
libs="${libs} -luv"
fi
if test "x${bootstrap_system_librhash}" != "x"; then
if test `which pkg-config`; then
use_librhash_flags="`pkg-config --cflags librhash`"
cmake_c_flags="${cmake_c_flags} ${use_librhash_flags}"
cmake_cxx_flags="${cmake_cxx_flags} ${use_librhash_flags}"
fi
libs="${libs} -lrhash"
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`"
cmake_cxx_flags="${cmake_cxx_flags} ${use_jsoncpp_flags}"
fi
libs="${libs} -ljsoncpp"
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}" ""
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}."