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