/
niceSOFT
/
cmake
Обзор
Документация
Войти
/
niceSOFT
/
cmake
Код
Задачи
Вики
Пакеты
0
Релизы
0
Аналитика
Безопасность
master
bootstrap
2 107 строк
65 KB
Matthew Woehlke
bootstrap: Remove deprecated commands
16 июл 2026, 19:41
16 июл 2026, 19:41
75161b3
Код
Авторство
О чём код?
#!/bin/sh # Distributed under the OSI-approved BSD 3-Clause License. See accompanying # file LICENSE.rst 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}/LICENSE.rst" | sed 's/\`Contributors.*\`_/Contributors/'`" 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.' 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 # 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 \ cmBuildDatabase \ cmCMakeLanguageCommand \ cmCMakeMinimumRequired \ cmList \ cmCMakeDiagnosticCommand \ cmCMakePath \ cmCMakePathCommand \ cmCMakePolicyCommand \ cmCMakeString \ cmCPackPropertiesGenerator \ cmCacheDocumentationTable \ cmCacheManager \ cmCachePatternTable \ cmCommands \ cmCommonTargetGenerator \ cmComputeComponentGraph \ cmComputeLinkDepends \ cmComputeLinkInformation \ cmComputeTargetDepends \ cmConditionEvaluator \ cmConfigureFileCommand \ cmContinueCommand \ cmCoreTryCompile \ cmCreateTestSourceList \ cmCryptoHash \ cmCustomCommand \ cmCustomCommandGenerator \ cmCustomCommandLines \ cmCxxModuleMapper \ cmCxxModuleUsageEffects \ cmDefinePropertyCommand \ cmDefinitions \ cmDiagnostics \ cmDiagnosticContext \ cmDiscoverTestsCommand \ cmDocumentationFormatter \ cmELF \ cmEnableLanguageCommand \ cmEnableTestingCommand \ cmEnvironment \ cmEvaluatedTargetProperty \ cmExecProgramCommand \ cmExecuteProcessCommand \ cmExpandedCommandArgument \ cmExperimental \ cmExportBuildCMakeConfigGenerator \ cmExportBuildFileGenerator \ cmExportCMakeConfigGenerator \ cmExportFileGenerator \ cmExportInstallCMakeConfigGenerator \ cmExportInstallFileGenerator \ cmExportSet \ cmExportTryCompileFileGenerator \ cmExprParserHelper \ cmExternalMakefileProjectGenerator \ cmFileCommand \ cmFileCommand_ReadMacho \ cmFileCopier \ cmFileInstaller \ cmFileSet \ cmFileSetMetadata \ cmFileTime \ cmFileTimeCache \ cmFileTimes \ cmFindBase \ cmFindCommon \ cmFindFileCommand \ cmFindLibraryCommand \ cmFindPackageCommand \ cmFindPackageStack \ cmFindPathCommand \ cmFindProgramCommand \ cmForEachCommand \ cmFunctionBlocker \ cmFunctionCommand \ cmFSPermissions \ cmGeneratedFileStream \ cmGenExContext \ cmGenExEvaluation \ cmGeneratorExpression \ cmGeneratorExpressionDAGChecker \ cmGeneratorExpressionEvaluationFile \ cmGeneratorExpressionEvaluator \ cmGeneratorExpressionLexer \ cmGeneratorExpressionNode \ cmGeneratorExpressionParser \ cmGeneratorFileSet \ cmGeneratorFileSets \ cmGeneratorTarget \ cmGeneratorTarget_CompatibleInterface \ cmGeneratorTarget_HeaderSetVerification \ cmGeneratorTarget_IncludeDirectories \ cmGeneratorTarget_Link \ cmGeneratorTarget_LinkDirectories \ cmGeneratorTarget_Options \ cmGeneratorTarget_Sources \ cmGeneratorTarget_TransitiveProperty \ cmGetCMakePropertyCommand \ cmGetDirectoryPropertyCommand \ cmGetFilenameComponentCommand \ cmGetPipes \ cmGetPropertyCommand \ cmGetSourceFilePropertyCommand \ cmGetTargetPropertyCommand \ cmGetTestPropertyCommand \ cmGlobalCommonGenerator \ cmGlobalGenerator \ cmGlobVerificationManager \ cmHexFileConverter \ cmIfCommand \ cmImportedCxxModuleInfo \ cmIncludeCommand \ cmIncludeGuardCommand \ cmIncludeDirectoryCommand \ cmIncludeRegularExpressionCommand \ cmInstallCMakeConfigExportGenerator \ cmInstallCommand \ cmInstallCommandArguments \ cmInstallCxxModuleBmiGenerator \ cmInstallDirectoryGenerator \ cmInstallExportGenerator \ cmInstallFileSetGenerator \ cmInstallFilesGenerator \ cmInstallGenerator \ cmInstallGetRuntimeDependenciesGenerator \ cmInstallImportedRuntimeArtifactsGenerator \ cmInstallDirs \ cmInstallRuntimeDependencySet \ cmInstallRuntimeDependencySetGenerator \ cmInstallScriptGenerator \ cmInstallSubdirectoryGenerator \ cmInstallTargetGenerator \ cmInstalledFile \ cmJSONHelpers \ cmJSONState \ cmLDConfigLDConfigTool \ cmLDConfigTool \ cmLinkDirectoriesCommand \ cmLinkItem \ cmLinkItemGraphVisitor \ cmLinkLineComputer \ cmLinkLineDeviceComputer \ cmListCommand \ cmListFileCache \ cmLocalCommonGenerator \ cmLocalGenerator \ cmMSVC60LinkLineComputer \ cmMacroCommand \ cmMakefile \ cmMarkAsAdvancedCommand \ cmMathCommand \ cmMessageCommand \ cmMessenger \ cmNewLineStyle \ cmOSXBundleGenerator \ cmOptionCommand \ cmOrderDirectories \ cmObjectLocation \ cmOutputConverter \ cmParseArgumentsCommand \ cmPathLabel \ cmPathResolver \ cmPolicies \ cmProcessOutput \ cmProjectCommand \ cmValue \ cmPropertyDefinition \ cmPropertyMap \ cmGccDepfileLexerHelper \ cmGccDepfileReader \ cmReturnCommand \ cmPackageInfoReader \ cmPlaceholderExpander \ cmPlistParser \ cmRulePlaceholderExpander \ cmRuntimeDependencyArchive \ cmScriptGenerator \ cmSearchPath \ cmSeparateArgumentsCommand \ cmSetCommand \ cmSetDirectoryPropertiesCommand \ cmSetPropertyCommand \ cmSetSourceFilesPropertiesCommand \ cmSetTargetPropertiesCommand \ cmSetTestsPropertiesCommand \ cmSiteNameCommand \ cmSourceFile \ cmSourceFileLocation \ cmStandardLevelResolver \ cmState \ cmStateDirectory \ cmStateSnapshot \ cmStdIoConsole \ cmStdIoInit \ cmStdIoStream \ cmStdIoTerminal \ cmString \ cmStringAlgorithms \ cmStringReplaceHelper \ cmStringCommand \ cmSubcommandTable \ cmSystemTools \ cmTarget \ cmTargetCompileDefinitionsCommand \ cmTargetCompileFeaturesCommand \ cmTargetCompileOptionsCommand \ cmTargetIncludeDirectoriesCommand \ cmTargetLinkLibrariesCommand \ cmTargetLinkOptionsCommand \ cmTargetPrecompileHeadersCommand \ cmTargetPropCommandBase \ cmTargetPropertyComputer \ cmTargetPropertyEntry \ 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_C_SOURCES="\ cm_utf8 \ " CMAKE_STD_CXX_HEADERS="\ filesystem \ memory \ optional \ shared_mutex \ string_view \ utility \ " CMAKE_STD_CXX_SOURCES="\ fs_path \ string_view \ " LexerParser_CXX_SOURCES="\ cmExprLexer \ cmExprParser \ cmGccDepfileLexer \ " LexerParser_C_SOURCES="\ cmListFileLexer \ " if ${cmake_system_mingw}; then KWSYS_C_SOURCES="\ EncodingC \ ProcessWin32 \ String \ System \ " else KWSYS_C_SOURCES="\ EncodingC \ ProcessUNIX \ String \ System \ " 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 \ " 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_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/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 tab="`printf '\t'`" 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 '"${tab}${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_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 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_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-installed\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-installed\"" 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} -ladvapi32 -ldbghelp -liphlpapi -lole32 -loleaut32 -lpsapi -lshell32 -luser32 -luserenv -luuid -lws2_32" 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" ;; *NetBSD*) libs="${libs} -lkvm" ;; *BSD*) ;; *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_uv_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_jsoncpp_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 -D_TIME_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 "${tab}${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 "${tab}${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: ${tab}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}."