bootstrap

   1 #!/bin/sh
   2 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   3 # file Copyright.txt or https://cmake.org/licensing for details.
   4
   5 die() {
   6   echo "$@" 1>&2 ; exit 1
   7 }
   8
   9 # Compile flag extraction function.
  10 cmake_extract_standard_flags()
  11 {
  12   id="${1:-*}"
  13   lang="${2}"
  14   ver="${3}"
  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 ';' ' '
  22 }
  23
  24 # Version number extraction function.
  25 cmake_version_component()
  26 {
  27   sed -n "
  28 /^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\)).*/\1/;p;}
  29 " "${cmake_source_dir}/Source/CMakeVersion.cmake"
  30 }
  31
  32 # Install destination extraction function.
  33 cmake_install_dest_default()
  34 {
  35   sed -n '
  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}"'/
  41   p
  42   q
  43 }
  44 ' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake"
  45 }
  46
  47 cmake_toupper()
  48 {
  49     echo "$1" | tr '[a-z]' '[A-Z]'
  50 }
  51
  52 # Detect system and directory information.
  53 cmake_system=`uname`
  54 cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd`
  55 cmake_binary_dir=`pwd`
  56
  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}"
  65 fi
  66
  67 cmake_copyright="`grep '^Copyright .* Kitware' "${cmake_source_dir}/Copyright.txt"`"
  68
  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"
  74 cmake_bin_dir=""
  75 cmake_data_dir=""
  76 cmake_doc_dir=""
  77 cmake_man_dir=""
  78 cmake_xdgdata_dir=""
  79 cmake_init_file=""
  80 cmake_bootstrap_system_libs=""
  81 cmake_bootstrap_qt_gui=""
  82 cmake_bootstrap_qt_qmake=""
  83 cmake_bootstrap_debugger=""
  84 cmake_sphinx_info=""
  85 cmake_sphinx_man=""
  86 cmake_sphinx_html=""
  87 cmake_sphinx_qthelp=""
  88 cmake_sphinx_latexpdf=""
  89 cmake_sphinx_build=""
  90 cmake_sphinx_flags=""
  91
  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"
  97 else
  98   cmake_system_cygwin=false
  99 fi
 100
 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"
 106 else
 107   cmake_system_msys=false
 108 fi
 109
 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
 113 else
 114   cmake_system_mingw=false
 115 fi
 116
 117 # Determine whether this is OS X
 118 if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then
 119   cmake_system_darwin=true
 120 else
 121   cmake_system_darwin=false
 122 fi
 123
 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"
 129 else
 130   cmake_system_beos=false
 131 fi
 132
 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"
 138 else
 139   cmake_system_haiku=false
 140 fi
 141
 142 # Determine whether this is OpenVMS
 143 if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then
 144   cmake_system_openvms=true
 145 else
 146   cmake_system_openvms=false
 147 fi
 148
 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
 152
 153   https://gitlab.kitware.com/cmake/cmake/-/issues/17137
 154
 155 Use CMake 3.9 or lower instead.'
 156   cmake_system_hpux=true
 157 else
 158   cmake_system_hpux=false
 159 fi
 160
 161 # Determine whether this is AIX
 162 if echo "${cmake_system}" | grep AIX >/dev/null 2>&1; then
 163   cmake_system_aix=true
 164 else
 165   cmake_system_aix=false
 166 fi
 167
 168 # Determine whether this is Linux
 169 if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then
 170   cmake_system_linux=true
 171 else
 172   cmake_system_linux=false
 173 fi
 174
 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
 182   fi
 183 elif ${cmake_system_hpux}; then
 184   if uname -m | grep ia64 >/dev/null 2>&1; then : ; else
 185     cmake_machine_parisc=true
 186   fi
 187 fi
 188
 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"
 193 else
 194   # Bootstrapping from a standard UNIX prompt.
 195   cmake_bootstrap_generator="Unix Makefiles"
 196 fi
 197
 198 # Choose tools and extensions for this platform.
 199 if ${cmake_system_openvms}; then
 200   _tmp="_tmp"
 201   _cmk="_cmk"
 202   _diff=`which diff`
 203 else
 204   _tmp=".tmp"
 205   _cmk=".cmk"
 206   _diff="diff"
 207 fi
 208
 209 # Construct bootstrap directory name.
 210 cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}"
 211
 212 # Helper function to fix windows paths.
 213 case "${cmake_system}" in
 214 *MINGW*)
 215   cmake_fix_slashes()
 216   {
 217     cmd //c echo "$(echo "$1" | sed 's/\\/\//g')" | sed 's/^"//;s/" *$//'
 218   }
 219   ;;
 220 *)
 221   cmake_fix_slashes()
 222   {
 223     echo "$1" | sed 's/\\/\//g'
 224   }
 225   ;;
 226 esac
 227
 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"`
 238   else
 239     cmake_default_prefix="c:/Program Files/CMake"
 240   fi
 241 elif ${cmake_system_haiku}; then
 242   cmake_default_prefix=`finddir B_COMMON_DIRECTORY`
 243 else
 244   cmake_default_prefix="/usr/local"
 245 fi
 246
 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}`"
 253
 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"
 258
 259 CMAKE_PROBLEMATIC_FILES="\
 260   CMakeCache.txt \
 261   CMakeSystem.cmake \
 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 \
 274   "
 275
 276 CMAKE_UNUSED_SOURCES="\
 277   cmGlobalXCodeGenerator \
 278   cmLocalXCodeGenerator \
 279   cmXCodeObject \
 280   cmXCode21Object \
 281   cmSourceGroup \
 282 "
 283
 284 CMAKE_CXX_SOURCES="\
 285   cmAddCompileDefinitionsCommand \
 286   cmAddCustomCommandCommand \
 287   cmAddCustomTargetCommand \
 288   cmAddDefinitionsCommand \
 289   cmAddDependenciesCommand \
 290   cmAddExecutableCommand \
 291   cmAddLibraryCommand \
 292   cmAddSubDirectoryCommand \
 293   cmAddTestCommand \
 294   cmArgumentParser \
 295   cmBinUtilsLinker \
 296   cmBinUtilsLinuxELFGetRuntimeDependenciesTool \
 297   cmBinUtilsLinuxELFLinker \
 298   cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool \
 299   cmBinUtilsMacOSMachOGetRuntimeDependenciesTool \
 300   cmBinUtilsMacOSMachOLinker \
 301   cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool \
 302   cmBinUtilsWindowsPEGetRuntimeDependenciesTool \
 303   cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool \
 304   cmBinUtilsWindowsPELinker \
 305   cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool \
 306   cmBlockCommand \
 307   cmBreakCommand \
 308   cmBuildCommand \
 309   cmCMakeLanguageCommand \
 310   cmCMakeMinimumRequired \
 311   cmList \
 312   cmCMakePath \
 313   cmCMakePathCommand \
 314   cmCMakePolicyCommand \
 315   cmCPackPropertiesGenerator \
 316   cmCacheManager \
 317   cmCommand \
 318   cmCommandArgumentParserHelper \
 319   cmCommands \
 320   cmCommonTargetGenerator \
 321   cmComputeComponentGraph \
 322   cmComputeLinkDepends \
 323   cmComputeLinkInformation \
 324   cmComputeTargetDepends \
 325   cmConsoleBuf \
 326   cmConditionEvaluator \
 327   cmConfigureFileCommand \
 328   cmContinueCommand \
 329   cmCoreTryCompile \
 330   cmCreateTestSourceList \
 331   cmCryptoHash \
 332   cmCustomCommand \
 333   cmCustomCommandGenerator \
 334   cmCustomCommandLines \
 335   cmCxxModuleMapper \
 336   cmCxxModuleUsageEffects \
 337   cmDefinePropertyCommand \
 338   cmDefinitions \
 339   cmDocumentationFormatter \
 340   cmELF \
 341   cmEnableLanguageCommand \
 342   cmEnableTestingCommand \
 343   cmEvaluatedTargetProperty \
 344   cmExecProgramCommand \
 345   cmExecuteProcessCommand \
 346   cmExpandedCommandArgument \
 347   cmExperimental \
 348   cmExportBuildFileGenerator \
 349   cmExportFileGenerator \
 350   cmExportInstallFileGenerator \
 351   cmExportSet \
 352   cmExportTryCompileFileGenerator \
 353   cmExprParserHelper \
 354   cmExternalMakefileProjectGenerator \
 355   cmFileCommand \
 356   cmFileCopier \
 357   cmFileInstaller \
 358   cmFileSet \
 359   cmFileTime \
 360   cmFileTimeCache \
 361   cmFileTimes \
 362   cmFindBase \
 363   cmFindCommon \
 364   cmFindFileCommand \
 365   cmFindLibraryCommand \
 366   cmFindPackageCommand \
 367   cmFindPackageStack \
 368   cmFindPathCommand \
 369   cmFindProgramCommand \
 370   cmForEachCommand \
 371   cmFunctionBlocker \
 372   cmFunctionCommand \
 373   cmFSPermissions \
 374   cmGeneratedFileStream \
 375   cmGeneratorExpression \
 376   cmGeneratorExpressionContext \
 377   cmGeneratorExpressionDAGChecker \
 378   cmGeneratorExpressionEvaluationFile \
 379   cmGeneratorExpressionEvaluator \
 380   cmGeneratorExpressionLexer \
 381   cmGeneratorExpressionNode \
 382   cmGeneratorExpressionParser \
 383   cmGeneratorTarget \
 384   cmGetCMakePropertyCommand \
 385   cmGetDirectoryPropertyCommand \
 386   cmGetFilenameComponentCommand \
 387   cmGetPipes \
 388   cmGetPropertyCommand \
 389   cmGetSourceFilePropertyCommand \
 390   cmGetTargetPropertyCommand \
 391   cmGetTestPropertyCommand \
 392   cmGlobalCommonGenerator \
 393   cmGlobalGenerator \
 394   cmGlobVerificationManager \
 395   cmHexFileConverter \
 396   cmIfCommand \
 397   cmImportedCxxModuleInfo \
 398   cmIncludeCommand \
 399   cmIncludeGuardCommand \
 400   cmIncludeDirectoryCommand \
 401   cmIncludeRegularExpressionCommand \
 402   cmInstallCommand \
 403   cmInstallCommandArguments \
 404   cmInstallCxxModuleBmiGenerator \
 405   cmInstallDirectoryGenerator \
 406   cmInstallExportGenerator \
 407   cmInstallFileSetGenerator \
 408   cmInstallFilesCommand \
 409   cmInstallFilesGenerator \
 410   cmInstallGenerator \
 411   cmInstallGetRuntimeDependenciesGenerator \
 412   cmInstallImportedRuntimeArtifactsGenerator \
 413   cmInstallRuntimeDependencySet \
 414   cmInstallRuntimeDependencySetGenerator \
 415   cmInstallScriptGenerator \
 416   cmInstallSubdirectoryGenerator \
 417   cmInstallTargetGenerator \
 418   cmInstallTargetsCommand \
 419   cmInstalledFile \
 420   cmJSONHelpers \
 421   cmJSONState \
 422   cmLDConfigLDConfigTool \
 423   cmLDConfigTool \
 424   cmLinkDirectoriesCommand \
 425   cmLinkItem \
 426   cmLinkItemGraphVisitor \
 427   cmLinkLineComputer \
 428   cmLinkLineDeviceComputer \
 429   cmListCommand \
 430   cmListFileCache \
 431   cmLocalCommonGenerator \
 432   cmLocalGenerator \
 433   cmMSVC60LinkLineComputer \
 434   cmMacroCommand \
 435   cmMakeDirectoryCommand \
 436   cmMakefile \
 437   cmMarkAsAdvancedCommand \
 438   cmMathCommand \
 439   cmMessageCommand \
 440   cmMessenger \
 441   cmNewLineStyle \
 442   cmOSXBundleGenerator \
 443   cmOptionCommand \
 444   cmOrderDirectories \
 445   cmOutputConverter \
 446   cmParseArgumentsCommand \
 447   cmPathLabel \
 448   cmPolicies \
 449   cmProcessOutput \
 450   cmProjectCommand \
 451   cmValue \
 452   cmPropertyDefinition \
 453   cmPropertyMap \
 454   cmGccDepfileLexerHelper \
 455   cmGccDepfileReader \
 456   cmReturnCommand \
 457   cmPlaceholderExpander \
 458   cmPlistParser \
 459   cmRulePlaceholderExpander \
 460   cmRuntimeDependencyArchive \
 461   cmScriptGenerator \
 462   cmSearchPath \
 463   cmSeparateArgumentsCommand \
 464   cmSetCommand \
 465   cmSetDirectoryPropertiesCommand \
 466   cmSetPropertyCommand \
 467   cmSetSourceFilesPropertiesCommand \
 468   cmSetTargetPropertiesCommand \
 469   cmSetTestsPropertiesCommand \
 470   cmSiteNameCommand \
 471   cmSourceFile \
 472   cmSourceFileLocation \
 473   cmStandardLevelResolver \
 474   cmState \
 475   cmStateDirectory \
 476   cmStateSnapshot \
 477   cmString \
 478   cmStringAlgorithms \
 479   cmStringReplaceHelper \
 480   cmStringCommand \
 481   cmSubcommandTable \
 482   cmSubdirCommand \
 483   cmSystemTools \
 484   cmTarget \
 485   cmTargetCompileDefinitionsCommand \
 486   cmTargetCompileFeaturesCommand \
 487   cmTargetCompileOptionsCommand \
 488   cmTargetIncludeDirectoriesCommand \
 489   cmTargetLinkLibrariesCommand \
 490   cmTargetLinkOptionsCommand \
 491   cmTargetPrecompileHeadersCommand \
 492   cmTargetPropCommandBase \
 493   cmTargetPropertyComputer \
 494   cmTargetSourcesCommand \
 495   cmTest \
 496   cmTestGenerator \
 497   cmTimestamp \
 498   cmTransformDepfile \
 499   cmTryCompileCommand \
 500   cmTryRunCommand \
 501   cmUnsetCommand \
 502   cmUVHandlePtr \
 503   cmUVProcessChain \
 504   cmVersion \
 505   cmWhileCommand \
 506   cmWindowsRegistry \
 507   cmWorkingDirectory \
 508   cmXcFramework \
 509   cmake  \
 510   cmakemain \
 511   cmcmd  \
 512   cm_fileno \
 513 "
 514
 515 if ${cmake_system_mingw}; then
 516   CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
 517     cmGlobalMSYSMakefileGenerator \
 518     cmGlobalMinGWMakefileGenerator \
 519     cmVSSetupHelper \
 520   "
 521 fi
 522
 523 CMAKE_STD_CXX_HEADERS="\
 524   filesystem \
 525   memory \
 526   optional \
 527   shared_mutex \
 528   string_view \
 529   utility \
 530 "
 531 CMAKE_STD_CXX_SOURCES="\
 532   fs_path \
 533   string_view \
 534 "
 535
 536 LexerParser_CXX_SOURCES="\
 537   cmCommandArgumentLexer \
 538   cmCommandArgumentParser \
 539   cmExprLexer \
 540   cmExprParser \
 541   cmGccDepfileLexer \
 542 "
 543
 544 LexerParser_C_SOURCES="\
 545   cmListFileLexer \
 546 "
 547
 548 if ${cmake_system_mingw}; then
 549   KWSYS_C_SOURCES="\
 550     EncodingC \
 551     ProcessWin32 \
 552     String \
 553     System \
 554     Terminal"
 555 else
 556   KWSYS_C_SOURCES="\
 557     EncodingC \
 558     ProcessUNIX \
 559     String \
 560     System \
 561     Terminal"
 562 fi
 563
 564 KWSYS_CXX_SOURCES="\
 565   Directory \
 566   EncodingCXX \
 567   FStream \
 568   Glob \
 569   RegularExpression \
 570   Status \
 571   SystemTools"
 572
 573 KWSYS_FILES="\
 574   Directory.hxx \
 575   Encoding.h \
 576   Encoding.hxx \
 577   FStream.hxx \
 578   Glob.hxx \
 579   Process.h \
 580   RegularExpression.hxx \
 581   Status.hxx \
 582   String.h \
 583   System.h \
 584   SystemTools.hxx \
 585   Terminal.h"
 586
 587 LIBRHASH_C_SOURCES="\
 588   librhash/algorithms.c \
 589   librhash/byte_order.c \
 590   librhash/hex.c \
 591   librhash/md5.c \
 592   librhash/rhash.c \
 593   librhash/sha1.c \
 594   librhash/sha256.c \
 595   librhash/sha3.c \
 596   librhash/sha512.c \
 597   librhash/util.c \
 598   "
 599
 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 \
 604   "
 605
 606 if ${cmake_system_mingw}; then
 607   LIBUV_C_SOURCES="\
 608     src/fs-poll.c \
 609     src/idna.c
 610     src/inet.c \
 611     src/threadpool.c \
 612     src/strscpy.c \
 613     src/strtok.c \
 614     src/timer.c \
 615     src/uv-common.c \
 616     src/win/async.c \
 617     src/win/core.c \
 618     src/win/detect-wakeup.c \
 619     src/win/dl.c \
 620     src/win/error.c \
 621     src/win/fs-event.c \
 622     src/win/fs.c \
 623     src/win/getaddrinfo.c \
 624     src/win/getnameinfo.c \
 625     src/win/handle.c \
 626     src/win/loop-watcher.c \
 627     src/win/pipe.c \
 628     src/win/poll.c \
 629     src/win/process-stdio.c \
 630     src/win/process.c \
 631     src/win/signal.c \
 632     src/win/stream.c \
 633     src/win/tcp.c \
 634     src/win/thread.c \
 635     src/win/tty.c \
 636     src/win/udp.c \
 637     src/win/util.c \
 638     src/win/winapi.c \
 639     src/win/winsock.c \
 640     "
 641 else
 642   LIBUV_C_SOURCES="\
 643     src/strscpy.c \
 644     src/strtok.c \
 645     src/timer.c \
 646     src/uv-common.c \
 647     src/unix/cmake-bootstrap.c \
 648     src/unix/core.c \
 649     src/unix/fs.c \
 650     src/unix/loop.c \
 651     src/unix/loop-watcher.c \
 652     src/unix/no-fsevents.c \
 653     src/unix/pipe.c \
 654     src/unix/poll.c \
 655     src/unix/posix-hrtime.c \
 656     src/unix/posix-poll.c \
 657     src/unix/process.c \
 658     src/unix/signal.c \
 659     src/unix/stream.c \
 660     src/unix/tcp.c \
 661     src/unix/tty.c \
 662     "
 663 fi
 664
 665 # Display CMake bootstrap usage
 666 cmake_usage()
 667 {
 668 echo '
 669 Usage: '"$0"' [<options>...] [-- <cmake-options>...]
 670 Options: [defaults in brackets after descriptions]
 671 Configuration:
 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
 676                           number of nodes [1]
 677   --generator=<generator> generator to use (MSYS Makefiles, Unix Makefiles,
 678                           or Ninja)
 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
 684                           (default)
 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)
 709
 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
 713
 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
 717
 718   --debugger              enable debugger support (default if supported)
 719   --no-debugger           disable debugger support
 720
 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
 728
 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}"']
 742 '
 743   exit 10
 744 }
 745
 746 # Display CMake bootstrap usage
 747 cmake_version_display()
 748 {
 749   echo "CMake ${cmake_version}, ${cmake_copyright}"
 750 }
 751
 752 # Display CMake bootstrap error, display the log file and exit
 753 cmake_error()
 754 {
 755   res=$1
 756   shift 1
 757   echo "---------------------------------------------"
 758   echo "Error when bootstrapping CMake:"
 759   echo "$*"
 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 "---------------------------------------------"
 765   fi
 766   exit ${res}
 767 }
 768
 769 cmake_generate_file_tmp ()
 770 {
 771   OUTFILE="$1"
 772   TMPFILE="$2"
 773   if "${_diff}" "$TMPFILE" "$OUTFILE" > /dev/null 2> /dev/null ; then
 774     rm -f "$TMPFILE"
 775   else
 776     mv -f "$TMPFILE" "$OUTFILE"
 777   fi
 778 }
 779
 780 cmake_generate_file ()
 781 {
 782   OUTFILE="$1"
 783   CONTENT="$2"
 784   echo "$CONTENT" > "$OUTFILE.tmp"
 785   cmake_generate_file_tmp "$OUTFILE" "$OUTFILE.tmp"
 786 }
 787
 788 # Replace KWSYS_NAMESPACE with cmsys
 789 cmake_replace_string ()
 790 {
 791   INFILE="$1"
 792   OUTFILE="$2"
 793   SEARCHFOR="$3"
 794   REPLACEWITH="$4"
 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}"
 801       else
 802         mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
 803       fi
 804     fi
 805   else
 806     cmake_error 1 "Cannot find file ${INFILE}"
 807   fi
 808 }
 809
 810 cmake_kwsys_config_replace_string ()
 811 {
 812   INFILE="$1"
 813   OUTFILE="$2"
 814   shift 2
 815   APPEND="$*"
 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}"
 831       else
 832         mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
 833       fi
 834     fi
 835   else
 836     cmake_error 2 "Cannot find file ${INFILE}"
 837   fi
 838 }
 839 # Write string into a file
 840 cmake_report ()
 841 {
 842   FILE=$1
 843   shift
 844   echo "$*" >> ${FILE}
 845 }
 846
 847 # Escape spaces in strings for artifacts
 848 cmake_escape_artifact ()
 849 {
 850   if test "${cmake_bootstrap_generator}" = "Ninja"; then
 851     echo $1 | sed "s/ /$ /g"
 852   else
 853     echo $1 | sed "s/ /\\\\ /g"
 854   fi
 855 }
 856
 857 # Escape spaces in strings for shell
 858 cmake_escape_shell ()
 859 {
 860   echo $1 | sed "s/ /\\\\ /g"
 861 }
 862
 863 # Encode object file names.
 864 cmake_obj ()
 865 {
 866   echo $1 | sed 's/\//-/g' | sed 's/$/\.o/'
 867 }
 868
 869 # Strip prefix from argument
 870 cmake_arg ()
 871 {
 872   echo "$1" | sed "s/^${2-[^=]*=}//"
 873 }
 874
 875 # Write message to the log
 876 cmake_log ()
 877 {
 878   echo "$*" >> cmake_bootstrap.log
 879 }
 880
 881 # Return temp file
 882 cmake_tmp_file ()
 883 {
 884   echo "cmake_bootstrap_$$_test"
 885 }
 886
 887 # Run a compiler test. First argument is compiler, second one are compiler
 888 # flags, third one is test source file to be compiled
 889 cmake_try_run ()
 890 {
 891   COMPILER=$1
 892   FLAGS=$2
 893   TESTFILE=$3
 894   if test ! -f "${TESTFILE}"; then
 895     echo "Test file ${TESTFILE} missing. Please verify your CMake source tree."
 896     exit 4
 897   fi
 898   TMPFILE=`cmake_tmp_file`
 899   echo "Try: ${COMPILER}"
 900   echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}"
 901   echo "----------  file   -----------------------"
 902   cat "${TESTFILE}"
 903   echo "------------------------------------------"
 904   ${COMPILER} ${FLAGS} "${TESTFILE}" -o "${TMPFILE}"
 905   RES=$?
 906   if test "${RES}" -ne "0"; then
 907     echo "Test failed to compile"
 908     return 1
 909   fi
 910   if test ! -f "${TMPFILE}" && test ! -f "${TMPFILE}.exe"; then
 911     echo "Test failed to produce executable"
 912     return 2
 913   fi
 914   ./${TMPFILE}
 915   RES=$?
 916   rm -f "${TMPFILE}"
 917   if test "${RES}" -ne "0"; then
 918     echo "Test produced non-zero return code"
 919     return 3
 920   fi
 921   echo "Test succeeded"
 922   return 0
 923 }
 924
 925 # Run a make test. First argument is the make interpreter.
 926 cmake_try_make ()
 927 {
 928   MAKE_PROC="$1"
 929   MAKE_FLAGS="$2"
 930   echo "Try: ${MAKE_PROC}"
 931   "${MAKE_PROC}" ${MAKE_FLAGS}
 932   RES=$?
 933   if test "${RES}" -ne "0"; then
 934     echo "${MAKE_PROC} does not work"
 935     return 1
 936   fi
 937   if test ! -f "test" && test ! -f "test.exe"; then
 938     echo "${COMPILER} does not produce output"
 939     return 2
 940   fi
 941   ./test
 942   RES=$?
 943   rm -f "test"
 944   if test "${RES}" -ne "0"; then
 945     echo "${MAKE_PROC} produces strange executable"
 946     return 3
 947   fi
 948   echo "${MAKE_PROC} works"
 949   return 0
 950 }
 951
 952 # Parse arguments
 953 cmake_verbose=
 954 cmake_parallel_make=
 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
 961   case "$1" in
 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"` ;;
