2 # Distributed under the OSI-approved BSD 3-Clause License. See accompanying
3 # file Copyright.txt or https://cmake.org/licensing for details.
6 echo "$@" 1>&2 ; exit 1
9 # Compile flag extraction function.
10 cmake_extract_standard_flags
()
15 sed -n "s/ *set *( *CMAKE_${lang}${ver}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \
16 "${cmake_source_dir}/Modules/Compiler/"${id}-${lang}.cmake \
17 2>/dev/null | tr ';' ' '
18 # Clang's CXX compiler flags are in the common module.
19 sed -n "s
/ *set *( *CMAKE_
\\\
${lang}${ver}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\
([^
\")]*\
).
*/\
1/p
" \
20 "${cmake_source_dir}/Modules
/Compiler
/Clang.cmake
" \
21 2>/dev/null | tr ';' ' '
24 # Version number extraction function.
25 cmake_version_component()
28 /^
set(CMake_VERSION_
${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\)).*/\1/;p;}
29 " "${cmake_source_dir}/Source
/CMakeVersion.cmake
"
32 # Install destination extraction function.
33 cmake_install_dest_default()
36 /^ *set(CMAKE_'"${1}"'_DIR_DEFAULT.*) # '"${2}"'$/ {
37 s/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT *"\
([^
"]*\)").
*$
/\
1/
38 s
/${CMake_VERSION_MAJOR}/'"${cmake_version_major}"'/
39 s
/${CMake_VERSION_MINOR}/'"${cmake_version_minor}"'/
40 s
/${CMake_VERSION_PATCH}/'"${cmake_version_patch}"'/
44 ' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake"
49 echo "$1" | tr '[a-z
]' '[A-Z
]'
52 # Detect system and directory information.
54 cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd`
55 cmake_binary_dir=`pwd`
57 # Load version information.
58 cmake_version_major="`cmake_version_component MAJOR`"
59 cmake_version_minor="`cmake_version_component MINOR`"
60 cmake_version_patch="`cmake_version_component PATCH`"
61 cmake_version="${cmake_version_major}.${cmake_version_minor}.${cmake_version_patch}"
62 cmake_version_rc="`cmake_version_component RC`"
63 if test "$cmake_version_rc" != ""; then
64 cmake_version="${cmake_version}-rc${cmake_version_rc}"
67 cmake_copyright="`grep '^Copyright .
* Kitware
' "${cmake_source_dir}/Copyright.txt"`"
69 cmake_bin_dir_keyword="OTHER"
70 cmake_data_dir_keyword="OTHER"
71 cmake_doc_dir_keyword="OTHER"
72 cmake_man_dir_keyword="OTHER"
73 cmake_xdgdata_dir_keyword="OTHER"
80 cmake_bootstrap_system_libs=""
81 cmake_bootstrap_qt_gui=""
82 cmake_bootstrap_qt_qmake=""
83 cmake_bootstrap_debugger=""
87 cmake_sphinx_qthelp=""
88 cmake_sphinx_latexpdf=""
92 # Determine whether this is a Cygwin environment.
93 if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then
94 cmake_system_cygwin=true
95 cmake_doc_dir_keyword="CYGWIN"
96 cmake_man_dir_keyword="CYGWIN"
98 cmake_system_cygwin=false
101 # Determine whether this is a MSYS environment.
102 if echo "${cmake_system}" | grep MSYS >/dev/null 2>&1; then
103 cmake_system_msys=true
104 cmake_doc_dir_keyword="MSYS"
105 cmake_man_dir_keyword="MSYS"
107 cmake_system_msys=false
110 # Determine whether this is a MinGW environment.
111 if echo "${cmake_system}" | grep 'MINGW
' >/dev/null 2>&1; then
112 cmake_system_mingw=true
114 cmake_system_mingw=false
117 # Determine whether this is OS X
118 if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then
119 cmake_system_darwin=true
121 cmake_system_darwin=false
124 # Determine whether this is BeOS
125 if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then
126 cmake_system_beos=true
127 cmake_doc_dir_keyword="HAIKU"
128 cmake_man_dir_keyword="HAIKU"
130 cmake_system_beos=false
133 # Determine whether this is Haiku
134 if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then
135 cmake_system_haiku=true
136 cmake_doc_dir_keyword="HAIKU"
137 cmake_man_dir_keyword="HAIKU"
139 cmake_system_haiku=false
142 # Determine whether this is OpenVMS
143 if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then
144 cmake_system_openvms=true
146 cmake_system_openvms=false
149 # Determine whether this is HP-UX
150 if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then
151 die 'CMake no longer compiles on HP-UX. See
153 https
://gitlab.kitware.com
/cmake
/cmake
/-/issues
/17137
155 Use CMake
3.9 or lower instead.
'
156 cmake_system_hpux=true
158 cmake_system_hpux=false
161 # Determine whether this is AIX
162 if echo "${cmake_system}" | grep AIX >/dev/null 2>&1; then
163 cmake_system_aix=true
165 cmake_system_aix=false
168 # Determine whether this is Linux
169 if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then
170 cmake_system_linux=true
172 cmake_system_linux=false
175 # Determine whether this is a PA-RISC machine
176 # This only works for Linux or HP-UX, not other PA-RISC OSs (BSD maybe?). Also
177 # may falsely detect parisc on HP-UX m68k
178 cmake_machine_parisc=false
179 if ${cmake_system_linux}; then
180 if uname -m | grep parisc >/dev/null 2>&1; then
181 cmake_machine_parisc=true
183 elif ${cmake_system_hpux}; then
184 if uname -m | grep ia64 >/dev/null 2>&1; then : ; else
185 cmake_machine_parisc=true
189 # Choose the generator to use for bootstrapping.
190 if ${cmake_system_mingw}; then
191 # Bootstrapping from an MSYS prompt.
192 cmake_bootstrap_generator="MSYS Makefiles"
194 # Bootstrapping from a standard UNIX prompt.
195 cmake_bootstrap_generator="Unix Makefiles"
198 # Choose tools and extensions for this platform.
199 if ${cmake_system_openvms}; then
209 # Construct bootstrap directory name.
210 cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}"
212 # Helper function to fix windows paths.
213 case "${cmake_system}" in
217 cmd //c echo "$(echo "$1" | sed 's
/\\/\
//g
')" | sed 's
/^
"//;s/" *$
//'
223 echo "$1" | sed 's
/\\/\
//g
'
228 # Choose the default install prefix.
229 if ${cmake_system_mingw}; then
230 if test "x${PROGRAMFILES}" != "x"; then
231 cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"`
232 elif test "x${ProgramFiles}" != "x"; then
233 cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"`
234 elif test "x${SYSTEMDRIVE}" != "x"; then
235 cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"`
236 elif test "x${SystemDrive}" != "x"; then
237 cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"`
239 cmake_default_prefix="c:/Program Files/CMake"
241 elif ${cmake_system_haiku}; then
242 cmake_default_prefix=`finddir B_COMMON_DIRECTORY`
244 cmake_default_prefix="/usr/local"
247 # Lookup default install destinations.
248 cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`"
249 cmake_data_dir_default="`cmake_install_dest_default DATA ${cmake_data_dir_keyword}`"
250 cmake_doc_dir_default="`cmake_install_dest_default DOC ${cmake_doc_dir_keyword}`"
251 cmake_man_dir_default="`cmake_install_dest_default MAN ${cmake_man_dir_keyword}`"
252 cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`"
254 CMAKE_KNOWN_C_COMPILERS="cc gcc clang xlc icx tcc"
255 CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icpx"
256 CMAKE_KNOWN_MAKE_PROCESSORS="gmake make smake"
257 CMAKE_KNOWN_NINJA_PROCESSORS="ninja-build ninja samu"
259 CMAKE_PROBLEMATIC_FILES="\
262 CMakeCCompiler.cmake \
263 CMakeCXXCompiler.cmake \
264 */CMakeSystem.cmake \
265 */CMakeCCompiler.cmake \
266 */CMakeCXXCompiler.cmake \
267 Source/cmConfigure.h \
268 Source/CTest/Curl/config.h \
269 Utilities/cmThirdParty.h \
270 Utilities/cmcurl/lib/curl_config.h \
271 Utilities/cmlibarchive/config.h \
272 Utilities/cmliblzma/config.h \
273 Utilities/cmnghttp2/config.h \
276 CMAKE_UNUSED_SOURCES="\
277 cmGlobalXCodeGenerator \
278 cmLocalXCodeGenerator \
285 cmAddCompileDefinitionsCommand \
286 cmAddCustomCommandCommand \
287 cmAddCustomTargetCommand \
288 cmAddDefinitionsCommand \
289 cmAddDependenciesCommand \
290 cmAddExecutableCommand \
291 cmAddLibraryCommand \
292 cmAddSubDirectoryCommand \
296 cmBinUtilsLinuxELFGetRuntimeDependenciesTool \
297 cmBinUtilsLinuxELFLinker \
298 cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool \
299 cmBinUtilsMacOSMachOGetRuntimeDependenciesTool \
300 cmBinUtilsMacOSMachOLinker \
301 cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool \
302 cmBinUtilsWindowsPEGetRuntimeDependenciesTool \
303 cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool \
304 cmBinUtilsWindowsPELinker \
305 cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool \
309 cmCMakeLanguageCommand \
310 cmCMakeMinimumRequired \
314 cmCMakePolicyCommand \
315 cmCPackPropertiesGenerator \
318 cmCommandArgumentParserHelper \
320 cmCommonTargetGenerator \
321 cmComputeComponentGraph \
322 cmComputeLinkDepends \
323 cmComputeLinkInformation \
324 cmComputeTargetDepends \
326 cmConditionEvaluator \
327 cmConfigureFileCommand \
330 cmCreateTestSourceList \
333 cmCustomCommandGenerator \
334 cmCustomCommandLines \
336 cmCxxModuleUsageEffects \
337 cmDefinePropertyCommand \
339 cmDocumentationFormatter \
341 cmEnableLanguageCommand \
342 cmEnableTestingCommand \
343 cmEvaluatedTargetProperty \
344 cmExecProgramCommand \
345 cmExecuteProcessCommand \
346 cmExpandedCommandArgument \
348 cmExportBuildFileGenerator \
349 cmExportFileGenerator \
350 cmExportInstallFileGenerator \
352 cmExportTryCompileFileGenerator \
354 cmExternalMakefileProjectGenerator \
365 cmFindLibraryCommand \
366 cmFindPackageCommand \
369 cmFindProgramCommand \
374 cmGeneratedFileStream \
375 cmGeneratorExpression \
376 cmGeneratorExpressionContext \
377 cmGeneratorExpressionDAGChecker \
378 cmGeneratorExpressionEvaluationFile \
379 cmGeneratorExpressionEvaluator \
380 cmGeneratorExpressionLexer \
381 cmGeneratorExpressionNode \
382 cmGeneratorExpressionParser \
384 cmGetCMakePropertyCommand \
385 cmGetDirectoryPropertyCommand \
386 cmGetFilenameComponentCommand \
388 cmGetPropertyCommand \
389 cmGetSourceFilePropertyCommand \
390 cmGetTargetPropertyCommand \
391 cmGetTestPropertyCommand \
392 cmGlobalCommonGenerator \
394 cmGlobVerificationManager \
397 cmImportedCxxModuleInfo \
399 cmIncludeGuardCommand \
400 cmIncludeDirectoryCommand \
401 cmIncludeRegularExpressionCommand \
403 cmInstallCommandArguments \
404 cmInstallCxxModuleBmiGenerator \
405 cmInstallDirectoryGenerator \
406 cmInstallExportGenerator \
407 cmInstallFileSetGenerator \
408 cmInstallFilesCommand \
409 cmInstallFilesGenerator \
411 cmInstallGetRuntimeDependenciesGenerator \
412 cmInstallImportedRuntimeArtifactsGenerator \
413 cmInstallRuntimeDependencySet \
414 cmInstallRuntimeDependencySetGenerator \
415 cmInstallScriptGenerator \
416 cmInstallSubdirectoryGenerator \
417 cmInstallTargetGenerator \
418 cmInstallTargetsCommand \
422 cmLDConfigLDConfigTool \
424 cmLinkDirectoriesCommand \
426 cmLinkItemGraphVisitor \
428 cmLinkLineDeviceComputer \
431 cmLocalCommonGenerator \
433 cmMSVC60LinkLineComputer \
435 cmMakeDirectoryCommand \
437 cmMarkAsAdvancedCommand \
442 cmOSXBundleGenerator \
446 cmParseArgumentsCommand \
452 cmPropertyDefinition \
454 cmGccDepfileLexerHelper \
457 cmPlaceholderExpander \
459 cmRulePlaceholderExpander \
460 cmRuntimeDependencyArchive \
463 cmSeparateArgumentsCommand \
465 cmSetDirectoryPropertiesCommand \
466 cmSetPropertyCommand \
467 cmSetSourceFilesPropertiesCommand \
468 cmSetTargetPropertiesCommand \
469 cmSetTestsPropertiesCommand \
472 cmSourceFileLocation \
473 cmStandardLevelResolver \
479 cmStringReplaceHelper \
485 cmTargetCompileDefinitionsCommand \
486 cmTargetCompileFeaturesCommand \
487 cmTargetCompileOptionsCommand \
488 cmTargetIncludeDirectoriesCommand \
489 cmTargetLinkLibrariesCommand \
490 cmTargetLinkOptionsCommand \
491 cmTargetPrecompileHeadersCommand \
492 cmTargetPropCommandBase \
493 cmTargetPropertyComputer \
494 cmTargetSourcesCommand \
499 cmTryCompileCommand \
515 if ${cmake_system_mingw}; then
516 CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
517 cmGlobalMSYSMakefileGenerator \
518 cmGlobalMinGWMakefileGenerator \
523 CMAKE_STD_CXX_HEADERS="\
531 CMAKE_STD_CXX_SOURCES="\
536 LexerParser_CXX_SOURCES="\
537 cmCommandArgumentLexer \
538 cmCommandArgumentParser \
544 LexerParser_C_SOURCES="\
548 if ${cmake_system_mingw}; then
580 RegularExpression.hxx \
587 LIBRHASH_C_SOURCES="\
588 librhash/algorithms.c \
589 librhash/byte_order.c \
600 JSONCPP_CXX_SOURCES="\
601 src/lib_json/json_reader.cpp \
602 src/lib_json/json_value.cpp \
603 src/lib_json/json_writer.cpp \
606 if ${cmake_system_mingw}; then
618 src/win/detect-wakeup.c \
623 src/win/getaddrinfo.c \
624 src/win/getnameinfo.c \
626 src/win/loop-watcher.c \
629 src/win/process-stdio.c \
647 src/unix/cmake-bootstrap.c \
651 src/unix/loop-watcher.c \
652 src/unix/no-fsevents.c \
655 src/unix/posix-hrtime.c \
656 src/unix/posix-poll.c \
665 # Display CMake bootstrap usage
669 Usage
: '"$0"' [<options
>...
] [-- <cmake-options
>...
]
670 Options
: [defaults
in brackets after descriptions
]
672 --help print this message
673 --version only print version information
674 --verbose display
more information
675 --parallel=n bootstrap cmake
in parallel
, where n is
677 --generator=<generator
> generator to use
(MSYS Makefiles
, Unix Makefiles
,
679 --enable-ccache Enable ccache when building cmake
680 --init=FILE load FILE as
script to populate cache
681 --system-libs use all system-installed third-party libraries
682 (for use only by package maintainers
)
683 --no-system-libs use all cmake-provided third-party libraries
685 --system-cppdap use system-installed cppdap library
686 --no-system-cppdap use cmake-provided cppdap library
(default
)
687 --system-curl use system-installed curl library
688 --no-system-curl use cmake-provided curl library
(default
)
689 --system-expat use system-installed expat library
690 --no-system-expat use cmake-provided expat library
(default
)
691 --system-jsoncpp use system-installed jsoncpp library
692 --no-system-jsoncpp use cmake-provided jsoncpp library
(default
)
693 --system-zlib use system-installed zlib library
694 --no-system-zlib use cmake-provided zlib library
(default
)
695 --system-bzip2 use system-installed
bzip2 library
696 --no-system-bzip2 use cmake-provided
bzip2 library
(default
)
697 --system-liblzma use system-installed liblzma library
698 --no-system-liblzma use cmake-provided liblzma library
(default
)
699 --system-nghttp2 use system-installed nghttp2 library
700 --no-system-nghttp2 use cmake-provided nghttp2 library
(default
)
701 --system-zstd use system-installed zstd library
702 --no-system-zstd use cmake-provided zstd library
(default
)
703 --system-libarchive use system-installed libarchive library
704 --no-system-libarchive use cmake-provided libarchive library
(default
)
705 --system-librhash use system-installed librhash library
706 --no-system-librhash use cmake-provided librhash library
(default
)
707 --system-libuv use system-installed libuv library
708 --no-system-libuv use cmake-provided libuv library
(default
)
710 --bootstrap-system-libuv use system-installed libuv library
for bootstrap
711 --bootstrap-system-jsoncpp use system-installed jsoncpp library
for bootstrap
712 --bootstrap-system-librhash use system-installed librhash library
for bootstrap
714 --qt-gui build the Qt-based GUI
(requires Qt
>= 4.2)
715 --no-qt-gui do not build the Qt-based GUI
(default
)
716 --qt-qmake=<qmake
> use
<qmake
> as the qmake executable to
find Qt
718 --debugger enable debugger support
(default
if supported
)
719 --no-debugger disable debugger support
721 --sphinx-info build Info manual with Sphinx
722 --sphinx-man build man pages with Sphinx
723 --sphinx-html build html
help with Sphinx
724 --sphinx-qthelp build qch
help with Sphinx
725 --sphinx-latexpdf build PDF with Sphinx using LaTeX
726 --sphinx-build=<sb
> use
<sb
> as the sphinx-build executable
727 --sphinx-flags=<flags
> pass
<flags
> to sphinx-build executable
729 Directory and
file names
:
730 --prefix=PREFIX
install files
in tree rooted
at PREFIX
731 ['"${cmake_default_prefix}"']
732 --bindir=DIR
install binaries
in PREFIX
/DIR
733 ['"${cmake_bin_dir_default}"']
734 --datadir=DIR
install data files
in PREFIX
/DIR
735 ['"${cmake_data_dir_default}"']
736 --docdir=DIR
install documentation files
in PREFIX
/DIR
737 ['"${cmake_doc_dir_default}"']
738 --mandir=DIR
install man pages files
in PREFIX
/DIR
/manN
739 ['"${cmake_man_dir_default}"']
740 --xdgdatadir=DIR
install XDG specific files
in PREFIX
/DIR
741 ['"${cmake_xdgdata_dir_default}"']
746 # Display CMake bootstrap usage
747 cmake_version_display()
749 echo "CMake ${cmake_version}, ${cmake_copyright}"
752 # Display CMake bootstrap error, display the log file and exit
757 echo "---------------------------------------------"
758 echo "Error when bootstrapping CMake:"
760 echo "---------------------------------------------"
761 if test -f cmake_bootstrap.log; then
762 echo "Log of errors: `pwd`/cmake_bootstrap.log"
763 #cat cmake_bootstrap.log
764 echo "---------------------------------------------"
769 cmake_generate_file_tmp ()
773 if "${_diff}" "$TMPFILE" "$OUTFILE" > /dev/null 2> /dev/null ; then
776 mv -f "$TMPFILE" "$OUTFILE"
780 cmake_generate_file ()
784 echo "$CONTENT" > "$OUTFILE.tmp"
785 cmake_generate_file_tmp "$OUTFILE" "$OUTFILE.tmp"
788 # Replace KWSYS_NAMESPACE with cmsys
789 cmake_replace_string ()
795 if test -f "${INFILE}" || ${cmake_system_openvms}; then
796 sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}"
797 if test -f "${OUTFILE}${_tmp}"; then
798 if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
799 #echo "Files are the same"
800 rm -f "${OUTFILE}${_tmp}"
802 mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
806 cmake_error 1 "Cannot find file ${INFILE}"
810 cmake_kwsys_config_replace_string ()
816 if test -f "${INFILE}" || ${cmake_system_openvms}; then
817 echo "${APPEND}" > "${OUTFILE}${_tmp}"
818 sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g;
819 s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/g;
820 s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g;
821 s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g;
822 s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g;
823 s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g;
824 s/@KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/g;
825 s/@KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP@/${KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP}/g;
826 }" "${INFILE}" >> "${OUTFILE}${_tmp}"
827 if test -f "${OUTFILE}${_tmp}"; then
828 if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
829 #echo "Files are the same"
830 rm -f "${OUTFILE}${_tmp}"
832 mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
836 cmake_error 2 "Cannot find file ${INFILE}"
839 # Write string into a file
847 # Escape spaces in strings for artifacts
848 cmake_escape_artifact ()
850 if test "${cmake_bootstrap_generator}" = "Ninja"; then
851 echo $1 | sed "s/ /$ /g"
853 echo $1 | sed "s/ /\\\\ /g"
857 # Escape spaces in strings for shell
858 cmake_escape_shell ()
860 echo $1 | sed "s/ /\\\\ /g"
863 # Encode object file names.
866 echo $1 | sed 's
/\
//-/g
' | sed 's
/$
/\.o
/'
869 # Strip prefix from argument
872 echo "$1" | sed "s/^${2-[^=]*=}//"
875 # Write message to the log
878 echo "$*" >> cmake_bootstrap.log
884 echo "cmake_bootstrap_$$_test"
887 # Run a compiler test. First argument is compiler, second one are compiler
888 # flags, third one is test source file to be compiled
894 if test ! -f "${TESTFILE}"; then
895 echo "Test file ${TESTFILE} missing. Please verify your CMake source tree."
898 TMPFILE=`cmake_tmp_file`
899 echo "Try: ${COMPILER}"
900 echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}"
901 echo "---------- file -----------------------"
903 echo "------------------------------------------"
904 ${COMPILER} ${FLAGS} "${TESTFILE}" -o "${TMPFILE}"
906 if test "${RES}" -ne "0"; then
907 echo "Test failed to compile"
910 if test ! -f "${TMPFILE}" && test ! -f "${TMPFILE}.exe"; then
911 echo "Test failed to produce executable"
917 if test "${RES}" -ne "0"; then
918 echo "Test produced non-zero return code"
921 echo "Test succeeded"
925 # Run a make test. First argument is the make interpreter.
930 echo "Try: ${MAKE_PROC}"
931 "${MAKE_PROC}" ${MAKE_FLAGS}
933 if test "${RES}" -ne "0"; then
934 echo "${MAKE_PROC} does not work"
937 if test ! -f "test" && test ! -f "test.exe"; then
938 echo "${COMPILER} does not produce output"
944 if test "${RES}" -ne "0"; then
945 echo "${MAKE_PROC} produces strange executable"
948 echo "${MAKE_PROC} works"
955 cmake_ccache_enabled=
956 cmake_prefix_dir="${cmake_default_prefix}"
957 bootstrap_system_libuv=
958 bootstrap_system_jsoncpp=
959 bootstrap_system_librhash=
960 while test $# != 0; do
962 --prefix=*) dir=`cmake_arg "$1"`
963 cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;;
964 --parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;;
965 --generator=*) cmake_bootstrap_generator=`cmake_arg "$1"` ;;
966 --bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;;
967 --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;;
968 --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;;
969 --mandir=*) cmake_man_dir=`cmake_arg "$1"` ;;
970 --xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;;
971 --init=*) cmake_init_file=`cmake_arg "$1"` ;;
972 --system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=1" ;;
973 --no-system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=0" ;;
974 --system-bzip2|--system-cppdap|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma|--system-nghttp2|--system-zstd|--system-libuv)
975 lib=`cmake_arg "$1" "--system-"`
976 cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;;
977 --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)
978 lib=`cmake_arg "$1" "--no-system-"`
979 cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;;
980 --bootstrap-system-libuv) bootstrap_system_libuv="1" ;;
981 --bootstrap-system-jsoncpp) bootstrap_system_jsoncpp="1" ;;
982 --bootstrap-system-librhash) bootstrap_system_librhash="1" ;;
983 --qt-gui) cmake_bootstrap_qt_gui="1" ;;
984 --no-qt-gui) cmake_bootstrap_qt_gui="0" ;;
985 --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;;
986 --debugger) cmake_bootstrap_debugger="1" ;;
987 --no-debugger) cmake_bootstrap_debugger="0" ;;
988 --sphinx-info) cmake_sphinx_info="1" ;;
989 --sphinx-man) cmake_sphinx_man="1" ;;
990 --sphinx-html) cmake_sphinx_html="1" ;;
991 --sphinx-qthelp) cmake_sphinx_qthelp="1" ;;
992 --sphinx-latexpdf) cmake_sphinx_latexpdf="1" ;;
993 --sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;;
994 --sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;;
995 --help) cmake_usage ;;
996 --version) cmake_version_display ; exit 2 ;;
997 --verbose) cmake_verbose=TRUE ;;
998 --enable-ccache) cmake_ccache_enabled=TRUE ;;
999 CC=*) CC=`cmake_arg "$1"` ;;
1000 CXX=*) CXX=`cmake_arg "$1"` ;;
1001 CFLAGS=*) CFLAGS=`cmake_arg "$1"` ;;
1002 CXXFLAGS=*) CXXFLAGS=`cmake_arg "$1"` ;;
1003 LDFLAGS=*) LDFLAGS=`cmake_arg "$1"` ;;
1005 *) die "Unknown option: $1" ;;
1010 # Make sure the generator is valid
1011 case "${cmake_bootstrap_generator}" in
1012 'MSYS Makefiles
'|'Unix Makefiles
'|'Ninja
') ;;
1013 *) cmake_error 10 "Invalid generator: ${cmake_bootstrap_generator}"
1016 # If verbose, display some information about bootstrap
1017 if test -n "${cmake_verbose}"; then
1018 echo "---------------------------------------------"
1019 echo "Source directory: ${cmake_source_dir}"
1020 echo "Binary directory: ${cmake_binary_dir}"
1021 echo "Prefix directory: ${cmake_prefix_dir}"
1022 echo "System: ${cmake_system}"
1023 echo "Generator: ${cmake_bootstrap_generator}"
1024 if test "x${cmake_parallel_make}" != "x"; then
1025 echo "Doing parallel make: ${cmake_parallel_make}"
1030 echo "---------------------------------------------"
1032 echo "`cmake_version_display`"
1034 # Check for in-source build
1035 cmake_in_source_build=
1036 if test -f "${cmake_binary_dir}/Source/cmake.cxx" &&
1037 test -f "${cmake_binary_dir}/Source/cmake.h"; then
1038 if test -n "${cmake_verbose}"; then
1039 echo "Warning: This is an in-source build"
1041 cmake_in_source_build=TRUE
1044 # If this is not an in-source build, then Bootstrap stuff should not exist.
1045 if test -z "${cmake_in_source_build}"; then
1046 # Did somebody bootstrap in the source tree?
1047 if test -d "${cmake_source_dir}/Bootstrap${_cmk}"; then
1048 cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\".
1049 Looks like somebody did bootstrap CMake in the source tree, but now you are
1050 trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk}
1051 directory from the source tree."
1053 # Is there a cache in the source tree?
1054 for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do
1055 if test -f "${cmake_source_dir}/${cmake_problematic_file}"; then
1056 cmake_error 10 "Found \"${cmake_source_dir}/${cmake_problematic_file}\".
1057 Looks like somebody tried to build CMake in the source tree, but now you are
1058 trying to do bootstrap in the binary tree. Please remove \"${cmake_problematic_file}\"
1059 from the source tree."
1064 # Make bootstrap directory
1065 test -d "${cmake_bootstrap_dir}" || mkdir "${cmake_bootstrap_dir}"
1066 if test ! -d "${cmake_bootstrap_dir}"; then
1067 cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake."
1069 cd "${cmake_bootstrap_dir}"
1071 test -d "cmsys" || mkdir "cmsys"
1072 if test ! -d "cmsys"; then
1073 cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys"
1076 # Delete all the bootstrap files
1077 rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log"
1078 rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}"
1079 rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}"
1081 # If building in-source, remove any cmConfigure.h that may
1082 # have been created by a previous run of the bootstrap cmake.
1083 if test -n "${cmake_in_source_build}"; then
1084 rm -f "${cmake_source_dir}/Source/cmConfigure.h"
1087 # If exist compiler flags, set them
1088 cmake_c_flags=${CFLAGS}
1089 cmake_cxx_flags=${CXXFLAGS}
1090 cmake_ld_flags=${LDFLAGS}
1092 # Add generator-specific files
1093 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1094 CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
1095 cmFortranParserImpl \
1096 cmGlobalNinjaGenerator \
1097 cmLocalNinjaGenerator \
1098 cmNinjaLinkLineComputer \
1099 cmNinjaLinkLineDeviceComputer \
1100 cmNinjaNormalTargetGenerator \
1101 cmNinjaTargetGenerator \
1102 cmNinjaUtilityTargetGenerator \
1105 LexerParser_CXX_SOURCES="${LexerParser_CXX_SOURCES} \
1110 CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
1114 cmGlobalUnixMakefileGenerator3 \
1115 cmLocalUnixMakefileGenerator3 \
1116 cmMakefileExecutableTargetGenerator \
1117 cmMakefileLibraryTargetGenerator \
1118 cmMakefileTargetGenerator \
1119 cmMakefileUtilityTargetGenerator \
1124 # Add Cygwin-specific flags
1125 if ${cmake_system_cygwin} || ${cmake_system_msys}; then
1126 cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import"
1129 # Add CoreFoundation framework on Darwin
1130 if ${cmake_system_darwin}; then
1131 cmake_ld_flags="${LDFLAGS} -framework CoreFoundation"
1134 # Add BeOS toolkits...
1135 if ${cmake_system_beos}; then
1136 cmake_ld_flags="${LDFLAGS} -lroot -lbe"
1139 # Add Haiku toolkits...
1140 if ${cmake_system_haiku}; then
1141 cmake_ld_flags="${LDFLAGS} -lroot -lbe"
1144 # Add AIX arch-specific link flags.
1145 if ${cmake_system_aix}; then
1146 if uname -p | grep powerpc >/dev/null 2>&1; then
1147 cmake_ld_flags="${LDFLAGS} -Wl,-bbigtoc"
1151 #-----------------------------------------------------------------------------
1152 # Detect known toolchains on some platforms.
1154 case "${cmake_system}" in
1155 *AIX*) cmake_toolchains='XL GNU
' ;;
1156 *CYGWIN*) cmake_toolchains='GNU
' ;;
1157 *MSYS*) cmake_toolchains='GNU
' ;;
1158 *Darwin*) cmake_toolchains='Clang GNU
' ;;
1159 *Linux*) cmake_toolchains='GNU Clang XL PGI PathScale
' ;;
1160 *MINGW*) cmake_toolchains='GNU
' ;;
1163 # Toolchain compiler name table.
1164 cmake_toolchain_Clang_CC='clang
'
1165 cmake_toolchain_Clang_CXX='clang
++'
1166 cmake_toolchain_GNU_CC='gcc
'
1167 cmake_toolchain_GNU_CXX='g
++'
1168 cmake_toolchain_PGI_CC='pgcc
'
1169 cmake_toolchain_PGI_CXX='pgCC
'
1170 cmake_toolchain_PathScale_CC='pathcc
'
1171 cmake_toolchain_PathScale_CXX='pathCC
'
1172 cmake_toolchain_XL_CC='xlc
'
1173 cmake_toolchain_XL_CXX='xlC
'
1175 cmake_toolchain_try()
1178 TMPFILE=`cmake_tmp_file`
1180 eval "tc_CC=\${cmake_toolchain_${tc}_CC}"
1181 echo 'int main
() { return 0; }' > "${TMPFILE}.c"
1182 cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1
1184 rm -f "${TMPFILE}.c"
1185 test "${tc_result_CC}" = "0" || return 1
1187 eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}"
1188 echo 'int main
() { return 0; }' > "${TMPFILE}.cpp"
1189 cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1
1191 rm -f "${TMPFILE}.cpp"
1192 test "${tc_result_CXX}" = "0" || return 1
1194 cmake_toolchain="$tc"
1197 cmake_toolchain_detect()
1200 for tc in ${cmake_toolchains}; do
1201 echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1
1202 cmake_toolchain_try "$tc" &&
1203 echo "Found $tc toolchain" &&
1208 if test -z "${CC}" && test -z "${CXX}"; then
1209 cmake_toolchain_detect
1213 case "${cmake_system}" in
1214 *AIX*) thread_flags='-pthread' ;;
1217 #-----------------------------------------------------------------------------
1221 # If CC is set, use that for compiler, otherwise use list of known compilers
1222 if test -n "${cmake_toolchain}"; then
1223 eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}"
1225 cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}"
1228 cmake_c_compiler_try_set()
1231 test_thread_flags="$2"
1233 # Check if C compiler works
1234 TMPFILE=`cmake_tmp_file`
1237 # error "The CMAKE_C_COMPILER is set to a C++ compiler"
1240 #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
1241 #error "On AIX with GNU we need the -pthread flag."
1244 #if defined(__sun) && __STDC_VERSION__ < 199901L
1245 #error "On Solaris we need C99."
1248 #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
1249 #error "On HP-UX we need GCC 4.9 or higher."
1254 int main
(int argc
, char
* argv
[])
1256 printf("%d%c", (argv
!= 0), (char
)0x0a);
1260 for std in 11 99 90; do
1261 std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`"
1262 for std_flag in '' $std_flags; do
1263 for thread_flag in '' $test_thread_flags; do
1264 echo "Checking whether '${test_compiler} ${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
1265 if cmake_try_run "${test_compiler}" "${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \
1266 "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then
1267 cmake_c_compiler="${test_compiler}"
1268 cmake_c_flags="${cmake_c_flags} ${std_flag} ${thread_flag}"
1269 rm -f "${TMPFILE}.c"
1275 rm -f "${TMPFILE}.c"
1279 if test -n "${CC}"; then
1280 cmake_c_compiler_try_set "${CC}" "${thread_flags}"
1282 for compiler in ${cmake_c_compilers}; do
1283 if cmake_c_compiler_try_set "${compiler}" "${thread_flags}"; then
1289 if test -z "${cmake_c_compiler}"; then
1290 cmake_error 6 "Cannot find appropriate C compiler on this system.
1291 Please specify one using environment variable CC.
1292 See cmake_bootstrap.log for compilers attempted.
1295 echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}"
1297 #-----------------------------------------------------------------------------
1301 # On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler.
1303 # If CC is set, use that for compiler, otherwise use list of known compilers
1304 if test -n "${cmake_toolchain}"; then
1305 eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}"
1307 cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}"
1310 # Check if C++ compiler works
1311 cmake_cxx_compiler_try_set()
1314 test_thread_flags="$2"
1316 TMPFILE=`cmake_tmp_file`
1320 #include <unordered_map>
1322 #if __cplusplus < 201103L
1323 #error "Compiler is not in a mode aware of C++11."
1326 #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
1327 #error "On AIX with GNU we need the -pthread flag."
1330 #if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5140
1331 #error "SunPro <= 5.13 mode not supported due to bug in move semantics."
1334 #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
1335 #error "On HP-UX we need GCC 4.9 or higher."
1338 #if __cplusplus > 201103L
1342 int a
[] = { 0, 1, 2 };
1343 auto ai
= std
::cbegin
(a
);
1345 int b
[] = { 2, 1, 0 };
1346 auto bi
= std
::cend
(b
);
1348 return *ai
+ *(bi
- 1);
1357 #if (__cplusplus >= 201703L || defined(__INTEL_COMPILER) && defined(__cpp_deduction_guides))
1359 template
<typename T
,
1360 typename std
::invoke_result
<decltype
(&T
::get
), T
>::type = nullptr
>
1361 typename T
::pointer get_ptr
(T
& item
)
1368 // Intel compiler
do not handle correctly
'decltype' inside
'invoke_result'
1369 std
::unique_ptr
<int
> u
(new int
(0));
1371 std
::optional
<int
> oi
= 0;
1384 int Get
() const
{ return this-
>Member
; }
1390 auto const c
= std
::unique_ptr
<Class
>(new Class
);
1391 std
::cout
<< c->Get() << check_cxx14() << check_cxx17() << std::endl;
1394 ' > "${TMPFILE}.cxx"
1395 for std in 17 14 11; do
1396 std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" CXX \"${std}\"`"
1397 for std_flag in '' $std_flags; do
1398 for thread_flag in '' $test_thread_flags; do
1399 echo "Checking whether '${test_compiler} ${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
1400 if cmake_try_run "${test_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \
1401 "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then
1402 cmake_cxx_compiler="${test_compiler}"
1403 cmake_cxx_flags="${cmake_cxx_flags} ${std_flag} ${thread_flag} "
1404 rm -f "${TMPFILE}.cxx"
1410 rm -f "${TMPFILE}.cxx"
1414 if test -n "${CXX}"; then
1415 cmake_cxx_compiler_try_set "${CXX}" "${thread_flags}"
1417 for compiler in ${cmake_cxx_compilers}; do
1418 if cmake_cxx_compiler_try_set "${compiler}" "${thread_flags}"; then
1424 if test -z "${cmake_cxx_compiler}"; then
1425 cmake_error 7 "Cannot find a C++ compiler that supports both C++11 and the specified C++ flags.
1426 Please specify one using environment variable CXX.
1427 The C++ flags are \"$cmake_cxx_flags\".
1428 They can be changed using the environment variable CXXFLAGS.
1429 See cmake_bootstrap.log for compilers attempted."
1431 echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}"
1433 #-----------------------------------------------------------------------------
1436 cmake_cxx_features="make_unique filesystem"
1438 for feature in ${cmake_cxx_features}; do
1439 eval "cmake_have_cxx_${feature}=0"
1440 echo "Checking whether '${cmake_cxx_compiler} ${cmake_cxx_flags} ${cmake_ld_flags}' supports '${feature}'." >> cmake_bootstrap.log 2>&1
1441 if cmake_try_run "${cmake_cxx_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags}" \
1442 "${cmake_source_dir}/Source/Checks/cm_cxx_${feature}.cxx" >> cmake_bootstrap.log 2>&1; then
1443 eval "cmake_have_cxx_${feature}=1"
1447 cmake_have_cxx_features=""
1448 for feature in ${cmake_cxx_features}; do
1449 feature_variable="cmake_have_cxx_${feature}"
1450 eval "feature_value=\${${feature_variable}}"
1451 if test "${feature_value}" -eq "1"; then
1452 cmake_have_cxx_features="${cmake_have_cxx_features} -DCMake_HAVE_CXX_`cmake_toupper ${feature}`=${feature_value}"
1456 cmake_generate_file "${cmake_bootstrap_dir}/cmSTL.hxx" ""
1459 #-----------------------------------------------------------------------------
1462 cmake_make_processor=
1465 # If MAKE is set, use that for make processor, otherwise use list of known make
1466 if test -n "${MAKE}"; then
1467 cmake_make_processors="${MAKE}"
1468 elif test "${cmake_bootstrap_generator}" = "Ninja"; then
1469 cmake_make_processors="${CMAKE_KNOWN_NINJA_PROCESSORS}"
1471 cmake_make_processors="${CMAKE_KNOWN_MAKE_PROCESSORS}"
1474 TMPFILE="`cmake_tmp_file`_dir"
1475 rm -rf "${cmake_bootstrap_dir}/${TMPFILE}"
1476 mkdir "${cmake_bootstrap_dir}/${TMPFILE}"
1477 cd "${cmake_bootstrap_dir}/${TMPFILE}"
1478 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1481 command = '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o $out $in
1482 build test: cc test.c
1487 '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c
1492 int main(){ printf("1%c", (char)0x0a); return 0; }
1494 cmake_original_make_flags="${cmake_make_flags}"
1495 if test "x${cmake_parallel_make}" != "x"; then
1496 cmake_make_flags="${cmake_make_flags} -j ${cmake_parallel_make}"
1498 for a in ${cmake_make_processors}; do
1499 if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then
1500 cmake_make_processor="${a}"
1503 cmake_full_make_flags="${cmake_make_flags}"
1504 if test "x${cmake_original_make_flags}" != "x${cmake_make_flags}"; then
1505 if test -z "${cmake_make_processor}"; then
1506 cmake_make_flags="${cmake_original_make_flags}"
1507 for a in ${cmake_make_processors}; do
1508 if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then
1509 cmake_make_processor="${a}"
1514 cd "${cmake_bootstrap_dir}"
1516 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1521 if test -z "${cmake_make_processor}"; then
1522 cmake_error 8 "Cannot find appropriate ${mf_str} processor on this system.
1523 Please specify one using environment variable MAKE."
1525 rm -rf "${cmake_bootstrap_dir}/${TMPFILE}"
1526 echo "${mf_str} processor on this system is: ${cmake_make_processor}"
1527 if test "x${cmake_full_make_flags}" != "x${cmake_make_flags}"; then
1528 echo "---------------------------------------------"
1529 echo "${mf_str} processor ${cmake_make_processor} does not support parallel build"
1530 echo "---------------------------------------------"
1533 # Test for kwsys features
1534 KWSYS_NAME_IS_KWSYS=0
1535 KWSYS_BUILD_SHARED=0
1536 KWSYS_LFS_AVAILABLE=0
1537 KWSYS_LFS_REQUESTED=0
1538 KWSYS_STL_HAS_WSTRING=0
1539 KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=0
1540 KWSYS_CXX_HAS_SETENV=0
1541 KWSYS_CXX_HAS_UNSETENV=0
1542 KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0
1543 KWSYS_CXX_HAS_UTIMENSAT=0
1544 KWSYS_CXX_HAS_UTIMES=0
1545 KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP=1
1547 if cmake_try_run "${cmake_cxx_compiler}" \
1548 "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_SETENV" \
1549 "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1550 KWSYS_CXX_HAS_SETENV=1
1551 echo "${cmake_cxx_compiler} has setenv"
1553 echo "${cmake_cxx_compiler} does not have setenv"
1556 if cmake_try_run "${cmake_cxx_compiler}" \
1557 "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_UNSETENV" \
1558 "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1559 KWSYS_CXX_HAS_UNSETENV=1
1560 echo "${cmake_cxx_compiler} has unsetenv"
1562 echo "${cmake_cxx_compiler} does not have unsetenv"
1565 if cmake_try_run "${cmake_cxx_compiler}" \
1566 "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H" \
1567 "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1568 KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=1
1569 echo "${cmake_cxx_compiler} has environ in stdlib.h"
1571 echo "${cmake_cxx_compiler} does not have environ in stdlib.h"
1574 if cmake_try_run "${cmake_cxx_compiler}" \
1575 "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_STL_HAS_WSTRING" \
1576 "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1577 KWSYS_STL_HAS_WSTRING=1
1578 echo "${cmake_cxx_compiler} has stl wstring"
1580 echo "${cmake_cxx_compiler} does not have stl wstring"
1583 if cmake_try_run "${cmake_cxx_compiler}" \
1584 "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H" \
1585 "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1586 KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=1
1587 echo "${cmake_cxx_compiler} has <ext/stdio_filebuf.h>"
1589 echo "${cmake_cxx_compiler} does not have <ext/stdio_filebuf.h>"
1592 if test -n "${cmake_ccache_enabled}"; then
1593 echo "Building CMake with ccache"
1594 cmake_c_compiler="ccache ${cmake_c_compiler}"
1595 cmake_cxx_compiler="ccache ${cmake_cxx_compiler}"
1598 # Just to be safe, let us store compiler and flags to the header file
1600 cmake_bootstrap_version='$Revision$'
1601 cmake_compiler_settings_comment="/*
1602 * Generated by ${cmake_source_dir}/bootstrap
1603 * Version: ${cmake_bootstrap_version}
1605 * Source directory: ${cmake_source_dir}
1606 * Binary directory: ${cmake_bootstrap_dir}
1608 * C compiler: ${cmake_c_compiler}
1609 * C flags: ${cmake_c_flags}
1611 * C++ compiler: ${cmake_cxx_compiler}
1612 * C++ flags: ${cmake_cxx_flags}
1614 * Make: ${cmake_make_processor}
1617 * ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES}
1619 * ${CMAKE_STD_CXX_HEADERS} ${CMAKE_STD_CXX_SOURCES}
1620 * LexerParser Sources:
1621 * ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES}
1623 * ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES}
1625 * ${LIBUV_C_SOURCES}
1627 * ${JSONCPP_CXX_SOURCES}
1629 * ${LIBRHASH_C_SOURCES}
1633 cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}"
1635 # When bootstrapping on MinGW with MSYS we must convert the source
1636 # directory to a windows path.
1637 if ${cmake_system_mingw}; then
1638 CMAKE_BOOTSTRAP_SOURCE_DIR=`cd "${cmake_source_dir}"; pwd -W`
1639 CMAKE_BOOTSTRAP_BINARY_DIR=`cd "${cmake_binary_dir}"; pwd -W`
1641 CMAKE_BOOTSTRAP_SOURCE_DIR="${cmake_source_dir}"
1642 CMAKE_BOOTSTRAP_BINARY_DIR="${cmake_binary_dir}"
1645 # Write CMake version
1646 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MAJOR ${cmake_version_major}"
1647 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MINOR ${cmake_version_minor}"
1648 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_PATCH ${cmake_version_patch}"
1649 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION \"${cmake_version}\""
1650 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_SOURCE_DIR \"${CMAKE_BOOTSTRAP_SOURCE_DIR}\""
1651 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_BINARY_DIR \"${CMAKE_BOOTSTRAP_BINARY_DIR}\""
1652 cmake_report cmConfigure.h${_tmp} "#define CMake_DEFAULT_RECURSION_LIMIT 400"
1653 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insalled\""
1654 cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\""
1655 cmake_report cmConfigure.h${_tmp} "#define CM_FALLTHROUGH"
1657 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1658 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_NINJA"
1660 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_MAKEFILES"
1663 if ${cmake_system_mingw}; then
1664 cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(NOMINMAX)"
1665 cmake_report cmConfigure.h${_tmp} "# define NOMINMAX"
1666 cmake_report cmConfigure.h${_tmp} "#endif"
1667 cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(KWSYS_ENCODING_DEFAULT_CODEPAGE)"
1668 cmake_report cmConfigure.h${_tmp} "# define KWSYS_ENCODING_DEFAULT_CODEPAGE CP_UTF8"
1669 cmake_report cmConfigure.h${_tmp} "#endif"
1672 # Regenerate configured headers
1673 for h in Configure VersionConfig; do
1674 if "${_diff}" cm${h}.h cm${h}.h${_tmp} > /dev/null 2> /dev/null; then
1675 rm -f cm${h}.h${_tmp}
1677 mv -f cm${h}.h${_tmp} cm${h}.h
1682 cmsys_header_files="cmsys/Configure.h cmsys/Configure.hxx"
1683 cmake_kwsys_config_replace_string \
1684 "${cmake_source_dir}/Source/kwsys/Configure.hxx.in" \
1685 "${cmake_bootstrap_dir}/cmsys/Configure.hxx" \
1686 "${cmake_compiler_settings_comment}"
1687 cmake_kwsys_config_replace_string \
1688 "${cmake_source_dir}/Source/kwsys/Configure.h.in" \
1689 "${cmake_bootstrap_dir}/cmsys/Configure.h" \
1690 "${cmake_compiler_settings_comment}"
1692 for a in ${KWSYS_FILES}; do
1693 cmake_replace_string "${cmake_source_dir}/Source/kwsys/${a}.in" \
1694 "${cmake_bootstrap_dir}/cmsys/${a}" KWSYS_NAMESPACE cmsys
1695 cmsys_header_files="${cmsys_header_files} cmsys/${a}"
1698 echo "#pragma once" > "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1699 if test "x${bootstrap_system_libuv}" != "x"; then
1700 echo "#define CMAKE_USE_SYSTEM_LIBUV" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1702 if test "x${bootstrap_system_jsoncpp}" != "x"; then
1703 echo "#define CMAKE_USE_SYSTEM_JSONCPP" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1705 if test "x${bootstrap_system_librhash}" != "x"; then
1706 echo "#define CMAKE_USE_SYSTEM_LIBRHASH" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1708 cmake_generate_file_tmp "${cmake_bootstrap_dir}/cmThirdParty.h" "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1711 dep="cmConfigure.h ${cmsys_header_files}"
1712 for h in "${cmake_source_dir}"/Source/*.hxx; do
1713 dep="${dep} `cmake_escape_artifact \"${h}\"`"
1715 for h in "${cmake_source_dir}"/Source/*.h; do
1716 dep="${dep} `cmake_escape_artifact \"${h}\"`"
1718 for h in ${CMAKE_STD_CXX_HEADERS}; do
1719 dep="${dep} `cmake_escape_artifact \"${cmake_source_dir}\"`/Utilities/std/cm/${h}"
1722 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
1723 objs="${objs} ${a}.o"
1725 if test "x${bootstrap_system_libuv}" = "x"; then
1726 for a in ${LIBUV_C_SOURCES}; do
1727 objs="${objs} uv-`cmake_obj ${a}`"
1730 if test "x${bootstrap_system_librhash}" = "x"; then
1731 for a in ${LIBRHASH_C_SOURCES}; do
1732 objs="${objs} rhash-`cmake_obj ${a}`"
1735 if test "x${bootstrap_system_jsoncpp}" = "x"; then
1736 for a in ${JSONCPP_CXX_SOURCES}; do
1737 objs="${objs} jsoncpp-`cmake_obj ${a}`"
1744 if ${cmake_system_mingw}; then
1745 uv_c_flags="${uv_c_flags} -DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0600"
1746 libs="${libs} -lws2_32 -lpsapi -liphlpapi -lshell32 -luserenv -lole32 -loleaut32"
1748 case "${cmake_system}" in
1750 uv_c_flags="${uv_c_flags} -D_ALL_SOURCE -D_XOPEN_SOURCE=500 -D_LINUX_SOURCE_COMPAT"
1751 libs="${libs} -lperfstat"
1754 uv_c_flags="${uv_c_flags} -D_DARWIN_USE_64_BIT_INODE=1 -D_DARWIN_UNLIMITED_SELECT=1"
1757 uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE_EXTENDED"
1760 uv_c_flags="${uv_c_flags} -D_GNU_SOURCE"
1761 libs="${libs} -ldl -lrt"
1764 libs="${libs} -lkvm -lfreebsd-glue"
1767 libs="${libs} -lkvm"
1770 uv_c_flags="${uv_c_flags} -D__EXTENSIONS__ -D_XOPEN_SOURCE=600"
1771 libs="${libs} -lkstat -lnsl -lsendfile -lsocket -lrt"
1774 uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE=700"
1775 libs="${libs} -lsocket"
1779 if test "x${bootstrap_system_libuv}" = "x"; then
1780 uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/include"`"
1781 if ${cmake_system_mingw}; then
1782 uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/win"`"
1784 uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/unix"`"
1786 uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src"`"
1788 if test `which pkg-config`; then
1789 use_uv_flags="`pkg-config --cflags libuv`"
1790 use_uv_ldflags="`pkg-config --libs libuv`"
1791 cmake_c_flags="${cmake_c_flags} ${use_uv_flags}"
1792 cmake_cxx_flags="${cmake_cxx_flags} ${use_uv_flags}"
1794 use_librhash_ldflags="-luv"
1796 libs="${libs} ${use_uv_ldflags}"
1799 librhash_c_flags="-DNO_IMPORT_EXPORT"
1800 if test "x${bootstrap_system_librhash}" != "x"; then
1801 if test `which pkg-config`; then
1802 use_librhash_flags="`pkg-config --cflags librhash`"
1803 use_librhash_ldflags="`pkg-config --libs librhash`"
1804 cmake_c_flags="${cmake_c_flags} ${use_librhash_flags}"
1805 cmake_cxx_flags="${cmake_cxx_flags} ${use_librhash_flags}"
1807 use_librhash_ldflags="-lrhash"
1809 libs="${libs} ${use_librhash_ldflags}"
1813 if test "x${bootstrap_system_jsoncpp}" = "x"; then
1814 jsoncpp_cxx_flags="${jsoncpp_cxx_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmjsoncpp/include"`"
1816 if test `which pkg-config`; then
1817 use_jsoncpp_flags="`pkg-config --cflags jsoncpp`"
1818 use_jsoncpp_ldflags="`pkg-config --libs jsoncpp`"
1819 cmake_cxx_flags="${cmake_cxx_flags} ${use_jsoncpp_flags}"
1821 use_librhash_ldflags="-ljsoncpp"
1823 libs="${libs} ${use_jsoncpp_ldflags}"
1826 if test "x${cmake_ansi_cxx_flags}" != "x"; then
1827 cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}"
1831 case "${cmake_system}" in
1832 # Ensure filesystem access uses 64-bit offsets even on 32-bit hosts.
1833 *Linux*) system_flags='-D_FILE_OFFSET_BITS=64' ;;
1835 if test "x${system_flags}" != "x"; then
1836 cmake_c_flags="${cmake_c_flags} ${system_flags}"
1837 cmake_cxx_flags="${cmake_cxx_flags} ${system_flags}"
1840 if test "x${cmake_c_flags}" != "x"; then
1841 cmake_c_flags="${cmake_c_flags} "
1844 if test "x${cmake_cxx_flags}" != "x"; then
1845 cmake_cxx_flags="${cmake_cxx_flags} "
1848 write_source_rule() {
1854 if test "${lang}" = "c"; then
1856 compiler="${cmake_c_compiler}"
1857 flags="${cmake_c_flags}"
1858 elif test "${lang}" = "cxx"; then
1860 compiler="${cmake_cxx_compiler}"
1861 flags="${cmake_cxx_flags}"
1864 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1865 echo "build ${obj} : ${ninja_rule} ${src} | ${dep}" >> "${cmake_bootstrap_dir}/build.ninja"
1866 echo " srcflags = ${src_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1868 echo "${obj} : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile"
1869 echo " ${compiler} ${flags} ${src_flags} -c ${src} -o ${obj}" >> "${cmake_bootstrap_dir}/Makefile"
1873 cmake_c_flags_String="-DKWSYS_STRING_C"
1874 if ${cmake_system_mingw}; then
1875 cmake_c_flags_EncodingC="-DKWSYS_ENCODING_DEFAULT_CODEPAGE=CP_ACP"
1876 cmake_cxx_flags_EncodingCXX="${cmake_c_flags_EncodingC}"
1877 cmake_cxx_flags_cmProcessOutput="${cmake_c_flags_EncodingC}"
1879 cmake_cxx_flags_SystemTools="
1880 -DKWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV}
1881 -DKWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV}
1882 -DKWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H}
1883 -DKWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT}
1884 -DKWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES}
1886 cmake_c_flags="${cmake_c_flags} \
1888 -I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \
1889 -I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \
1890 -I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \
1891 -I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`"
1892 cmake_cxx_flags="${cmake_cxx_flags} \
1894 ${cmake_have_cxx_features} \
1895 -I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \
1896 -I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \
1897 -I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \
1898 -I`cmake_escape_shell \"${cmake_source_dir}/Utilities/std\"` \
1899 -I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`"
1900 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1901 echo "cc = ${cmake_c_compiler}" > "${cmake_bootstrap_dir}/build.ninja"
1902 echo "cxx = ${cmake_cxx_compiler}" >> "${cmake_bootstrap_dir}/build.ninja"
1903 echo "cflags = ${cmake_c_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1904 echo "cxxflags = ${cmake_cxx_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1905 echo "ldflags = ${cmake_ld_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1906 echo "rule cc" >> "${cmake_bootstrap_dir}/build.ninja"
1907 echo " command = \$cc \$cflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
1908 echo "rule cxx" >> "${cmake_bootstrap_dir}/build.ninja"
1909 echo " command = \$cxx \$cxxflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
1910 echo "rule link" >> "${cmake_bootstrap_dir}/build.ninja"
1911 echo " command = \$cxx \$ldflags \$cxxflags \$in \$libs -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
1912 echo "build cmake: link ${objs}" >> "${cmake_bootstrap_dir}/build.ninja"
1913 echo " libs = ${libs}" >> "${cmake_bootstrap_dir}/build.ninja"
1915 echo "cmake: ${objs}" > "${cmake_bootstrap_dir}/Makefile"
1916 echo " ${cmake_cxx_compiler} ${cmake_ld_flags} ${cmake_cxx_flags} ${objs} ${libs} -o cmake" >> "${cmake_bootstrap_dir}/Makefile"
1918 for a in ${CMAKE_CXX_SOURCES}; do
1919 src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.cxx"`
1920 src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
1921 write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1923 for a in ${CMAKE_C_SOURCES}; do
1924 src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.c"`
1925 write_source_rule "c" "${a}.o" "${src}" ""
1927 for a in ${CMAKE_STD_CXX_SOURCES}; do
1928 src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/std/cm/bits/${a}.cxx"`
1929 src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
1930 write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1932 for a in ${LexerParser_CXX_SOURCES}; do
1933 src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.cxx"`
1934 src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
1935 write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1937 for a in ${LexerParser_C_SOURCES}; do
1938 src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.c"`
1939 write_source_rule "c" "${a}.o" "${src}" ""
1941 for a in ${KWSYS_C_SOURCES}; do
1942 src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.c"`
1943 src_flags="`eval echo \\${cmake_c_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys"
1944 write_source_rule "c" "${a}.o" "${src}" "${src_flags}"
1946 for a in ${KWSYS_CXX_SOURCES}; do
1947 src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.cxx"`
1948 src_flags="`eval echo \\${cmake_cxx_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys"
1949 write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1951 if test "x${bootstrap_system_libuv}" = "x"; then
1952 for a in ${LIBUV_C_SOURCES}; do
1953 src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibuv/${a}"`
1954 write_source_rule "c" "uv-`cmake_obj ${a}`" "${src}" "${uv_c_flags}"
1957 if test "x${bootstrap_system_librhash}" = "x"; then
1958 for a in ${LIBRHASH_C_SOURCES}; do
1959 src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibrhash/${a}"`
1960 write_source_rule "c" "rhash-`cmake_obj ${a}`" "${src}" "${librhash_c_flags}"
1963 if test "x${bootstrap_system_jsoncpp}" = "x"; then
1964 for a in ${JSONCPP_CXX_SOURCES}; do
1965 src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmjsoncpp/${a}"`
1966 write_source_rule "cxx" "jsoncpp-`cmake_obj ${a}`" "${src}" "${jsoncpp_cxx_flags}"
1969 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1972 command = cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
1974 build build.ninja : rebuild_cache
1975 " >> "${cmake_bootstrap_dir}/build.ninja"
1979 cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
1980 " >> "${cmake_bootstrap_dir}/Makefile"
1983 # Write our default settings to Bootstrap${_cmk}/InitialCacheFlags.cmake.
1985 # Generated by '"${cmake_source_dir}"'/bootstrap
1986 # Default cmake settings. These may be overridden any settings below.
1987 set (CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build.") # not FORCE to preserve defaults specified elsewhere
1988 set (CMAKE_INSTALL_PREFIX "'"${cmake_prefix_dir}"'" CACHE PATH "Install path prefix, prepended onto install directories." FORCE)
1989 set (CMAKE_DOC_DIR "'"${cmake_doc_dir}"'" CACHE PATH "Install location for documentation (relative to prefix)." FORCE)
1990 set (CMAKE_MAN_DIR "'"${cmake_man_dir}"'" CACHE PATH "Install location for man pages (relative to prefix)." FORCE)
1991 set (CMAKE_BIN_DIR "'"${cmake_bin_dir}"'" CACHE PATH "Install location for binaries (relative to prefix)." FORCE)
1992 set (CMAKE_DATA_DIR "'"${cmake_data_dir}"'" CACHE PATH "Install location for data (relative to prefix)." FORCE)
1993 set (CMAKE_XDGDATA_DIR "'"${cmake_xdgdata_dir}"'" CACHE PATH "Install location for XDG specific files (relative to prefix)." FORCE)
1994 ' > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1996 # Add configuration settings given as command-line options.
1997 if test "x${cmake_bootstrap_qt_gui}" != "x"; then
1999 set (BUILD_QtDialog '"${cmake_bootstrap_qt_gui}"' CACHE BOOL "Build Qt dialog for CMake" FORCE)
2000 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2002 if test "x${cmake_bootstrap_qt_qmake}" != "x"; then
2004 set (QT_QMAKE_EXECUTABLE "'"${cmake_bootstrap_qt_qmake}"'" CACHE FILEPATH "Location of Qt qmake" FORCE)
2005 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2007 if test "x${cmake_bootstrap_debugger}" != "x"; then
2009 set (CMake_ENABLE_DEBUGGER '"${cmake_bootstrap_debugger}"' CACHE BOOL "Enable CMake debugger support" FORCE)
2010 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2012 if test "x${cmake_sphinx_info}" != "x"; then
2014 set (SPHINX_INFO "'"${cmake_sphinx_info}"'" CACHE BOOL "Build Info manual with Sphinx" FORCE)
2015 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2017 if test "x${cmake_sphinx_man}" != "x"; then
2019 set (SPHINX_MAN "'"${cmake_sphinx_man}"'" CACHE BOOL "Build man pages with Sphinx" FORCE)
2020 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2022 if test "x${cmake_sphinx_html}" != "x"; then
2024 set (SPHINX_HTML "'"${cmake_sphinx_html}"'" CACHE BOOL "Build html help with Sphinx" FORCE)
2025 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2027 if test "x${cmake_sphinx_qthelp}" != "x"; then
2029 set (SPHINX_QTHELP "'"${cmake_sphinx_qthelp}"'" CACHE BOOL "Build qch help with Sphinx" FORCE)
2030 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2032 if test "x${cmake_sphinx_latexpdf}" != "x"; then
2034 set (SPHINX_LATEXPDF "'"${cmake_sphinx_latexpdf}"'" CACHE BOOL "Build PDF help with Sphinx using LaTeX" FORCE)
2035 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2037 if test "x${cmake_sphinx_build}" != "x"; then
2039 set (SPHINX_EXECUTABLE "'"${cmake_sphinx_build}"'" CACHE FILEPATH "Location of Qt sphinx-build" FORCE)
2040 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2042 if test "x${cmake_sphinx_flags}" != "x"; then
2044 set (SPHINX_FLAGS [==['"${cmake_sphinx_flags}"']==] CACHE STRING "Flags to pass to sphinx-build" FORCE)
2045 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2048 # Add user-specified settings. Handle relative-path case for
2049 # specification of cmake_init_file.
2051 cd "${cmake_binary_dir}"
2052 if test -f "${cmake_init_file}"; then
2053 cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2057 echo "---------------------------------------------"
2059 # Run make to build bootstrap cmake
2060 if test "${cmake_bootstrap_generator}" = "Ninja"; then
2065 if test "x${cmake_parallel_make}" != "x"; then
2066 ${cmake_make_processor} ${cmake_make_flags} ${ninja_v}
2068 ${cmake_make_processor} ${ninja_v}
2071 if test "${RES}" -ne "0"; then
2072 cmake_error 9 "Problem while running ${cmake_make_processor}"
2074 cd "${cmake_binary_dir}"
2076 # Set C, CXX, and MAKE environment variables, so that real real cmake will be
2077 # build with same compiler and make
2078 CC="${cmake_c_compiler}"
2079 CXX="${cmake_cxx_compiler}"
2080 MAKE="${cmake_make_processor}"
2088 # Run bootstrap CMake to configure real CMake
2089 cmake_options="-DCMAKE_BOOTSTRAP=1"
2090 if test -n "${cmake_verbose}"; then
2091 cmake_options="${cmake_options} -DCMAKE_VERBOSE_MAKEFILE=1"
2093 "${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" ${cmake_options} ${cmake_bootstrap_system_libs} "$@"
2095 if test "${RES}" -ne "0"; then
2096 cmake_error 11 "Problem while running initial CMake"
2099 echo "---------------------------------------------"
2101 # And we are done. Now just run make
2102 echo "CMake has bootstrapped. Now run ${cmake_make_processor}."