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_sphinx_info=""
  84 cmake_sphinx_man=""
  85 cmake_sphinx_html=""
  86 cmake_sphinx_qthelp=""
  87 cmake_sphinx_latexpdf=""
  88 cmake_sphinx_build=""
  89 cmake_sphinx_flags=""
  90
  91 # Determine whether this is a Cygwin environment.
  92 if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then
  93   cmake_system_cygwin=true
  94   cmake_doc_dir_keyword="CYGWIN"
  95   cmake_man_dir_keyword="CYGWIN"
  96 else
  97   cmake_system_cygwin=false
  98 fi
  99
 100 # Determine whether this is a MSYS environment.
 101 if echo "${cmake_system}" | grep MSYS >/dev/null 2>&1; then
 102   cmake_system_msys=true
 103   cmake_doc_dir_keyword="MSYS"
 104   cmake_man_dir_keyword="MSYS"
 105 else
 106   cmake_system_msys=false
 107 fi
 108
 109 # Determine whether this is a MinGW environment.
 110 if echo "${cmake_system}" | grep 'MINGW' >/dev/null 2>&1; then
 111   cmake_system_mingw=true
 112 else
 113   cmake_system_mingw=false
 114 fi
 115
 116 # Determine whether this is OS X
 117 if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then
 118   cmake_system_darwin=true
 119 else
 120   cmake_system_darwin=false
 121 fi
 122
 123 # Determine whether this is BeOS
 124 if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then
 125   cmake_system_beos=true
 126   cmake_doc_dir_keyword="HAIKU"
 127   cmake_man_dir_keyword="HAIKU"
 128 else
 129   cmake_system_beos=false
 130 fi
 131
 132 # Determine whether this is Haiku
 133 if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then
 134   cmake_system_haiku=true
 135   cmake_doc_dir_keyword="HAIKU"
 136   cmake_man_dir_keyword="HAIKU"
 137 else
 138   cmake_system_haiku=false
 139 fi
 140
 141 # Determine whether this is OpenVMS
 142 if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then
 143   cmake_system_openvms=true
 144 else
 145   cmake_system_openvms=false
 146 fi
 147
 148 # Determine whether this is HP-UX
 149 if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then
 150   die 'CMake no longer compiles on HP-UX.  See
 151
 152   https://gitlab.kitware.com/cmake/cmake/-/issues/17137
 153
 154 Use CMake 3.9 or lower instead.'
 155   cmake_system_hpux=true
 156 else
 157   cmake_system_hpux=false
 158 fi
 159
 160 # Determine whether this is Linux
 161 if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then
 162   cmake_system_linux=true
 163 else
 164   cmake_system_linux=false
 165  fi
 166
 167 # Determine whether this is a PA-RISC machine
 168 # This only works for Linux or HP-UX, not other PA-RISC OSs (BSD maybe?). Also
 169 # may falsely detect parisc on HP-UX m68k
 170 cmake_machine_parisc=false
 171 if ${cmake_system_linux}; then
 172   if uname -m | grep parisc >/dev/null 2>&1; then
 173     cmake_machine_parisc=true
 174   fi
 175 elif ${cmake_system_hpux}; then
 176   if uname -m | grep ia64 >/dev/null 2>&1; then : ; else
 177     cmake_machine_parisc=true
 178   fi
 179 fi
 180
 181 # Choose the generator to use for bootstrapping.
 182 if ${cmake_system_mingw}; then
 183   # Bootstrapping from an MSYS prompt.
 184   cmake_bootstrap_generator="MSYS Makefiles"
 185 else
 186   # Bootstrapping from a standard UNIX prompt.
 187   cmake_bootstrap_generator="Unix Makefiles"
 188 fi
 189
 190 # Choose tools and extensions for this platform.
 191 if ${cmake_system_openvms}; then
 192   _tmp="_tmp"
 193   _cmk="_cmk"
 194   _diff=`which diff`
 195 else
 196   _tmp=".tmp"
 197   _cmk=".cmk"
 198   _diff="diff"
 199 fi
 200
 201 # Construct bootstrap directory name.
 202 cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}"
 203
 204 # Helper function to fix windows paths.
 205 case "${cmake_system}" in
 206 *MINGW*)
 207   cmake_fix_slashes()
 208   {
 209     cmd //c echo "$(echo "$1" | sed 's/\\/\//g')" | sed 's/^"//;s/" *$//'
 210   }
 211   ;;
 212 *)
 213   cmake_fix_slashes()
 214   {
 215     echo "$1" | sed 's/\\/\//g'
 216   }
 217   ;;
 218 esac
 219
 220 # Choose the default install prefix.
 221 if ${cmake_system_mingw}; then
 222   if test "x${PROGRAMFILES}" != "x"; then
 223     cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"`
 224   elif test "x${ProgramFiles}" != "x"; then
 225     cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"`
 226   elif test "x${SYSTEMDRIVE}" != "x"; then
 227     cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"`
 228   elif test "x${SystemDrive}" != "x"; then
 229     cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"`
 230   else
 231     cmake_default_prefix="c:/Program Files/CMake"
 232   fi
 233 elif ${cmake_system_haiku}; then
 234   cmake_default_prefix=`finddir B_COMMON_DIRECTORY`
 235 else
 236   cmake_default_prefix="/usr/local"
 237 fi
 238
 239 # Lookup default install destinations.
 240 cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`"
 241 cmake_data_dir_default="`cmake_install_dest_default DATA ${cmake_data_dir_keyword}`"
 242 cmake_doc_dir_default="`cmake_install_dest_default DOC ${cmake_doc_dir_keyword}`"
 243 cmake_man_dir_default="`cmake_install_dest_default MAN ${cmake_man_dir_keyword}`"
 244 cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`"
 245
 246 CMAKE_KNOWN_C_COMPILERS="cc gcc clang xlc icc tcc"
 247 CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icc como "
 248 CMAKE_KNOWN_MAKE_PROCESSORS="gmake make smake"
 249 CMAKE_KNOWN_NINJA_PROCESSORS="ninja-build ninja samu"
 250
 251 CMAKE_PROBLEMATIC_FILES="\
 252   CMakeCache.txt \
 253   CMakeSystem.cmake \
 254   CMakeCCompiler.cmake \
 255   CMakeCXXCompiler.cmake \
 256   */CMakeSystem.cmake \
 257   */CMakeCCompiler.cmake \
 258   */CMakeCXXCompiler.cmake \
 259   Source/cmConfigure.h \
 260   Source/CTest/Curl/config.h \
 261   Utilities/cmThirdParty.h \
 262   Utilities/cmcurl/lib/curl_config.h \
 263   Utilities/cmlibarchive/config.h \
 264   Utilities/cmliblzma/config.h \
 265   Utilities/cmnghttp2/config.h \
 266   Utilities/cmzlib/zlibDllConfig.h \
 267   "
 268
 269 CMAKE_UNUSED_SOURCES="\
 270   cmGlobalXCodeGenerator \
 271   cmLocalXCodeGenerator \
 272   cmXCodeObject \
 273   cmXCode21Object \
 274   cmSourceGroup \
 275 "
 276
 277 CMAKE_CXX_SOURCES="\
 278   cmAddCustomCommandCommand \
 279   cmAddCustomTargetCommand \
 280   cmAddDefinitionsCommand \
 281   cmAddDependenciesCommand \
 282   cmAddExecutableCommand \
 283   cmAddLibraryCommand \
 284   cmAddSubDirectoryCommand \
 285   cmAddTestCommand \
 286   cmArgumentParser \
 287   cmBinUtilsLinker \
 288   cmBinUtilsLinuxELFGetRuntimeDependenciesTool \
 289   cmBinUtilsLinuxELFLinker \
 290   cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool \
 291   cmBinUtilsMacOSMachOGetRuntimeDependenciesTool \
 292   cmBinUtilsMacOSMachOLinker \
 293   cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool \
 294   cmBinUtilsWindowsPEGetRuntimeDependenciesTool \
 295   cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool \
 296   cmBinUtilsWindowsPELinker \
 297   cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool \
 298   cmBreakCommand \
 299   cmBuildCommand \
 300   cmCMakeMinimumRequired \
 301   cmCMakePath \
 302   cmCMakePathCommand \
 303   cmCMakePolicyCommand \
 304   cmCPackPropertiesGenerator \
 305   cmCacheManager \
 306   cmCommand \
 307   cmCommandArgumentParserHelper \
 308   cmCommands \
 309   cmCommonTargetGenerator \
 310   cmComputeComponentGraph \
 311   cmComputeLinkDepends \
 312   cmComputeLinkInformation \
 313   cmComputeTargetDepends \
 314   cmConsoleBuf \
 315   cmConditionEvaluator \
 316   cmConfigureFileCommand \
 317   cmContinueCommand \
 318   cmCoreTryCompile \
 319   cmCreateTestSourceList \
 320   cmCryptoHash \
 321   cmCustomCommand \
 322   cmCustomCommandGenerator \
 323   cmCustomCommandLines \
 324   cmDefinePropertyCommand \
 325   cmDefinitions \
 326   cmDocumentationFormatter \
 327   cmEnableLanguageCommand \
 328   cmEnableTestingCommand \
 329   cmExecProgramCommand \
 330   cmExecuteProcessCommand \
 331   cmExpandedCommandArgument \
 332   cmExportBuildFileGenerator \
 333   cmExportFileGenerator \
 334   cmExportInstallFileGenerator \
 335   cmExportSet \
 336   cmExportTryCompileFileGenerator \
 337   cmExprParserHelper \
 338   cmExternalMakefileProjectGenerator \
 339   cmFileCommand \
 340   cmFileCopier \
 341   cmFileInstaller \
 342   cmFileTime \
 343   cmFileTimeCache \
 344   cmFileTimes \
 345   cmFindBase \
 346   cmFindCommon \
 347   cmFindFileCommand \
 348   cmFindLibraryCommand \
 349   cmFindPackageCommand \
 350   cmFindPathCommand \
 351   cmFindProgramCommand \
 352   cmForEachCommand \
 353   cmFunctionBlocker \
 354   cmFunctionCommand \
 355   cmFSPermissions \
 356   cmGeneratedFileStream \
 357   cmGeneratorExpression \
 358   cmGeneratorExpressionContext \
 359   cmGeneratorExpressionDAGChecker \
 360   cmGeneratorExpressionEvaluationFile \
 361   cmGeneratorExpressionEvaluator \
 362   cmGeneratorExpressionLexer \
 363   cmGeneratorExpressionNode \
 364   cmGeneratorExpressionParser \
 365   cmGeneratorTarget \
 366   cmGetCMakePropertyCommand \
 367   cmGetDirectoryPropertyCommand \
 368   cmGetFilenameComponentCommand \
 369   cmGetPipes \
 370   cmGetPropertyCommand \
 371   cmGetSourceFilePropertyCommand \
 372   cmGetTargetPropertyCommand \
 373   cmGetTestPropertyCommand \
 374   cmGlobalCommonGenerator \
 375   cmGlobalGenerator \
 376   cmGlobVerificationManager \
 377   cmHexFileConverter \
 378   cmIfCommand \
 379   cmIncludeCommand \
 380   cmIncludeGuardCommand \
 381   cmIncludeDirectoryCommand \
 382   cmIncludeRegularExpressionCommand \
 383   cmInstallCommand \
 384   cmInstallCommandArguments \
 385   cmInstallDirectoryGenerator \
 386   cmInstallExportGenerator \
 387   cmInstallFilesCommand \
 388   cmInstallFilesGenerator \
 389   cmInstallGenerator \
 390   cmInstallGetRuntimeDependenciesGenerator \
 391   cmInstallImportedRuntimeArtifactsGenerator \
 392   cmInstallRuntimeDependencySet \
 393   cmInstallRuntimeDependencySetGenerator \
 394   cmInstallScriptGenerator \
 395   cmInstallSubdirectoryGenerator \
 396   cmInstallTargetGenerator \
 397   cmInstallTargetsCommand \
 398   cmInstalledFile \
 399   cmLDConfigLDConfigTool \
 400   cmLDConfigTool \
 401   cmLinkDirectoriesCommand \
 402   cmLinkItem \
 403   cmLinkItemGraphVisitor \
 404   cmLinkLineComputer \
 405   cmLinkLineDeviceComputer \
 406   cmListCommand \
 407   cmListFileCache \
 408   cmLocalCommonGenerator \
 409   cmLocalGenerator \
 410   cmMSVC60LinkLineComputer \
 411   cmMacroCommand \
 412   cmMakeDirectoryCommand \
 413   cmMakefile \
 414   cmMarkAsAdvancedCommand \
 415   cmMathCommand \
 416   cmMessageCommand \
 417   cmMessenger \
 418   cmNewLineStyle \
 419   cmOSXBundleGenerator \
 420   cmOptionCommand \
 421   cmOrderDirectories \
 422   cmOutputConverter \
 423   cmParseArgumentsCommand \
 424   cmPathLabel \
 425   cmPolicies \
 426   cmProcessOutput \
 427   cmProjectCommand \
 428   cmPropertyDefinition \
 429   cmPropertyMap \
 430   cmGccDepfileLexerHelper \
 431   cmGccDepfileReader \
 432   cmReturnCommand \
 433   cmRulePlaceholderExpander \
 434   cmRuntimeDependencyArchive \
 435   cmScriptGenerator \
 436   cmSearchPath \
 437   cmSeparateArgumentsCommand \
 438   cmSetCommand \
 439   cmSetDirectoryPropertiesCommand \
 440   cmSetPropertyCommand \
 441   cmSetSourceFilesPropertiesCommand \
 442   cmSetTargetPropertiesCommand \
 443   cmSetTestsPropertiesCommand \
 444   cmSiteNameCommand \
 445   cmSourceFile \
 446   cmSourceFileLocation \
 447   cmStandardLevelResolver \
 448   cmState \
 449   cmStateDirectory \
 450   cmStateSnapshot \
 451   cmString \
 452   cmStringAlgorithms \
 453   cmStringReplaceHelper \
 454   cmStringCommand \
 455   cmSubcommandTable \
 456   cmSubdirCommand \
 457   cmSystemTools \
 458   cmTarget \
 459   cmTargetCompileDefinitionsCommand \
 460   cmTargetCompileFeaturesCommand \
 461   cmTargetCompileOptionsCommand \
 462   cmTargetIncludeDirectoriesCommand \
 463   cmTargetLinkLibrariesCommand \
 464   cmTargetLinkOptionsCommand \
 465   cmTargetPrecompileHeadersCommand \
 466   cmTargetPropCommandBase \
 467   cmTargetPropertyComputer \
 468   cmTargetSourcesCommand \
 469   cmTest \
 470   cmTestGenerator \
 471   cmTimestamp \
 472   cmTransformDepfile \
 473   cmTryCompileCommand \
 474   cmTryRunCommand \
 475   cmUnsetCommand \
 476   cmUVHandlePtr \
 477   cmUVProcessChain \
 478   cmVersion \
 479   cmWhileCommand \
 480   cmWorkingDirectory \
 481   cmake  \
 482   cmakemain \
 483   cmcmd  \
 484 "
 485
 486 if ${cmake_system_mingw}; then
 487   CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
 488     cmGlobalMSYSMakefileGenerator \
 489     cmGlobalMinGWMakefileGenerator \
 490     cmVSSetupHelper \
 491   "
 492 fi
 493
 494 CMAKE_STD_CXX_HEADERS="\
 495   filesystem \
 496   memory \
 497   optional \
 498   shared_mutex \
 499   string_view \
 500   utility \
 501 "
 502 CMAKE_STD_CXX_SOURCES="\
 503   fs_path \
 504   string_view \
 505 "
 506
 507 LexerParser_CXX_SOURCES="\
 508   cmCommandArgumentLexer \
 509   cmCommandArgumentParser \
 510   cmExprLexer \
 511   cmExprParser \
 512   cmGccDepfileLexer \
 513 "
 514
 515 LexerParser_C_SOURCES="\
 516   cmListFileLexer \
 517 "
 518
 519 if ${cmake_system_mingw}; then
 520   KWSYS_C_SOURCES="\
 521     EncodingC \
 522     ProcessWin32 \
 523     String \
 524     System \
 525     Terminal"
 526 else
 527   KWSYS_C_SOURCES="\
 528     EncodingC \
 529     ProcessUNIX \
 530     String \
 531     System \
 532     Terminal"
 533 fi
 534
 535 KWSYS_CXX_SOURCES="\
 536   Directory \
 537   EncodingCXX \
 538   FStream \
 539   Glob \
 540   RegularExpression \
 541   Status \
 542   SystemTools"
 543
 544 KWSYS_FILES="\
 545   Directory.hxx \
 546   Encoding.h \
 547   Encoding.hxx \
 548   FStream.hxx \
 549   Glob.hxx \
 550   Process.h \
 551   RegularExpression.hxx \
 552   Status.hxx \
 553   String.h \
 554   String.hxx \
 555   System.h \
 556   SystemTools.hxx \
 557   Terminal.h"
 558
 559 LIBRHASH_C_SOURCES="\
 560   librhash/algorithms.c \
 561   librhash/byte_order.c \
 562   librhash/hex.c \
 563   librhash/md5.c \
 564   librhash/rhash.c \
 565   librhash/sha1.c \
 566   librhash/sha256.c \
 567   librhash/sha3.c \
 568   librhash/sha512.c \
 569   "
 570
 571 if ${cmake_system_mingw}; then
 572   LIBUV_C_SOURCES="\
 573     src/fs-poll.c \
 574     src/idna.c
 575     src/inet.c \
 576     src/threadpool.c \
 577     src/strscpy.c \
 578     src/timer.c \
 579     src/uv-common.c \
 580     src/win/async.c \
 581     src/win/core.c \
 582     src/win/detect-wakeup.c \
 583     src/win/dl.c \
 584     src/win/error.c \
 585     src/win/fs-event.c \
 586     src/win/fs.c \
 587     src/win/getaddrinfo.c \
 588     src/win/getnameinfo.c \
 589     src/win/handle.c \
 590     src/win/loop-watcher.c \
 591     src/win/pipe.c \
 592     src/win/poll.c \
 593     src/win/process-stdio.c \
 594     src/win/process.c \
 595     src/win/signal.c \
 596     src/win/stream.c \
 597     src/win/tcp.c \
 598     src/win/thread.c \
 599     src/win/tty.c \
 600     src/win/udp.c \
 601     src/win/util.c \
 602     src/win/winapi.c \
 603     src/win/winsock.c \
 604     "
 605 else
 606   LIBUV_C_SOURCES="\
 607     src/strscpy.c \
 608     src/timer.c \
 609     src/uv-common.c \
 610     src/unix/cmake-bootstrap.c \
 611     src/unix/core.c \
 612     src/unix/fs.c \
 613     src/unix/loop.c \
 614     src/unix/loop-watcher.c \
 615     src/unix/no-fsevents.c \
 616     src/unix/pipe.c \
 617     src/unix/poll.c \
 618     src/unix/posix-hrtime.c \
 619     src/unix/posix-poll.c \
 620     src/unix/process.c \
 621     src/unix/signal.c \
 622     src/unix/stream.c \
 623     "
 624 fi
 625
 626 # Display CMake bootstrap usage
 627 cmake_usage()
 628 {
 629 echo '
 630 Usage: '"$0"' [<options>...] [-- <cmake-options>...]
 631 Options: [defaults in brackets after descriptions]
 632 Configuration:
 633   --help                  print this message
 634   --version               only print version information
 635   --verbose               display more information
 636   --parallel=n            bootstrap cmake in parallel, where n is
 637                           number of nodes [1]
 638   --generator=<generator> generator to use (MSYS Makefiles, Unix Makefiles,
 639                           or Ninja)
 640   --enable-ccache         Enable ccache when building cmake
 641   --init=FILE             load FILE as script to populate cache
 642   --system-libs           use all system-installed third-party libraries
 643                           (for use only by package maintainers)
 644   --no-system-libs        use all cmake-provided third-party libraries
 645                           (default)
 646   --system-curl           use system-installed curl library
 647   --no-system-curl        use cmake-provided curl library (default)
 648   --system-expat          use system-installed expat library
 649   --no-system-expat       use cmake-provided expat library (default)
 650   --system-jsoncpp        use system-installed jsoncpp library
 651   --no-system-jsoncpp     use cmake-provided jsoncpp library (default)
 652   --system-zlib           use system-installed zlib library
 653   --no-system-zlib        use cmake-provided zlib library (default)
 654   --system-bzip2          use system-installed bzip2 library
 655   --no-system-bzip2       use cmake-provided bzip2 library (default)
 656   --system-liblzma        use system-installed liblzma library
 657   --no-system-liblzma     use cmake-provided liblzma library (default)
 658   --system-nghttp2        use system-installed nghttp2 library
 659   --no-system-nghttp2     use cmake-provided nghttp2 library (default)
 660   --system-zstd           use system-installed zstd library
 661   --no-system-zstd        use cmake-provided zstd library (default)
 662   --system-libarchive     use system-installed libarchive library
 663   --no-system-libarchive  use cmake-provided libarchive library (default)
 664   --system-librhash       use system-installed librhash library
 665   --no-system-librhash    use cmake-provided librhash library (default)
 666   --system-libuv          use system-installed libuv library
 667   --no-system-libuv       use cmake-provided libuv library (default)
 668
 669   --bootstrap-system-libuv use system-installed libuv library for bootstrap
 670   --bootstrap-system-jsoncpp use system-installed jsoncpp library for bootstrap
 671   --bootstrap-system-librhash use system-installed librhash library for bootstrap
 672
 673   --qt-gui                build the Qt-based GUI (requires Qt >= 4.2)
 674   --no-qt-gui             do not build the Qt-based GUI (default)
 675   --qt-qmake=<qmake>      use <qmake> as the qmake executable to find Qt
 676
 677   --sphinx-info           build Info manual with Sphinx
 678   --sphinx-man            build man pages with Sphinx
 679   --sphinx-html           build html help with Sphinx
 680   --sphinx-qthelp         build qch help with Sphinx
 681   --sphinx-latexpdf       build PDF with Sphinx using LaTeX
 682   --sphinx-build=<sb>     use <sb> as the sphinx-build executable
 683   --sphinx-flags=<flags>  pass <flags> to sphinx-build executable
 684
 685 Directory and file names:
 686   --prefix=PREFIX         install files in tree rooted at PREFIX
 687                           ['"${cmake_default_prefix}"']
 688   --bindir=DIR            install binaries in PREFIX/DIR
 689                           ['"${cmake_bin_dir_default}"']
 690   --datadir=DIR           install data files in PREFIX/DIR
 691                           ['"${cmake_data_dir_default}"']
 692   --docdir=DIR            install documentation files in PREFIX/DIR
 693                           ['"${cmake_doc_dir_default}"']
 694   --mandir=DIR            install man pages files in PREFIX/DIR/manN
 695                           ['"${cmake_man_dir_default}"']
 696   --xdgdatadir=DIR        install XDG specific files in PREFIX/DIR
 697                           ['"${cmake_xdgdata_dir_default}"']
 698 '
 699   exit 10
 700 }
 701
 702 # Display CMake bootstrap usage
 703 cmake_version_display()
 704 {
 705   echo "CMake ${cmake_version}, ${cmake_copyright}"
 706 }
 707
 708 # Display CMake bootstrap error, display the log file and exit
 709 cmake_error()
 710 {
 711   res=$1
 712   shift 1
 713   echo "---------------------------------------------"
 714   echo "Error when bootstrapping CMake:"
 715   echo "$*"
 716   echo "---------------------------------------------"
 717   if test -f cmake_bootstrap.log; then
 718     echo "Log of errors: `pwd`/cmake_bootstrap.log"
 719     #cat cmake_bootstrap.log
 720     echo "---------------------------------------------"
 721   fi
 722   exit ${res}
 723 }
 724
 725 cmake_generate_file_tmp ()
 726 {
 727   OUTFILE="$1"
 728   TMPFILE="$2"
 729   if "${_diff}" "$TMPFILE" "$OUTFILE" > /dev/null 2> /dev/null ; then
 730     rm -f "$TMPFILE"
 731   else
 732     mv -f "$TMPFILE" "$OUTFILE"
 733   fi
 734 }
 735
 736 cmake_generate_file ()
 737 {
 738   OUTFILE="$1"
 739   CONTENT="$2"
 740   echo "$CONTENT" > "$OUTFILE.tmp"
 741   cmake_generate_file_tmp "$OUTFILE" "$OUTFILE.tmp"
 742 }
 743
 744 # Replace KWSYS_NAMESPACE with cmsys
 745 cmake_replace_string ()
 746 {
 747   INFILE="$1"
 748   OUTFILE="$2"
 749   SEARCHFOR="$3"
 750   REPLACEWITH="$4"
 751   if test -f "${INFILE}" || ${cmake_system_openvms}; then
 752     sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}"
 753     if test -f "${OUTFILE}${_tmp}"; then
 754       if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
 755         #echo "Files are the same"
 756         rm -f "${OUTFILE}${_tmp}"
 757       else
 758         mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
 759       fi
 760     fi
 761   else
 762     cmake_error 1 "Cannot find file ${INFILE}"
 763   fi
 764 }
 765
 766 cmake_kwsys_config_replace_string ()
 767 {
 768   INFILE="$1"
 769   OUTFILE="$2"
 770   shift 2
 771   APPEND="$*"
 772   if test -f "${INFILE}" || ${cmake_system_openvms}; then
 773     echo "${APPEND}" > "${OUTFILE}${_tmp}"
 774     sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g;
 775               s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/g;
 776               s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g;
 777               s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g;
 778               s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g;
 779               s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g;
 780               s/@KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/g;
 781               s/@KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP@/${KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP}/g;
 782              }" "${INFILE}" >> "${OUTFILE}${_tmp}"
 783     if test -f "${OUTFILE}${_tmp}"; then
 784       if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
 785         #echo "Files are the same"
 786         rm -f "${OUTFILE}${_tmp}"
 787       else
 788         mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
 789       fi
 790     fi
 791   else
 792     cmake_error 2 "Cannot find file ${INFILE}"
 793   fi
 794 }
 795 # Write string into a file
 796 cmake_report ()
 797 {
 798   FILE=$1
 799   shift
 800   echo "$*" >> ${FILE}
 801 }
 802
 803 # Escape spaces in strings for artifacts
 804 cmake_escape_artifact ()
 805 {
 806   if test "${cmake_bootstrap_generator}" = "Ninja"; then
 807     echo $1 | sed "s/ /$ /g"
 808   else
 809     echo $1 | sed "s/ /\\\\ /g"
 810   fi
 811 }
 812
 813 # Escape spaces in strings for shell
 814 cmake_escape_shell ()
 815 {
 816   echo $1 | sed "s/ /\\\\ /g"
 817 }
 818
 819 # Encode object file names.
 820 cmake_obj ()
 821 {
 822   echo $1 | sed 's/\//-/g' | sed 's/$/\.o/'
 823 }
 824
 825 # Strip prefix from argument
 826 cmake_arg ()
 827 {
 828   echo "$1" | sed "s/^${2-[^=]*=}//"
 829 }
 830
 831 # Write message to the log
 832 cmake_log ()
 833 {
 834   echo "$*" >> cmake_bootstrap.log
 835 }
 836
 837 # Return temp file
 838 cmake_tmp_file ()
 839 {
 840   echo "cmake_bootstrap_$$_test"
 841 }
 842
 843 # Run a compiler test. First argument is compiler, second one are compiler
 844 # flags, third one is test source file to be compiled
 845 cmake_try_run ()
 846 {
 847   COMPILER=$1
 848   FLAGS=$2
 849   TESTFILE=$3
 850   if test ! -f "${TESTFILE}"; then
 851     echo "Test file ${TESTFILE} missing. Please verify your CMake source tree."
 852     exit 4
 853   fi
 854   TMPFILE=`cmake_tmp_file`
 855   echo "Try: ${COMPILER}"
 856   echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}"
 857   echo "----------  file   -----------------------"
 858   cat "${TESTFILE}"
 859   echo "------------------------------------------"
 860   "${COMPILER}" ${FLAGS} "${TESTFILE}" -o "${TMPFILE}"
 861   RES=$?
 862   if test "${RES}" -ne "0"; then
 863     echo "Test failed to compile"
 864     return 1
 865   fi
 866   if test ! -f "${TMPFILE}" && test ! -f "${TMPFILE}.exe"; then
 867     echo "Test failed to produce executable"
 868     return 2
 869   fi
 870   ./${TMPFILE}
 871   RES=$?
 872   rm -f "${TMPFILE}"
 873   if test "${RES}" -ne "0"; then
 874     echo "Test produced non-zero return code"
 875     return 3
 876   fi
 877   echo "Test succeeded"
 878   return 0
 879 }
 880
 881 # Run a make test. First argument is the make interpreter.
 882 cmake_try_make ()
 883 {
 884   MAKE_PROC="$1"
 885   MAKE_FLAGS="$2"
 886   echo "Try: ${MAKE_PROC}"
 887   "${MAKE_PROC}" ${MAKE_FLAGS}
 888   RES=$?
 889   if test "${RES}" -ne "0"; then
 890     echo "${MAKE_PROC} does not work"
 891     return 1
 892   fi
 893   if test ! -f "test" && test ! -f "test.exe"; then
 894     echo "${COMPILER} does not produce output"
 895     return 2
 896   fi
 897   ./test
 898   RES=$?
 899   rm -f "test"
 900   if test "${RES}" -ne "0"; then
 901     echo "${MAKE_PROC} produces strange executable"
 902     return 3
 903   fi
 904   echo "${MAKE_PROC} works"
 905   return 0
 906 }
 907
 908 # Parse arguments
 909 cmake_verbose=
 910 cmake_parallel_make=
 911 cmake_ccache_enabled=
 912 cmake_prefix_dir="${cmake_default_prefix}"
 913 bootstrap_system_libuv=
 914 bootstrap_system_jsoncpp=
 915 bootstrap_system_librhash=
 916 while test $# != 0; do
 917   case "$1" in
 918   --prefix=*) dir=`cmake_arg "$1"`
 919               cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;;
 920   --parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;;
 921   --generator=*) cmake_bootstrap_generator=`cmake_arg "$1"` ;;
 922   --bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;;
 923   --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;;
 924   --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;;
 925   --mandir=*) cmake_man_dir=`cmake_arg "$1"` ;;
 926   --xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;;
 927   --init=*) cmake_init_file=`cmake_arg "$1"` ;;
 928   --system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=1" ;;
 929   --no-system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=0" ;;
 930   --system-bzip2|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma|--system-nghttp2|--system-zstd|--system-libuv)
 931     lib=`cmake_arg "$1" "--system-"`
 932     cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;;
 933   --no-system-bzip2|--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)
 934     lib=`cmake_arg "$1" "--no-system-"`
 935     cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;;
 936   --bootstrap-system-libuv) bootstrap_system_libuv="1" ;;
 937   --bootstrap-system-jsoncpp) bootstrap_system_jsoncpp="1" ;;
 938   --bootstrap-system-librhash) bootstrap_system_librhash="1" ;;
 939   --qt-gui) cmake_bootstrap_qt_gui="1" ;;
 940   --no-qt-gui) cmake_bootstrap_qt_gui="0" ;;
 941   --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;;
 942   --sphinx-info) cmake_sphinx_info="1" ;;
 943   --sphinx-man) cmake_sphinx_man="1" ;;
 944   --sphinx-html) cmake_sphinx_html="1" ;;
 945   --sphinx-qthelp) cmake_sphinx_qthelp="1" ;;
 946   --sphinx-latexpdf) cmake_sphinx_latexpdf="1" ;;
 947   --sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;;
 948   --sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;;
 949   --help) cmake_usage ;;
 950   --version) cmake_version_display ; exit 2 ;;
 951   --verbose) cmake_verbose=TRUE ;;
 952   --enable-ccache) cmake_ccache_enabled=TRUE ;;
 953   CC=*) CC=`cmake_arg "$1"` ;;
 954   CXX=*) CXX=`cmake_arg "$1"` ;;
 955   CFLAGS=*) CFLAGS=`cmake_arg "$1"` ;;
 956   CXXFLAGS=*) CXXFLAGS=`cmake_arg "$1"` ;;
 957   LDFLAGS=*) LDFLAGS=`cmake_arg "$1"` ;;
 958   --) shift; break ;;
 959   *) die "Unknown option: $1" ;;
 960   esac
 961   shift
 962 done
 963
 964 # Make sure the generator is valid
 965 case "${cmake_bootstrap_generator}" in
 966   'MSYS Makefiles'|'Unix Makefiles'|'Ninja') ;;
 967   *) cmake_error 10 "Invalid generator: ${cmake_bootstrap_generator}"
 968 esac
 969
 970 # If verbose, display some information about bootstrap
 971 if test -n "${cmake_verbose}"; then
 972   echo "---------------------------------------------"
 973   echo "Source directory: ${cmake_source_dir}"
 974   echo "Binary directory: ${cmake_binary_dir}"
 975   echo "Prefix directory: ${cmake_prefix_dir}"
 976   echo "System:           ${cmake_system}"
 977   echo "Generator:        ${cmake_bootstrap_generator}"
 978   if test "x${cmake_parallel_make}" != "x"; then
 979     echo "Doing parallel make: ${cmake_parallel_make}"
 980   fi
 981   echo ""
 982 fi
 983
 984 echo "---------------------------------------------"
 985 # Get CMake version
 986 echo "`cmake_version_display`"
 987
 988 # Check for in-source build
 989 cmake_in_source_build=
 990 if test -f "${cmake_binary_dir}/Source/cmake.cxx" &&
 991      test -f "${cmake_binary_dir}/Source/cmake.h"; then
 992   if test -n "${cmake_verbose}"; then
 993     echo "Warning: This is an in-source build"
 994   fi
 995   cmake_in_source_build=TRUE
 996 fi
 997
 998 # If this is not an in-source build, then Bootstrap stuff should not exist.
 999 if test -z "${cmake_in_source_build}"; then