1004   --) shift; break ;;
1005   *) die "Unknown option: $1" ;;
1006   esac
1007   shift
1008 done
1009
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}"
1014 esac
1015
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}"
1026   fi
1027   echo ""
1028 fi
1029
1030 echo "---------------------------------------------"
1031 # Get CMake version
1032 echo "`cmake_version_display`"
1033
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"
1040   fi
1041   cmake_in_source_build=TRUE
1042 fi
1043
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."
1052   fi
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."
1060     fi
1061   done
1062 fi
1063
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."
1068 fi
1069 cd "${cmake_bootstrap_dir}"
1070
1071 test -d "cmsys" || mkdir "cmsys"
1072 if test ! -d "cmsys"; then
1073   cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys"
1074 fi
1075
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}"
1080
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"
1085 fi
1086
1087 # If exist compiler flags, set them
1088 cmake_c_flags=${CFLAGS}
1089 cmake_cxx_flags=${CXXFLAGS}
1090 cmake_ld_flags=${LDFLAGS}
1091
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 \
1103     "
1104
1105   LexerParser_CXX_SOURCES="${LexerParser_CXX_SOURCES} \
1106     cmFortranLexer \
1107     cmFortranParser \
1108     "
1109 else
1110   CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
1111     cmDepends \
1112     cmDependsC \
1113     cmDependsCompiler \
1114     cmGlobalUnixMakefileGenerator3 \
1115     cmLocalUnixMakefileGenerator3 \
1116     cmMakefileExecutableTargetGenerator \
1117     cmMakefileLibraryTargetGenerator \
1118     cmMakefileTargetGenerator \
1119     cmMakefileUtilityTargetGenerator \
1120     cmProcessTools \
1121     "
1122 fi
1123
1124 # Add Cygwin-specific flags
1125 if ${cmake_system_cygwin} || ${cmake_system_msys}; then
1126   cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import"
1127 fi
1128
1129 # Add CoreFoundation framework on Darwin
1130 if ${cmake_system_darwin}; then
1131   cmake_ld_flags="${LDFLAGS} -framework CoreFoundation"
1132 fi
1133
1134 # Add BeOS toolkits...
1135 if ${cmake_system_beos}; then
1136   cmake_ld_flags="${LDFLAGS} -lroot -lbe"
1137 fi
1138
1139 # Add Haiku toolkits...
1140 if ${cmake_system_haiku}; then
1141   cmake_ld_flags="${LDFLAGS} -lroot -lbe"
1142 fi
1143
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"
1148   fi
1149 fi
1150
1151 #-----------------------------------------------------------------------------
1152 # Detect known toolchains on some platforms.
1153 cmake_toolchains=''
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' ;;
1161 esac
1162
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'
1174
1175 cmake_toolchain_try()
1176 {
1177   tc="$1"
1178   TMPFILE=`cmake_tmp_file`
1179
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
1183   tc_result_CC="$?"
1184   rm -f "${TMPFILE}.c"
1185   test "${tc_result_CC}" = "0" || return 1
1186
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
1190   tc_result_CXX="$?"
1191   rm -f "${TMPFILE}.cpp"
1192   test "${tc_result_CXX}" = "0" || return 1
1193
1194   cmake_toolchain="$tc"
1195 }
1196
1197 cmake_toolchain_detect()
1198 {
1199   cmake_toolchain=
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" &&
1204     break
1205   done
1206 }
1207
1208 if test -z "${CC}" && test -z "${CXX}"; then
1209   cmake_toolchain_detect
1210 fi
1211
1212 thread_flags=''
1213 case "${cmake_system}" in
1214   *AIX*)   thread_flags='-pthread' ;;
1215 esac
1216
1217 #-----------------------------------------------------------------------------
1218 # Test C compiler
1219 cmake_c_compiler=
1220
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}"
1224 else
1225   cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}"
1226 fi
1227
1228 cmake_c_compiler_try_set()
1229 {
1230   test_compiler="$1"
1231   test_thread_flags="$2"
1232
1233   # Check if C compiler works
1234   TMPFILE=`cmake_tmp_file`
1235   echo '
1236 #ifdef __cplusplus
1237 # error "The CMAKE_C_COMPILER is set to a C++ compiler"
1238 #endif
1239
1240 #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
1241 #error "On AIX with GNU we need the -pthread flag."
1242 #endif
1243
1244 #if defined(__sun) && __STDC_VERSION__ < 199901L
1245 #error "On Solaris we need C99."
1246 #endif
1247
1248 #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
1249 #error "On HP-UX we need GCC 4.9 or higher."
1250 #endif
1251
1252 #include <stdio.h>
1253
1254 int main(int argc, char* argv[])
1255 {
1256   printf("%d%c", (argv != 0), (char)0x0a);
1257   return argc - 1;
1258 }
1259 ' > "${TMPFILE}.c"
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"
1270           return 0
1271         fi
1272       done
1273     done
1274   done
1275   rm -f "${TMPFILE}.c"
1276   return 1
1277 }
1278
1279 if test -n "${CC}"; then
1280   cmake_c_compiler_try_set "${CC}" "${thread_flags}"
1281 else
1282   for compiler in ${cmake_c_compilers}; do
1283     if cmake_c_compiler_try_set "${compiler}" "${thread_flags}"; then
1284       break
1285     fi
1286   done
1287 fi
1288
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.
1293 "
1294 fi
1295 echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}"
1296
1297 #-----------------------------------------------------------------------------
1298 # Test CXX compiler
1299 cmake_cxx_compiler=
1300
1301 # On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler.
1302
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}"
1306 else
1307   cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}"
1308 fi
1309
1310 # Check if C++ compiler works
1311 cmake_cxx_compiler_try_set()
1312 {
1313   test_compiler="$1"
1314   test_thread_flags="$2"
1315
1316   TMPFILE=`cmake_tmp_file`
1317 echo '
1318 #include <iostream>
1319 #include <memory>
1320 #include <unordered_map>
1321
1322 #if __cplusplus < 201103L
1323 #error "Compiler is not in a mode aware of C++11."
1324 #endif
1325
1326 #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
1327 #error "On AIX with GNU we need the -pthread flag."
1328 #endif
1329
1330 #if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5140
1331 #error "SunPro <= 5.13 mode not supported due to bug in move semantics."
1332 #endif
1333
1334 #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
1335 #error "On HP-UX we need GCC 4.9 or higher."
1336 #endif
1337
1338 #if __cplusplus > 201103L
1339 #include <iterator>
1340 int check_cxx14()
1341 {
1342   int a[] = { 0, 1, 2 };
1343   auto ai = std::cbegin(a);
1344
1345   int b[] = { 2, 1, 0 };
1346   auto bi = std::cend(b);
1347
1348   return *ai + *(bi - 1);
1349 }
1350 #else
1351 int check_cxx14()
1352 {
1353   return 0;
1354 }
1355 #endif
1356
1357 #if (__cplusplus >= 201703L || defined(__INTEL_COMPILER) && defined(__cpp_deduction_guides))
1358 #include <optional>
1359 template <typename T,
1360           typename std::invoke_result<decltype(&T::get), T>::type = nullptr>
1361 typename T::pointer get_ptr(T& item)
1362 {
1363   return item.get();
1364 }
1365
1366 int check_cxx17()
1367 {
1368   // Intel compiler do not handle correctly 'decltype' inside 'invoke_result'
1369   std::unique_ptr<int> u(new int(0));
1370   get_ptr(u);
1371   std::optional<int> oi = 0;
1372   return oi.value();
1373 }
1374 #else
1375 int check_cxx17()
1376 {
1377   return 0;
1378 }
1379 #endif
1380
1381 class Class
1382 {
1383 public:
1384   int Get() const { return this->Member; }
1385 private:
1386   int Member = 1;
1387 };
1388 int main()
1389 {
1390   auto const c = std::unique_ptr<Class>(new Class);
1391   std::cout << c->Get() << check_cxx14() << check_cxx17() << std::endl;
1392   return 0;
1393 }
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"
1405           return 0
1406         fi
1407       done
1408     done
1409   done
1410   rm -f "${TMPFILE}.cxx"
1411   return 1
1412 }
1413
1414 if test -n "${CXX}"; then
1415   cmake_cxx_compiler_try_set "${CXX}" "${thread_flags}"
1416 else
1417   for compiler in ${cmake_cxx_compilers}; do
1418     if cmake_cxx_compiler_try_set "${compiler}" "${thread_flags}"; then
1419       break
1420     fi
1421   done
1422 fi
1423
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."
1430 fi
1431 echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}"
1432
1433 #-----------------------------------------------------------------------------
1434 # Test CXX features
1435
1436 cmake_cxx_features="make_unique filesystem"
1437
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"
1444   fi
1445 done
1446
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}"
1453   fi
1454 done
1455
1456 cmake_generate_file "${cmake_bootstrap_dir}/cmSTL.hxx" ""
1457
1458
1459 #-----------------------------------------------------------------------------
1460 # Test Make
1461
1462 cmake_make_processor=
1463 cmake_make_flags=
1464
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}"
1470 else
1471   cmake_make_processors="${CMAKE_KNOWN_MAKE_PROCESSORS}"
1472 fi
1473
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
1479   echo '
1480 rule cc
1481   command = '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o $out $in
1482 build test: cc test.c
1483 '>"build.ninja"
1484 else
1485   echo '
1486 test: test.c
1487         '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c
1488 '>"Makefile"
1489 fi
1490 echo '
1491 #include <stdio.h>
1492 int main(){ printf("1%c", (char)0x0a); return 0; }
1493 ' > "test.c"
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}"
1497 fi
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}"
1501   fi
1502 done
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}"
1510       fi
1511     done
1512   fi
1513 fi
1514 cd "${cmake_bootstrap_dir}"
1515
1516 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1517   mf_str=Ninja
1518 else
1519   mf_str=Makefile
1520 fi
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."
1524 fi
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 "---------------------------------------------"
1531 fi
1532
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
1546
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"
1552 else
1553   echo "${cmake_cxx_compiler} does not have setenv"
1554 fi
1555
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"
1561 else
1562   echo "${cmake_cxx_compiler} does not have unsetenv"
1563 fi
1564
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"
1570 else
1571   echo "${cmake_cxx_compiler} does not have environ in stdlib.h"
1572 fi
1573
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"
1579 else
1580   echo "${cmake_cxx_compiler} does not have stl wstring"
1581 fi
1582
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>"
1588 else
1589   echo "${cmake_cxx_compiler} does not have <ext/stdio_filebuf.h>"
1590 fi
1591
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}"
1596 fi
1597
1598 # Just to be safe, let us store compiler and flags to the header file
1599
1600 cmake_bootstrap_version='$Revision$'
1601 cmake_compiler_settings_comment="/*
1602  * Generated by ${cmake_source_dir}/bootstrap
1603  * Version:     ${cmake_bootstrap_version}
1604  *
1605  * Source directory: ${cmake_source_dir}
1606  * Binary directory: ${cmake_bootstrap_dir}
1607  *
1608  * C compiler:   ${cmake_c_compiler}
1609  * C flags:      ${cmake_c_flags}
1610  *
1611  * C++ compiler: ${cmake_cxx_compiler}
1612  * C++ flags:    ${cmake_cxx_flags}
1613  *
1614  * Make:         ${cmake_make_processor}
1615  *
1616  * Sources:
1617  * ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES}
1618  * STD Sources:
1619  * ${CMAKE_STD_CXX_HEADERS} ${CMAKE_STD_CXX_SOURCES}
1620  * LexerParser Sources:
1621  * ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES}
1622  * kwSys Sources:
1623  * ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES}
1624  * libuv Sources:
1625  * ${LIBUV_C_SOURCES}
1626  * jsoncpp Sources:
1627  * ${JSONCPP_CXX_SOURCES}
1628  * librhash Sources:
1629  * ${LIBRHASH_C_SOURCES}
1630  */
1631 "
1632
1633 cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}"
1634
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`
1640 else
1641     CMAKE_BOOTSTRAP_SOURCE_DIR="${cmake_source_dir}"
1642     CMAKE_BOOTSTRAP_BINARY_DIR="${cmake_binary_dir}"
1643 fi
1644
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"
1656
1657 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1658   cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_NINJA"
1659 else
1660   cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_MAKEFILES"
1661 fi
1662
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"
1670 fi
1671
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}
1676   else
1677     mv -f cm${h}.h${_tmp} cm${h}.h
1678   fi
1679 done
1680
1681 # Prepare KWSYS
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}"
1691
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}"
1696 done
1697
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"
1701 fi
1702 if test "x${bootstrap_system_jsoncpp}" != "x"; then
1703   echo "#define CMAKE_USE_SYSTEM_JSONCPP" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1704 fi
1705 if test "x${bootstrap_system_librhash}" != "x"; then
1706   echo "#define CMAKE_USE_SYSTEM_LIBRHASH" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1707 fi
1708 cmake_generate_file_tmp "${cmake_bootstrap_dir}/cmThirdParty.h" "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1709
1710 # Generate Makefile
1711 dep="cmConfigure.h ${cmsys_header_files}"
1712 for h in "${cmake_source_dir}"/Source/*.hxx; do
1713   dep="${dep} `cmake_escape_artifact \"${h}\"`"
1714 done
1715 for h in "${cmake_source_dir}"/Source/*.h; do
1716   dep="${dep} `cmake_escape_artifact \"${h}\"`"
1717 done
1718 for h in ${CMAKE_STD_CXX_HEADERS}; do
1719   dep="${dep} `cmake_escape_artifact \"${cmake_source_dir}\"`/Utilities/std/cm/${h}"
1720 done
1721 objs=""
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"
1724 done
1725 if test "x${bootstrap_system_libuv}" = "x"; then
1726   for a in ${LIBUV_C_SOURCES}; do
1727     objs="${objs} uv-`cmake_obj ${a}`"
1728   done
1729 fi
1730 if test "x${bootstrap_system_librhash}" = "x"; then
1731   for a in ${LIBRHASH_C_SOURCES}; do
1732     objs="${objs} rhash-`cmake_obj ${a}`"
1733   done
1734 fi
1735 if test "x${bootstrap_system_jsoncpp}" = "x"; then
1736   for a in ${JSONCPP_CXX_SOURCES}; do
1737     objs="${objs} jsoncpp-`cmake_obj ${a}`"
1738   done
1739 fi
1740
1741 libs=""
1742
1743 uv_c_flags=""
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"
1747 else
1748   case "${cmake_system}" in
1749     *AIX*)
1750       uv_c_flags="${uv_c_flags} -D_ALL_SOURCE -D_XOPEN_SOURCE=500 -D_LINUX_SOURCE_COMPAT"
1751       libs="${libs} -lperfstat"
1752       ;;
1753     *Darwin*)
1754       uv_c_flags="${uv_c_flags} -D_DARWIN_USE_64_BIT_INODE=1 -D_DARWIN_UNLIMITED_SELECT=1"
1755       ;;
1756     *HP-UX*)
1757       uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE_EXTENDED"
1758       ;;
1759     *Linux*)
1760       uv_c_flags="${uv_c_flags} -D_GNU_SOURCE"
1761       libs="${libs} -ldl -lrt"
1762       ;;
1763     *kFreeBSD*)
1764       libs="${libs} -lkvm -lfreebsd-glue"
1765       ;;
1766     *BSD*)
1767       libs="${libs} -lkvm"
1768       ;;
1769     *SunOS*)
1770       uv_c_flags="${uv_c_flags} -D__EXTENSIONS__ -D_XOPEN_SOURCE=600"
1771       libs="${libs} -lkstat -lnsl -lsendfile -lsocket -lrt"
1772       ;;
1773     *QNX*)
1774       uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE=700"
1775       libs="${libs} -lsocket"
1776       ;;
1777   esac
1778 fi
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"`"
1783   else
1784     uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/unix"`"
1785   fi
1786   uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src"`"
1787 else
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}"
1793   else
1794     use_librhash_ldflags="-luv"
1795   fi
1796   libs="${libs} ${use_uv_ldflags}"
1797 fi
1798
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}"
1806   else
1807     use_librhash_ldflags="-lrhash"
1808   fi
1809   libs="${libs} ${use_librhash_ldflags}"
1810 fi
1811
1812 jsoncpp_cxx_flags=
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"`"
1815 else
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}"
1820   else
1821     use_librhash_ldflags="-ljsoncpp"
1822   fi
1823   libs="${libs} ${use_jsoncpp_ldflags}"
1824 fi
1825
1826 if test "x${cmake_ansi_cxx_flags}" != "x"; then
1827   cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}"
1828 fi
1829
1830 system_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' ;;
1834 esac
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}"
1838 fi
1839
1840 if test "x${cmake_c_flags}" != "x"; then
1841   cmake_c_flags="${cmake_c_flags} "
1842 fi
1843
1844 if test "x${cmake_cxx_flags}" != "x"; then
1845   cmake_cxx_flags="${cmake_cxx_flags} "
1846 fi
1847
1848 write_source_rule() {
1849   lang="$1"
1850   obj="$2"
1851   src="$3"
1852   src_flags="$4"
1853
1854   if test "${lang}" = "c"; then
1855     ninja_rule=cc
1856     compiler="${cmake_c_compiler}"
1857     flags="${cmake_c_flags}"
1858   elif test "${lang}" = "cxx"; then
1859     ninja_rule=cxx
1860     compiler="${cmake_cxx_compiler}"
1861     flags="${cmake_cxx_flags}"
1862   fi
1863
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"
1867   else
1868     echo "${obj} : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile"
1869     echo "      ${compiler} ${flags} ${src_flags} -c ${src} -o ${obj}" >> "${cmake_bootstrap_dir}/Makefile"
1870   fi
1871 }
1872
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}"
1878 fi
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}
1885 "
1886 cmake_c_flags="${cmake_c_flags} \
1887   -DCMAKE_BOOTSTRAP \
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} \
1893   -DCMAKE_BOOTSTRAP \
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"
1914 else
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"
1917 fi
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}"
1922 done
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}" ""
1926 done
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}"
1931 done
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}"
1936 done
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}" ""
1940 done
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}"
1945 done
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}"
1950 done
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}"
1955   done
1956 fi
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}"
1961   done
1962 fi
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}"
1967   done
1968 fi
1969 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1970   echo "
1971 rule rebuild_cache
1972   command = cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
1973   generator = 1
1974 build build.ninja : rebuild_cache
1975 " >> "${cmake_bootstrap_dir}/build.ninja"
1976 else
1977   echo "
1978 rebuild_cache:
1979         cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
1980 " >> "${cmake_bootstrap_dir}/Makefile"
1981 fi
1982
1983 # Write our default settings to Bootstrap${_cmk}/InitialCacheFlags.cmake.
1984 echo '
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"
1995
1996 # Add configuration settings given as command-line options.
1997 if test "x${cmake_bootstrap_qt_gui}" != "x"; then
1998   echo '
1999 set (BUILD_QtDialog '"${cmake_bootstrap_qt_gui}"' CACHE BOOL "Build Qt dialog for CMake" FORCE)
2000 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2001 fi
2002 if test "x${cmake_bootstrap_qt_qmake}" != "x"; then
2003   echo '
2004 set (QT_QMAKE_EXECUTABLE "'"${cmake_bootstrap_qt_qmake}"'" CACHE FILEPATH "Location of Qt qmake" FORCE)
2005 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2006 fi
2007 if test "x${cmake_bootstrap_debugger}" != "x"; then
2008   echo '
2009 set (CMake_ENABLE_DEBUGGER '"${cmake_bootstrap_debugger}"' CACHE BOOL "Enable CMake debugger support" FORCE)
2010 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2011 fi
2012 if test "x${cmake_sphinx_info}" != "x"; then
2013   echo '
2014 set (SPHINX_INFO "'"${cmake_sphinx_info}"'" CACHE BOOL "Build Info manual with Sphinx" FORCE)
2015 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2016 fi
2017 if test "x${cmake_sphinx_man}" != "x"; then
2018   echo '
2019 set (SPHINX_MAN "'"${cmake_sphinx_man}"'" CACHE BOOL "Build man pages with Sphinx" FORCE)
2020 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2021 fi
2022 if test "x${cmake_sphinx_html}" != "x"; then
2023   echo '
2024 set (SPHINX_HTML "'"${cmake_sphinx_html}"'" CACHE BOOL "Build html help with Sphinx" FORCE)
2025 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2026 fi
2027 if test "x${cmake_sphinx_qthelp}" != "x"; then
2028   echo '
2029 set (SPHINX_QTHELP "'"${cmake_sphinx_qthelp}"'" CACHE BOOL "Build qch help with Sphinx" FORCE)
2030 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2031 fi
2032 if test "x${cmake_sphinx_latexpdf}" != "x"; then
2033   echo '
2034 set (SPHINX_LATEXPDF "'"${cmake_sphinx_latexpdf}"'" CACHE BOOL "Build PDF help with Sphinx using LaTeX" FORCE)
2035 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2036 fi
2037 if test "x${cmake_sphinx_build}" != "x"; then
2038   echo '
2039 set (SPHINX_EXECUTABLE "'"${cmake_sphinx_build}"'" CACHE FILEPATH "Location of Qt sphinx-build" FORCE)
2040 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2041 fi
2042 if test "x${cmake_sphinx_flags}" != "x"; then
2043   echo '
2044 set (SPHINX_FLAGS [==['"${cmake_sphinx_flags}"']==] CACHE STRING "Flags to pass to sphinx-build" FORCE)
2045 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2046 fi
2047
2048 # Add user-specified settings.  Handle relative-path case for
2049 # specification of cmake_init_file.
2050 (
2051 cd "${cmake_binary_dir}"
2052 if test -f "${cmake_init_file}"; then
2053   cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
2054 fi
2055 )
2056
2057 echo "---------------------------------------------"
2058
2059 # Run make to build bootstrap cmake
2060 if test "${cmake_bootstrap_generator}" = "Ninja"; then
2061   ninja_v=-v
2062 else
2063   ninja_v=
2064 fi
2065 if test "x${cmake_parallel_make}" != "x"; then
2066   ${cmake_make_processor} ${cmake_make_flags} ${ninja_v}
2067 else
2068   ${cmake_make_processor} ${ninja_v}
2069 fi
2070 RES=$?
2071 if test "${RES}" -ne "0"; then
2072   cmake_error 9 "Problem while running ${cmake_make_processor}"
2073 fi
2074 cd "${cmake_binary_dir}"
2075
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}"
2081 export CC
2082 export CXX
2083 export MAKE
2084 export CFLAGS
2085 export CXXFLAGS
2086 export LDFLAGS
2087
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"
2092 fi
2093 "${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" ${cmake_options} ${cmake_bootstrap_system_libs} "$@"
2094 RES=$?
2095 if test "${RES}" -ne "0"; then
2096   cmake_error 11 "Problem while running initial CMake"
2097 fi
2098
2099 echo "---------------------------------------------"
2100
2101 # And we are done. Now just run make
2102 echo "CMake has bootstrapped.  Now run ${cmake_make_processor}."