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