1000   # Did somebody bootstrap in the source tree?
1001   if test -d "${cmake_source_dir}/Bootstrap${_cmk}"; then
1002     cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\".
1003 Looks like somebody did bootstrap CMake in the source tree, but now you are
1004 trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk}
1005 directory from the source tree."
1006   fi
1007   # Is there a cache in the source tree?
1008   for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do
1009     if test -f "${cmake_source_dir}/${cmake_problematic_file}"; then
1010       cmake_error 10 "Found \"${cmake_source_dir}/${cmake_problematic_file}\".
1011 Looks like somebody tried to build CMake in the source tree, but now you are
1012 trying to do bootstrap in the binary tree. Please remove \"${cmake_problematic_file}\"
1013 from the source tree."
1014     fi
1015   done
1016 fi
1017
1018 # Make bootstrap directory
1019 test -d "${cmake_bootstrap_dir}" || mkdir "${cmake_bootstrap_dir}"
1020 if test ! -d "${cmake_bootstrap_dir}"; then
1021   cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake."
1022 fi
1023 cd "${cmake_bootstrap_dir}"
1024
1025 test -d "cmsys" || mkdir "cmsys"
1026 if test ! -d "cmsys"; then
1027   cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys"
1028 fi
1029
1030 # Delete all the bootstrap files
1031 rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log"
1032 rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}"
1033 rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}"
1034
1035 # If building in-source, remove any cmConfigure.h that may
1036 # have been created by a previous run of the bootstrap cmake.
1037 if test -n "${cmake_in_source_build}"; then
1038   rm -f "${cmake_source_dir}/Source/cmConfigure.h"
1039 fi
1040
1041 # If exist compiler flags, set them
1042 cmake_c_flags=${CFLAGS}
1043 cmake_cxx_flags=${CXXFLAGS}
1044 cmake_ld_flags=${LDFLAGS}
1045
1046 # Add generator-specific files
1047 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1048   CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
1049     cmFortranParserImpl \
1050     cmGlobalNinjaGenerator \
1051     cmLocalNinjaGenerator \
1052     cmNinjaLinkLineComputer \
1053     cmNinjaLinkLineDeviceComputer \
1054     cmNinjaNormalTargetGenerator \
1055     cmNinjaTargetGenerator \
1056     cmNinjaUtilityTargetGenerator \
1057     "
1058
1059   LexerParser_CXX_SOURCES="${LexerParser_CXX_SOURCES} \
1060     cmFortranLexer \
1061     cmFortranParser \
1062     "
1063
1064   JSONCPP_CXX_SOURCES="\
1065     src/lib_json/json_reader.cpp \
1066     src/lib_json/json_value.cpp \
1067     src/lib_json/json_writer.cpp \
1068     "
1069 else
1070   CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
1071     cmDepends \
1072     cmDependsC \
1073     cmDependsCompiler \
1074     cmGlobalUnixMakefileGenerator3 \
1075     cmLocalUnixMakefileGenerator3 \
1076     cmMakefileExecutableTargetGenerator \
1077     cmMakefileLibraryTargetGenerator \
1078     cmMakefileTargetGenerator \
1079     cmMakefileUtilityTargetGenerator \
1080     cmProcessTools \
1081     "
1082
1083   JSONCPP_CXX_SOURCES=
1084 fi
1085
1086 # Add Cygwin-specific flags
1087 if ${cmake_system_cygwin} || ${cmake_system_msys}; then
1088   cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import"
1089 fi
1090
1091 # Add CoreFoundation framework on Darwin
1092 if ${cmake_system_darwin}; then
1093   cmake_ld_flags="${LDFLAGS} -framework CoreFoundation"
1094 fi
1095
1096 # Add BeOS toolkits...
1097 if ${cmake_system_beos}; then
1098   cmake_ld_flags="${LDFLAGS} -lroot -lbe"
1099 fi
1100
1101 # Add Haiku toolkits...
1102 if ${cmake_system_haiku}; then
1103   cmake_ld_flags="${LDFLAGS} -lroot -lbe"
1104 fi
1105
1106 #-----------------------------------------------------------------------------
1107 # Detect known toolchains on some platforms.
1108 cmake_toolchains=''
1109 case "${cmake_system}" in
1110   *AIX*)   cmake_toolchains='XL GNU' ;;
1111   *CYGWIN*) cmake_toolchains='GNU' ;;
1112   *MSYS*) cmake_toolchains='GNU' ;;
1113   *Darwin*) cmake_toolchains='Clang GNU' ;;
1114   *Linux*) cmake_toolchains='GNU Clang XL PGI PathScale' ;;
1115   *MINGW*) cmake_toolchains='GNU' ;;
1116 esac
1117
1118 # Toolchain compiler name table.
1119 cmake_toolchain_Clang_CC='clang'
1120 cmake_toolchain_Clang_CXX='clang++'
1121 cmake_toolchain_GNU_CC='gcc'
1122 cmake_toolchain_GNU_CXX='g++'
1123 cmake_toolchain_PGI_CC='pgcc'
1124 cmake_toolchain_PGI_CXX='pgCC'
1125 cmake_toolchain_PathScale_CC='pathcc'
1126 cmake_toolchain_PathScale_CXX='pathCC'
1127 cmake_toolchain_XL_CC='xlc'
1128 cmake_toolchain_XL_CXX='xlC'
1129
1130 cmake_toolchain_try()
1131 {
1132   tc="$1"
1133   TMPFILE=`cmake_tmp_file`
1134
1135   eval "tc_CC=\${cmake_toolchain_${tc}_CC}"
1136   echo 'int main() { return 0; }' > "${TMPFILE}.c"
1137   cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1
1138   tc_result_CC="$?"
1139   rm -f "${TMPFILE}.c"
1140   test "${tc_result_CC}" = "0" || return 1
1141
1142   eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}"
1143   echo 'int main() { return 0; }' > "${TMPFILE}.cpp"
1144   cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1
1145   tc_result_CXX="$?"
1146   rm -f "${TMPFILE}.cpp"
1147   test "${tc_result_CXX}" = "0" || return 1
1148
1149   cmake_toolchain="$tc"
1150 }
1151
1152 cmake_toolchain_detect()
1153 {
1154   cmake_toolchain=
1155   for tc in ${cmake_toolchains}; do
1156     echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1
1157     cmake_toolchain_try "$tc" &&
1158     echo "Found $tc toolchain" &&
1159     break
1160   done
1161 }
1162
1163 if test -z "${CC}" && test -z "${CXX}"; then
1164   cmake_toolchain_detect
1165 fi
1166
1167 thread_flags=''
1168 case "${cmake_system}" in
1169   *AIX*)   thread_flags='-pthread' ;;
1170 esac
1171
1172 #-----------------------------------------------------------------------------
1173 # Test C compiler
1174 cmake_c_compiler=
1175
1176 # If CC is set, use that for compiler, otherwise use list of known compilers
1177 if test -n "${cmake_toolchain}"; then
1178   eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}"
1179 elif test -n "${CC}"; then
1180   cmake_c_compilers="${CC}"
1181 else
1182   cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}"
1183 fi
1184
1185 # Check if C compiler works
1186 TMPFILE=`cmake_tmp_file`
1187 echo '
1188 #ifdef __cplusplus
1189 # error "The CMAKE_C_COMPILER is set to a C++ compiler"
1190 #endif
1191
1192 #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
1193 #error "On AIX with GNU we need the -pthread flag."
1194 #endif
1195
1196 #if defined(__sun) && __STDC_VERSION__ < 199901L
1197 #error "On Solaris we need C99."
1198 #endif
1199
1200 #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
1201 #error "On HP-UX we need GCC 4.9 or higher."
1202 #endif
1203
1204 #include <stdio.h>
1205
1206 int main(int argc, char* argv[])
1207 {
1208   printf("%d%c", (argv != 0), (char)0x0a);
1209   return argc - 1;
1210 }
1211 ' > "${TMPFILE}.c"
1212 for std in 11 99 90; do
1213   std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`"
1214   for compiler in ${cmake_c_compilers}; do
1215     for std_flag in '' $std_flags; do
1216       for thread_flag in '' $thread_flags; do
1217         echo "Checking whether '${compiler} ${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
1218         if cmake_try_run "${compiler}" "${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \
1219           "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then
1220           cmake_c_compiler="${compiler}"
1221           cmake_c_flags="${cmake_c_flags} ${std_flag} ${thread_flag}"
1222           break 4
1223         fi
1224       done
1225     done
1226   done
1227 done
1228 rm -f "${TMPFILE}.c"
1229
1230 if test -z "${cmake_c_compiler}"; then
1231   cmake_error 6 "Cannot find appropriate C compiler on this system.
1232 Please specify one using environment variable CC.
1233 See cmake_bootstrap.log for compilers attempted.
1234 "
1235 fi
1236 echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}"
1237
1238 #-----------------------------------------------------------------------------
1239 # Test CXX compiler
1240 cmake_cxx_compiler=
1241
1242 # On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler.
1243
1244 # If CC is set, use that for compiler, otherwise use list of known compilers
1245 if test -n "${cmake_toolchain}"; then
1246   eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}"
1247 elif test -n "${CXX}"; then
1248   cmake_cxx_compilers="${CXX}"
1249 else
1250   cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}"
1251 fi
1252
1253 # Check if C++ compiler works
1254 TMPFILE=`cmake_tmp_file`
1255 echo '
1256 #include <iostream>
1257 #include <memory>
1258 #include <unordered_map>
1259
1260 #if __cplusplus < 201103L
1261 #error "Compiler is not in a mode aware of C++11."
1262 #endif
1263
1264 #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
1265 #error "On AIX with GNU we need the -pthread flag."
1266 #endif
1267
1268 #if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5140
1269 #error "SunPro <= 5.13 mode not supported due to bug in move semantics."
1270 #endif
1271
1272 #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
1273 #error "On HP-UX we need GCC 4.9 or higher."
1274 #endif
1275
1276 #if __cplusplus > 201103L
1277 #include <iterator>
1278 int check_cxx14()
1279 {
1280   int a[] = { 0, 1, 2 };
1281   auto ai = std::cbegin(a);
1282
1283   int b[] = { 2, 1, 0 };
1284   auto bi = std::cend(b);
1285
1286   return *ai + *(bi - 1);
1287 }
1288 #else
1289 int check_cxx14()
1290 {
1291   return 0;
1292 }
1293 #endif
1294
1295 #if (__cplusplus >= 201703L || defined(__INTEL_COMPILER) && defined(__cpp_deduction_guides))
1296 #include <optional>
1297 template <typename T,
1298           typename std::invoke_result<decltype(&T::get), T>::type = nullptr>
1299 typename T::pointer get_ptr(T& item)
1300 {
1301   return item.get();
1302 }
1303
1304 int check_cxx17()
1305 {
1306   // Intel compiler do not handle correctly 'decltype' inside 'invoke_result'
1307   std::unique_ptr<int> u(new int(0));
1308   get_ptr(u);
1309   std::optional<int> oi = 0;
1310   return oi.value();
1311 }
1312 #else
1313 int check_cxx17()
1314 {
1315   return 0;
1316 }
1317 #endif
1318
1319 class Class
1320 {
1321 public:
1322   int Get() const { return this->Member; }
1323 private:
1324   int Member = 1;
1325 };
1326 int main()
1327 {
1328   auto const c = std::unique_ptr<Class>(new Class);
1329   std::cout << c->Get() << check_cxx14() << check_cxx17() << std::endl;
1330   return 0;
1331 }
1332 ' > "${TMPFILE}.cxx"
1333 for std in 17 14 11; do
1334   std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" CXX \"${std}\"`"
1335   for compiler in ${cmake_cxx_compilers}; do
1336     for std_flag in '' $std_flags; do
1337       for thread_flag in '' $thread_flags; do
1338         echo "Checking whether '${compiler} ${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
1339         if cmake_try_run "${compiler}" "${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \
1340           "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then
1341           cmake_cxx_compiler="${compiler}"
1342           cmake_cxx_flags="${cmake_cxx_flags} ${std_flag} ${thread_flag} "
1343           break 4
1344         fi
1345       done
1346     done
1347   done
1348 done
1349 rm -f "${TMPFILE}.cxx"
1350
1351 if test -z "${cmake_cxx_compiler}"; then
1352 cmake_error 7 "Cannot find a C++ compiler that supports both C++11 and the specified C++ flags.
1353 Please specify one using environment variable CXX.
1354 The C++ flags are \"$cmake_cxx_flags\".
1355 They can be changed using the environment variable CXXFLAGS.
1356 See cmake_bootstrap.log for compilers attempted."
1357 fi
1358 echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}"
1359
1360 #-----------------------------------------------------------------------------
1361 # Test CXX features
1362
1363 cmake_cxx_features="make_unique filesystem"
1364
1365 for feature in ${cmake_cxx_features}; do
1366   eval "cmake_have_cxx_${feature}=0"
1367   echo "Checking whether '${cmake_cxx_compiler} ${cmake_cxx_flags} ${cmake_ld_flags}' supports '${feature}'." >> cmake_bootstrap.log 2>&1
1368   if cmake_try_run "${cmake_cxx_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags}" \
1369                    "${cmake_source_dir}/Source/Checks/cm_cxx_${feature}.cxx" >> cmake_bootstrap.log 2>&1; then
1370     eval "cmake_have_cxx_${feature}=1"
1371   fi
1372 done
1373
1374 cmake_have_cxx_features=""
1375 for feature in ${cmake_cxx_features}; do
1376   feature_variable="cmake_have_cxx_${feature}"
1377   eval "feature_value=\${${feature_variable}}"
1378   if test "${feature_value}" -eq "1"; then
1379     cmake_have_cxx_features="${cmake_have_cxx_features} -DCMake_HAVE_CXX_`cmake_toupper ${feature}`=${feature_value}"
1380   fi
1381 done
1382
1383 cmake_generate_file "${cmake_bootstrap_dir}/cmSTL.hxx" ""
1384
1385
1386 #-----------------------------------------------------------------------------
1387 # Test Make
1388
1389 cmake_make_processor=
1390 cmake_make_flags=
1391
1392 # If MAKE is set, use that for make processor, otherwise use list of known make
1393 if test -n "${MAKE}"; then
1394   cmake_make_processors="${MAKE}"
1395 elif test "${cmake_bootstrap_generator}" = "Ninja"; then
1396   cmake_make_processors="${CMAKE_KNOWN_NINJA_PROCESSORS}"
1397 else
1398   cmake_make_processors="${CMAKE_KNOWN_MAKE_PROCESSORS}"
1399 fi
1400
1401 TMPFILE="`cmake_tmp_file`_dir"
1402 rm -rf "${cmake_bootstrap_dir}/${TMPFILE}"
1403 mkdir "${cmake_bootstrap_dir}/${TMPFILE}"
1404 cd "${cmake_bootstrap_dir}/${TMPFILE}"
1405 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1406   echo '
1407 rule cc
1408   command = "'"${cmake_c_compiler}"'" '"${cmake_ld_flags} ${cmake_c_flags}"' -o $out $in
1409 build test: cc test.c
1410 '>"build.ninja"
1411 else
1412   echo '
1413 test: test.c
1414         "'"${cmake_c_compiler}"'" '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c
1415 '>"Makefile"
1416 fi
1417 echo '
1418 #include <stdio.h>
1419 int main(){ printf("1%c", (char)0x0a); return 0; }
1420 ' > "test.c"
1421 cmake_original_make_flags="${cmake_make_flags}"
1422 if test "x${cmake_parallel_make}" != "x"; then
1423   cmake_make_flags="${cmake_make_flags} -j ${cmake_parallel_make}"
1424 fi
1425 for a in ${cmake_make_processors}; do
1426   if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then
1427     cmake_make_processor="${a}"
1428   fi
1429 done
1430 cmake_full_make_flags="${cmake_make_flags}"
1431 if test "x${cmake_original_make_flags}" != "x${cmake_make_flags}"; then
1432   if test -z "${cmake_make_processor}"; then
1433     cmake_make_flags="${cmake_original_make_flags}"
1434     for a in ${cmake_make_processors}; do
1435       if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then
1436         cmake_make_processor="${a}"
1437       fi
1438     done
1439   fi
1440 fi
1441 cd "${cmake_bootstrap_dir}"
1442
1443 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1444   mf_str=Ninja
1445 else
1446   mf_str=Makefile
1447 fi
1448 if test -z "${cmake_make_processor}"; then
1449   cmake_error 8 "Cannot find appropriate ${mf_str} processor on this system.
1450 Please specify one using environment variable MAKE."
1451 fi
1452 rm -rf "${cmake_bootstrap_dir}/${TMPFILE}"
1453 echo "${mf_str} processor on this system is: ${cmake_make_processor}"
1454 if test "x${cmake_full_make_flags}" != "x${cmake_make_flags}"; then
1455   echo "---------------------------------------------"
1456   echo "${mf_str} processor ${cmake_make_processor} does not support parallel build"
1457   echo "---------------------------------------------"
1458 fi
1459
1460 # Test for kwsys features
1461 KWSYS_NAME_IS_KWSYS=0
1462 KWSYS_BUILD_SHARED=0
1463 KWSYS_LFS_AVAILABLE=0
1464 KWSYS_LFS_REQUESTED=0
1465 KWSYS_STL_HAS_WSTRING=0
1466 KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=0
1467 KWSYS_CXX_HAS_SETENV=0
1468 KWSYS_CXX_HAS_UNSETENV=0
1469 KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0
1470 KWSYS_CXX_HAS_UTIMENSAT=0
1471 KWSYS_CXX_HAS_UTIMES=0
1472 KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP=1
1473
1474 if cmake_try_run "${cmake_cxx_compiler}" \
1475   "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_SETENV" \
1476   "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1477   KWSYS_CXX_HAS_SETENV=1
1478   echo "${cmake_cxx_compiler} has setenv"
1479 else
1480   echo "${cmake_cxx_compiler} does not have setenv"
1481 fi
1482
1483 if cmake_try_run "${cmake_cxx_compiler}" \
1484   "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_UNSETENV" \
1485   "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1486   KWSYS_CXX_HAS_UNSETENV=1
1487   echo "${cmake_cxx_compiler} has unsetenv"
1488 else
1489   echo "${cmake_cxx_compiler} does not have unsetenv"
1490 fi
1491
1492 if cmake_try_run "${cmake_cxx_compiler}" \
1493   "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H" \
1494   "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1495   KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=1
1496   echo "${cmake_cxx_compiler} has environ in stdlib.h"
1497 else
1498   echo "${cmake_cxx_compiler} does not have environ in stdlib.h"
1499 fi
1500
1501 if cmake_try_run "${cmake_cxx_compiler}" \
1502   "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_STL_HAS_WSTRING" \
1503   "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1504   KWSYS_STL_HAS_WSTRING=1
1505   echo "${cmake_cxx_compiler} has stl wstring"
1506 else
1507   echo "${cmake_cxx_compiler} does not have stl wstring"
1508 fi
1509
1510 if cmake_try_run "${cmake_cxx_compiler}" \
1511   "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H" \
1512   "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then
1513   KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=1
1514   echo "${cmake_cxx_compiler} has <ext/stdio_filebuf.h>"
1515 else
1516   echo "${cmake_cxx_compiler} does not have <ext/stdio_filebuf.h>"
1517 fi
1518
1519 if test -n "${cmake_ccache_enabled}"; then
1520   echo "Building CMake with ccache"
1521   cmake_c_compiler="ccache ${cmake_c_compiler}"
1522   cmake_cxx_compiler="ccache ${cmake_cxx_compiler}"
1523 fi
1524
1525 # Just to be safe, let us store compiler and flags to the header file
1526
1527 cmake_bootstrap_version='$Revision$'
1528 cmake_compiler_settings_comment="/*
1529  * Generated by ${cmake_source_dir}/bootstrap
1530  * Version:     ${cmake_bootstrap_version}
1531  *
1532  * Source directory: ${cmake_source_dir}
1533  * Binary directory: ${cmake_bootstrap_dir}
1534  *
1535  * C compiler:   ${cmake_c_compiler}
1536  * C flags:      ${cmake_c_flags}
1537  *
1538  * C++ compiler: ${cmake_cxx_compiler}
1539  * C++ flags:    ${cmake_cxx_flags}
1540  *
1541  * Make:         ${cmake_make_processor}
1542  *
1543  * Sources:
1544  * ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES}
1545  * STD Sources:
1546  * ${CMAKE_STD_CXX_HEADERS} ${CMAKE_STD_CXX_SOURCES}
1547  * LexerParser Sources:
1548  * ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES}
1549  * kwSys Sources:
1550  * ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES}
1551  * libuv Sources:
1552  * ${LIBUV_C_SOURCES}
1553  * jsoncpp Sources:
1554  * ${JSONCPP_CXX_SOURCES}
1555  * librhash Sources:
1556  * ${LIBRHASH_C_SOURCES}
1557  */
1558 "
1559
1560 cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}"
1561
1562 # When bootstrapping on MinGW with MSYS we must convert the source
1563 # directory to a windows path.
1564 if ${cmake_system_mingw}; then
1565     CMAKE_BOOTSTRAP_SOURCE_DIR=`cd "${cmake_source_dir}"; pwd -W`
1566     CMAKE_BOOTSTRAP_BINARY_DIR=`cd "${cmake_binary_dir}"; pwd -W`
1567 else
1568     CMAKE_BOOTSTRAP_SOURCE_DIR="${cmake_source_dir}"
1569     CMAKE_BOOTSTRAP_BINARY_DIR="${cmake_binary_dir}"
1570 fi
1571
1572 # Write CMake version
1573 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MAJOR ${cmake_version_major}"
1574 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MINOR ${cmake_version_minor}"
1575 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_PATCH ${cmake_version_patch}"
1576 cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION \"${cmake_version}\""
1577 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_SOURCE_DIR \"${CMAKE_BOOTSTRAP_SOURCE_DIR}\""
1578 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_BINARY_DIR \"${CMAKE_BOOTSTRAP_BINARY_DIR}\""
1579 cmake_report cmConfigure.h${_tmp} "#define CMake_DEFAULT_RECURSION_LIMIT 400"
1580 cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insalled\""
1581 cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\""
1582 cmake_report cmConfigure.h${_tmp} "#define CM_FALLTHROUGH"
1583
1584 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1585   cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_NINJA"
1586 else
1587   cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_MAKEFILES"
1588 fi
1589
1590 if ${cmake_system_mingw}; then
1591   cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(NOMINMAX)"
1592   cmake_report cmConfigure.h${_tmp} "#  define NOMINMAX"
1593   cmake_report cmConfigure.h${_tmp} "#endif"
1594 fi
1595
1596 # Regenerate configured headers
1597 for h in Configure VersionConfig; do
1598   if "${_diff}" cm${h}.h cm${h}.h${_tmp} > /dev/null 2> /dev/null; then
1599     rm -f cm${h}.h${_tmp}
1600   else
1601     mv -f cm${h}.h${_tmp} cm${h}.h
1602   fi
1603 done
1604
1605 # Prepare KWSYS
1606 cmsys_header_files="cmsys/Configure.h cmsys/Configure.hxx"
1607 cmake_kwsys_config_replace_string \
1608   "${cmake_source_dir}/Source/kwsys/Configure.hxx.in" \
1609   "${cmake_bootstrap_dir}/cmsys/Configure.hxx" \
1610   "${cmake_compiler_settings_comment}"
1611 cmake_kwsys_config_replace_string \
1612   "${cmake_source_dir}/Source/kwsys/Configure.h.in" \
1613   "${cmake_bootstrap_dir}/cmsys/Configure.h" \
1614   "${cmake_compiler_settings_comment}"
1615
1616 for a in ${KWSYS_FILES}; do
1617   cmake_replace_string "${cmake_source_dir}/Source/kwsys/${a}.in" \
1618      "${cmake_bootstrap_dir}/cmsys/${a}" KWSYS_NAMESPACE cmsys
1619   cmsys_header_files="${cmsys_header_files} cmsys/${a}"
1620 done
1621
1622 echo "#pragma once" > "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1623 if test "x${bootstrap_system_libuv}" != "x"; then
1624   echo "#define CMAKE_USE_SYSTEM_LIBUV" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1625 fi
1626 if test "x${bootstrap_system_jsoncpp}" != "x"; then
1627   echo "#define CMAKE_USE_SYSTEM_JSONCPP" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1628 fi
1629 if test "x${bootstrap_system_librhash}" != "x"; then
1630   echo "#define CMAKE_USE_SYSTEM_LIBRHASH" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1631 fi
1632 cmake_generate_file_tmp "${cmake_bootstrap_dir}/cmThirdParty.h" "${cmake_bootstrap_dir}/cmThirdParty.h.tmp"
1633
1634 # Generate Makefile
1635 dep="cmConfigure.h ${cmsys_header_files}"
1636 for h in "${cmake_source_dir}"/Source/*.hxx; do
1637   dep="${dep} `cmake_escape_artifact \"${h}\"`"
1638 done
1639 for h in "${cmake_source_dir}"/Source/*.h; do
1640   dep="${dep} `cmake_escape_artifact \"${h}\"`"
1641 done
1642 for h in ${CMAKE_STD_CXX_HEADERS}; do
1643   dep="${dep} `cmake_escape_artifact \"${cmake_source_dir}\"`/Utilities/std/cm/${h}"
1644 done
1645 objs=""
1646 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
1647   objs="${objs} ${a}.o"
1648 done
1649 if test "x${bootstrap_system_libuv}" = "x"; then
1650   for a in ${LIBUV_C_SOURCES}; do
1651     objs="${objs} uv-`cmake_obj ${a}`"
1652   done
1653 fi
1654 if test "x${bootstrap_system_librhash}" = "x"; then
1655   for a in ${LIBRHASH_C_SOURCES}; do
1656     objs="${objs} rhash-`cmake_obj ${a}`"
1657   done
1658 fi
1659 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1660   if test "x${bootstrap_system_jsoncpp}" = "x"; then
1661     for a in ${JSONCPP_CXX_SOURCES}; do
1662       objs="${objs} jsoncpp-`cmake_obj ${a}`"
1663     done
1664   fi
1665 fi
1666
1667 libs=""
1668
1669 uv_c_flags=""
1670 if ${cmake_system_mingw}; then
1671   uv_c_flags="${uv_c_flags} -DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0600"
1672   libs="${libs} -lws2_32 -lpsapi -liphlpapi -lshell32 -luserenv -lole32 -loleaut32"
1673 else
1674   case "${cmake_system}" in
1675     *AIX*)
1676       uv_c_flags="${uv_c_flags} -D_ALL_SOURCE -D_XOPEN_SOURCE=500 -D_LINUX_SOURCE_COMPAT"
1677       libs="${libs} -lperfstat"
1678       ;;
1679     *Darwin*)
1680       uv_c_flags="${uv_c_flags} -D_DARWIN_USE_64_BIT_INODE=1 -D_DARWIN_UNLIMITED_SELECT=1"
1681       ;;
1682     *HP-UX*)
1683       uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE_EXTENDED"
1684       ;;
1685     *Linux*)
1686       uv_c_flags="${uv_c_flags} -D_GNU_SOURCE"
1687       libs="${libs} -ldl -lrt"
1688       ;;
1689     *kFreeBSD*)
1690       libs="${libs} -lkvm -lfreebsd-glue"
1691       ;;
1692     *BSD*)
1693       libs="${libs} -lkvm"
1694       ;;
1695     *SunOS*)
1696       # Normally libuv uses '-D_XOPEN_SOURCE=500 -std=c90' on Solaris 5.10,
1697       # but we do not need to do that because we bootstrap using POSIX APIs.
1698       uv_c_flags="${uv_c_flags} -D__EXTENSIONS__ -D_XOPEN_SOURCE=600"
1699       libs="${libs} -lkstat -lnsl -lsendfile -lsocket -lrt"
1700       ;;
1701     *QNX*)
1702       uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE=700"
1703       libs="${libs} -lsocket"
1704       ;;
1705   esac
1706 fi
1707 if test "x${bootstrap_system_libuv}" = "x"; then
1708   uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/include"`"
1709   if ${cmake_system_mingw}; then
1710     uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/win"`"
1711   else
1712     uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/unix"`"
1713   fi
1714   uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src"`"
1715 else
1716   if test `which pkg-config`; then
1717     use_uv_flags="`pkg-config --cflags libuv`"
1718     cmake_c_flags="${cmake_c_flags} ${use_uv_flags}"
1719     cmake_cxx_flags="${cmake_cxx_flags} ${use_uv_flags}"
1720   fi
1721   libs="${libs} -luv"
1722 fi
1723
1724 if test "x${bootstrap_system_librhash}" != "x"; then
1725   if test `which pkg-config`; then
1726     use_librhash_flags="`pkg-config --cflags librhash`"
1727     cmake_c_flags="${cmake_c_flags} ${use_librhash_flags}"
1728     cmake_cxx_flags="${cmake_cxx_flags} ${use_librhash_flags}"
1729   fi
1730   libs="${libs} -lrhash"
1731 fi
1732
1733 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1734   jsoncpp_cxx_flags=
1735   if test "x${bootstrap_system_jsoncpp}" = "x"; then
1736     jsoncpp_cxx_flags="${jsoncpp_cxx_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmjsoncpp/include"`"
1737   else
1738     if test `which pkg-config`; then
1739       use_jsoncpp_flags="`pkg-config --cflags jsoncpp`"
1740       cmake_cxx_flags="${cmake_cxx_flags} ${use_jsoncpp_flags}"
1741     fi
1742     libs="${libs} -ljsoncpp"
1743   fi
1744 fi
1745
1746 if test "x${cmake_ansi_cxx_flags}" != "x"; then
1747   cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}"
1748 fi
1749
1750 system_flags=''
1751 case "${cmake_system}" in
1752   # Ensure filesystem access uses 64-bit offsets even on 32-bit hosts.
1753   *Linux*) system_flags='-D_FILE_OFFSET_BITS=64' ;;
1754 esac
1755 if test "x${system_flags}" != "x"; then
1756   cmake_c_flags="${cmake_c_flags} ${system_flags}"
1757   cmake_cxx_flags="${cmake_cxx_flags} ${system_flags}"
1758 fi
1759
1760 if test "x${cmake_c_flags}" != "x"; then
1761   cmake_c_flags="${cmake_c_flags} "
1762 fi
1763
1764 if test "x${cmake_cxx_flags}" != "x"; then
1765   cmake_cxx_flags="${cmake_cxx_flags} "
1766 fi
1767
1768 write_source_rule() {
1769   lang="$1"
1770   obj="$2"
1771   src="$3"
1772   src_flags="$4"
1773
1774   if test "${lang}" = "c"; then
1775     ninja_rule=cc
1776     compiler="${cmake_c_compiler}"
1777     flags="${cmake_c_flags}"
1778   elif test "${lang}" = "cxx"; then
1779     ninja_rule=cxx
1780     compiler="${cmake_cxx_compiler}"
1781     flags="${cmake_cxx_flags}"
1782   fi
1783
1784   if test "${cmake_bootstrap_generator}" = "Ninja"; then
1785     echo "build ${obj} : ${ninja_rule} ${src} | ${dep}" >> "${cmake_bootstrap_dir}/build.ninja"
1786     echo "  srcflags = ${src_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1787   else
1788     echo "${obj} : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile"
1789     echo "      ${compiler} ${flags} ${src_flags} -c ${src} -o ${obj}" >> "${cmake_bootstrap_dir}/Makefile"
1790   fi
1791 }
1792
1793 cmake_c_flags_String="-DKWSYS_STRING_C"
1794 if ${cmake_system_mingw}; then
1795   cmake_c_flags_EncodingC="-DKWSYS_ENCODING_DEFAULT_CODEPAGE=CP_ACP"
1796   cmake_cxx_flags_EncodingCXX="${cmake_c_flags_EncodingC}"
1797   cmake_cxx_flags_cmProcessOutput="${cmake_c_flags_EncodingC}"
1798 fi
1799 cmake_cxx_flags_SystemTools="
1800   -DKWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV}
1801   -DKWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV}
1802   -DKWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H}
1803   -DKWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT}
1804   -DKWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES}
1805 "
1806 cmake_c_flags="${cmake_c_flags} \
1807   -DCMAKE_BOOTSTRAP \
1808   -I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \
1809   -I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \
1810   -I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \
1811   -I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`"
1812 cmake_cxx_flags="${cmake_cxx_flags} \
1813   -DCMAKE_BOOTSTRAP \
1814   ${cmake_have_cxx_features} \
1815   -I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \
1816   -I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \
1817   -I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \
1818   -I`cmake_escape_shell \"${cmake_source_dir}/Utilities/std\"` \
1819   -I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`"
1820 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1821   echo "cc = ${cmake_c_compiler}" > "${cmake_bootstrap_dir}/build.ninja"
1822   echo "cxx = ${cmake_cxx_compiler}" >> "${cmake_bootstrap_dir}/build.ninja"
1823   echo "cflags = ${cmake_c_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1824   echo "cxxflags = ${cmake_cxx_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1825   echo "ldflags = ${cmake_ld_flags}" >> "${cmake_bootstrap_dir}/build.ninja"
1826   echo "rule cc" >> "${cmake_bootstrap_dir}/build.ninja"
1827   echo "  command = \$cc \$cflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
1828   echo "rule cxx" >> "${cmake_bootstrap_dir}/build.ninja"
1829   echo "  command = \$cxx \$cxxflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
1830   echo "rule link" >> "${cmake_bootstrap_dir}/build.ninja"
1831   echo "  command = \$cxx \$ldflags \$cxxflags \$in \$libs -o \$out" >> "${cmake_bootstrap_dir}/build.ninja"
1832   echo "build cmake: link ${objs}" >> "${cmake_bootstrap_dir}/build.ninja"
1833   echo "  libs = ${libs}" >> "${cmake_bootstrap_dir}/build.ninja"
1834 else
1835   echo "cmake: ${objs}" > "${cmake_bootstrap_dir}/Makefile"
1836   echo "        ${cmake_cxx_compiler} ${cmake_ld_flags} ${cmake_cxx_flags} ${objs} ${libs} -o cmake" >> "${cmake_bootstrap_dir}/Makefile"
1837 fi
1838 for a in ${CMAKE_CXX_SOURCES}; do
1839   src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.cxx"`
1840   src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
1841   write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1842 done
1843 for a in ${CMAKE_C_SOURCES}; do
1844   src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.c"`
1845   write_source_rule "c" "${a}.o" "${src}" ""
1846 done
1847 for a in ${CMAKE_STD_CXX_SOURCES}; do
1848   src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/std/cm/bits/${a}.cxx"`
1849   src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
1850   write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1851 done
1852 for a in ${LexerParser_CXX_SOURCES}; do
1853   src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.cxx"`
1854   src_flags=`eval echo \\${cmake_cxx_flags_\${a}}`
1855   write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1856 done
1857 for a in ${LexerParser_C_SOURCES}; do
1858   src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.c"`
1859   write_source_rule "c" "${a}.o" "${src}" ""
1860 done
1861 for a in ${KWSYS_C_SOURCES}; do
1862   src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.c"`
1863   src_flags="`eval echo \\${cmake_c_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys"
1864   write_source_rule "c" "${a}.o" "${src}" "${src_flags}"
1865 done
1866 for a in ${KWSYS_CXX_SOURCES}; do
1867   src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.cxx"`
1868   src_flags="`eval echo \\${cmake_cxx_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys"
1869   write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}"
1870 done
1871 if test "x${bootstrap_system_libuv}" = "x"; then
1872   for a in ${LIBUV_C_SOURCES}; do
1873     src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibuv/${a}"`
1874     write_source_rule "c" "uv-`cmake_obj ${a}`" "${src}" "${uv_c_flags}"
1875   done
1876 fi
1877 if test "x${bootstrap_system_librhash}" = "x"; then
1878   for a in ${LIBRHASH_C_SOURCES}; do
1879     src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibrhash/${a}"`
1880     write_source_rule "c" "rhash-`cmake_obj ${a}`" "${src}" ""
1881   done
1882 fi
1883 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1884   if test "x${bootstrap_system_jsoncpp}" = "x"; then
1885     for a in ${JSONCPP_CXX_SOURCES}; do
1886       src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmjsoncpp/${a}"`
1887       write_source_rule "cxx" "jsoncpp-`cmake_obj ${a}`" "${src}" "${jsoncpp_cxx_flags}"
1888     done
1889   fi
1890 fi
1891 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1892   echo "
1893 rule rebuild_cache
1894   command = cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
1895   generator = 1
1896 build build.ninja : rebuild_cache
1897 " >> "${cmake_bootstrap_dir}/build.ninja"
1898 else
1899   echo "
1900 rebuild_cache:
1901         cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\"
1902 " >> "${cmake_bootstrap_dir}/Makefile"
1903 fi
1904
1905 # Write our default settings to Bootstrap${_cmk}/InitialCacheFlags.cmake.
1906 echo '
1907 # Generated by '"${cmake_source_dir}"'/bootstrap
1908 # Default cmake settings.  These may be overridden any settings below.
1909 set (CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build.") # not FORCE to preserve defaults specified elsewhere
1910 set (CMAKE_INSTALL_PREFIX "'"${cmake_prefix_dir}"'" CACHE PATH "Install path prefix, prepended onto install directories." FORCE)
1911 set (CMAKE_DOC_DIR "'"${cmake_doc_dir}"'" CACHE PATH "Install location for documentation (relative to prefix)." FORCE)
1912 set (CMAKE_MAN_DIR "'"${cmake_man_dir}"'" CACHE PATH "Install location for man pages (relative to prefix)." FORCE)
1913 set (CMAKE_BIN_DIR "'"${cmake_bin_dir}"'" CACHE PATH "Install location for binaries (relative to prefix)." FORCE)
1914 set (CMAKE_DATA_DIR "'"${cmake_data_dir}"'" CACHE PATH "Install location for data (relative to prefix)." FORCE)
1915 set (CMAKE_XDGDATA_DIR "'"${cmake_xdgdata_dir}"'" CACHE PATH "Install location for XDG specific files (relative to prefix)." FORCE)
1916 ' > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1917
1918 # Add configuration settings given as command-line options.
1919 if test "x${cmake_bootstrap_qt_gui}" != "x"; then
1920   echo '
1921 set (BUILD_QtDialog '"${cmake_bootstrap_qt_gui}"' CACHE BOOL "Build Qt dialog for CMake" FORCE)
1922 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1923 fi
1924 if test "x${cmake_bootstrap_qt_qmake}" != "x"; then
1925   echo '
1926 set (QT_QMAKE_EXECUTABLE "'"${cmake_bootstrap_qt_qmake}"'" CACHE FILEPATH "Location of Qt qmake" FORCE)
1927 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1928 fi
1929 if test "x${cmake_sphinx_info}" != "x"; then
1930   echo '
1931 set (SPHINX_INFO "'"${cmake_sphinx_info}"'" CACHE BOOL "Build Info manual with Sphinx" FORCE)
1932 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1933 fi
1934 if test "x${cmake_sphinx_man}" != "x"; then
1935   echo '
1936 set (SPHINX_MAN "'"${cmake_sphinx_man}"'" CACHE BOOL "Build man pages with Sphinx" FORCE)
1937 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1938 fi
1939 if test "x${cmake_sphinx_html}" != "x"; then
1940   echo '
1941 set (SPHINX_HTML "'"${cmake_sphinx_html}"'" CACHE BOOL "Build html help with Sphinx" FORCE)
1942 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1943 fi
1944 if test "x${cmake_sphinx_qthelp}" != "x"; then
1945   echo '
1946 set (SPHINX_QTHELP "'"${cmake_sphinx_qthelp}"'" CACHE BOOL "Build qch help with Sphinx" FORCE)
1947 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1948 fi
1949 if test "x${cmake_sphinx_latexpdf}" != "x"; then
1950   echo '
1951 set (SPHINX_LATEXPDF "'"${cmake_sphinx_latexpdf}"'" CACHE BOOL "Build PDF help with Sphinx using LaTeX" FORCE)
1952 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1953 fi
1954 if test "x${cmake_sphinx_build}" != "x"; then
1955   echo '
1956 set (SPHINX_EXECUTABLE "'"${cmake_sphinx_build}"'" CACHE FILEPATH "Location of Qt sphinx-build" FORCE)
1957 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1958 fi
1959 if test "x${cmake_sphinx_flags}" != "x"; then
1960   echo '
1961 set (SPHINX_FLAGS [==['"${cmake_sphinx_flags}"']==] CACHE STRING "Flags to pass to sphinx-build" FORCE)
1962 ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1963 fi
1964
1965 # Add user-specified settings.  Handle relative-path case for
1966 # specification of cmake_init_file.
1967 (
1968 cd "${cmake_binary_dir}"
1969 if test -f "${cmake_init_file}"; then
1970   cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake"
1971 fi
1972 )
1973
1974 echo "---------------------------------------------"
1975
1976 # Run make to build bootstrap cmake
1977 if test "${cmake_bootstrap_generator}" = "Ninja"; then
1978   ninja_v=-v
1979 else
1980   ninja_v=
1981 fi
1982 if test "x${cmake_parallel_make}" != "x"; then
1983   ${cmake_make_processor} ${cmake_make_flags} ${ninja_v}
1984 else
1985   ${cmake_make_processor} ${ninja_v}
1986 fi
1987 RES=$?
1988 if test "${RES}" -ne "0"; then
1989   cmake_error 9 "Problem while running ${cmake_make_processor}"
1990 fi
1991 cd "${cmake_binary_dir}"
1992
1993 # Set C, CXX, and MAKE environment variables, so that real real cmake will be
1994 # build with same compiler and make
1995 CC="${cmake_c_compiler}"
1996 CXX="${cmake_cxx_compiler}"
1997 MAKE="${cmake_make_processor}"
1998 export CC
1999 export CXX
2000 export MAKE
2001 export CFLAGS
2002 export CXXFLAGS
2003 export LDFLAGS
2004
2005 # Run bootstrap CMake to configure real CMake
2006 cmake_options="-DCMAKE_BOOTSTRAP=1"
2007 if test -n "${cmake_verbose}"; then
2008   cmake_options="${cmake_options} -DCMAKE_VERBOSE_MAKEFILE=1"
2009 fi
2010 "${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" ${cmake_options} ${cmake_bootstrap_system_libs} "$@"
2011 RES=$?
2012 if test "${RES}" -ne "0"; then
2013   cmake_error 11 "Problem while running initial CMake"
2014 fi
2015
2016 echo "---------------------------------------------"
2017
2018 # And we are done. Now just run make
2019 echo "CMake has bootstrapped.  Now run ${cmake_make_processor}."