bootstrap 51.7 KB
Newer Older
1
#!/bin/sh
2 3
# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
4

5 6 7 8
die() {
  echo "$@" 1>&2 ; exit 1
}

9 10 11
# Compile flag extraction function.
cmake_extract_standard_flags()
{
12
  sed -n "s/ *set *( *CMAKE_${2}${3}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \
13
    "${cmake_source_dir}/Modules/Compiler/"${1:-*}-${2}.cmake 2>/dev/null | tr ';' ' '
14 15
}

16 17 18
# Version number extraction function.
cmake_version_component()
{
19
  sed -n "
20
/^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\))/\1/;p;}
21
" "${cmake_source_dir}/Source/CMakeVersion.cmake"
22 23
}

24 25 26
# Install destination extraction function.
cmake_install_dest_default()
{
27
  sed -n '
28
/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT.*) # '"${2}"'$/ {
29 30 31 32 33 34 35
  s/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT *"\([^"]*\)").*$/\1/
  s/${CMake_VERSION_MAJOR}/'"${cmake_version_major}"'/
  s/${CMake_VERSION_MINOR}/'"${cmake_version_minor}"'/
  s/${CMake_VERSION_PATCH}/'"${cmake_version_patch}"'/
  p
  q
}
36
' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake"
37 38
}

39 40
cmake_toupper()
{
41
    echo "$1" | tr '[:lower:]' '[:upper:]'
42 43
}

44 45
# Detect system and directory information.
cmake_system=`uname`
46
cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd`
47
cmake_binary_dir=`pwd`
48 49

# Load version information.
50 51
cmake_version_major="`cmake_version_component MAJOR`"
cmake_version_minor="`cmake_version_component MINOR`"
52 53
cmake_version_patch="`cmake_version_component PATCH`"
cmake_version="${cmake_version_major}.${cmake_version_minor}.${cmake_version_patch}"
54 55 56 57
cmake_version_rc="`cmake_version_component RC`"
if [ "$cmake_version_rc" != "" ]; then
  cmake_version="${cmake_version}-rc${cmake_version_rc}"
fi
58

59 60
cmake_copyright="`grep '^Copyright .* Kitware' "${cmake_source_dir}/Copyright.txt"`"

61
cmake_bin_dir_keyword="OTHER"
62 63 64
cmake_data_dir_keyword="OTHER"
cmake_doc_dir_keyword="OTHER"
cmake_man_dir_keyword="OTHER"
65
cmake_xdgdata_dir_keyword="OTHER"
66
cmake_bin_dir=""
67 68 69
cmake_data_dir=""
cmake_doc_dir=""
cmake_man_dir=""
70
cmake_xdgdata_dir=""
71
cmake_init_file=""
72
cmake_bootstrap_system_libs=""
73 74
cmake_bootstrap_qt_gui=""
cmake_bootstrap_qt_qmake=""
75
cmake_sphinx_info=""
76 77
cmake_sphinx_man=""
cmake_sphinx_html=""
78
cmake_sphinx_qthelp=""
79
cmake_sphinx_build=""
80
cmake_sphinx_flags=""
81

82
# Determine whether this is a Cygwin environment.
83
if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then
84
  cmake_system_cygwin=true
85 86
  cmake_doc_dir_keyword="CYGWIN"
  cmake_man_dir_keyword="CYGWIN"
87 88 89 90
else
  cmake_system_cygwin=false
fi

91
# Determine whether this is a MinGW environment.
92
if echo "${cmake_system}" | grep 'MINGW\|MSYS' >/dev/null 2>&1; then
93 94 95 96 97
  cmake_system_mingw=true
else
  cmake_system_mingw=false
fi

98
# Determine whether this is OS X
99
if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then
100 101 102 103 104
  cmake_system_darwin=true
else
  cmake_system_darwin=false
fi

105
# Determine whether this is BeOS
106
if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then
107
  cmake_system_beos=true
108 109
  cmake_doc_dir_keyword="HAIKU"
  cmake_man_dir_keyword="HAIKU"
110 111 112 113
else
  cmake_system_beos=false
fi

114
# Determine whether this is Haiku
115
if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then
116
  cmake_system_haiku=true
117 118
  cmake_doc_dir_keyword="HAIKU"
  cmake_man_dir_keyword="HAIKU"
119 120 121 122
else
  cmake_system_haiku=false
fi

123
# Determine whether this is OpenVMS
124
if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then
125 126 127 128 129
  cmake_system_openvms=true
else
  cmake_system_openvms=false
fi

130
# Determine whether this is HP-UX
131
if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then
132 133 134 135 136
  die 'CMake no longer compiles on HP-UX.  See

  https://gitlab.kitware.com/cmake/cmake/issues/17137

Use CMake 3.9 or lower instead.'
137 138 139 140 141
  cmake_system_hpux=true
else
  cmake_system_hpux=false
fi

142
# Determine whether this is Linux
143
if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then
144
  cmake_system_linux=true
145 146 147 148 149 150 151 152 153
else
  cmake_system_linux=false
 fi

# Determine whether this is a PA-RISC machine
# This only works for Linux or HP-UX, not other PA-RISC OSs (BSD maybe?). Also
# may falsely detect parisc on HP-UX m68k
cmake_machine_parisc=false
if ${cmake_system_linux}; then
154
  if uname -m | grep parisc >/dev/null 2>&1; then
155 156
    cmake_machine_parisc=true
  fi
157
elif ${cmake_system_hpux}; then
158
  if uname -m | grep ia64 >/dev/null 2>&1; then : ; else
159 160
    cmake_machine_parisc=true
  fi
161 162
fi

163 164 165 166 167 168 169 170 171
# Choose the generator to use for bootstrapping.
if ${cmake_system_mingw}; then
  # Bootstrapping from an MSYS prompt.
  cmake_bootstrap_generator="MSYS Makefiles"
else
  # Bootstrapping from a standard UNIX prompt.
  cmake_bootstrap_generator="Unix Makefiles"
fi

172 173 174 175 176 177 178 179 180 181 182 183 184 185
# Choose tools and extensions for this platform.
if ${cmake_system_openvms}; then
  _tmp="_tmp"
  _cmk="_cmk"
  _diff=`which diff`
else
  _tmp=".tmp"
  _cmk=".cmk"
  _diff="diff"
fi

# Construct bootstrap directory name.
cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}"

186
# Helper function to fix windows paths.
187 188 189 190 191 192 193 194 195 196 197 198 199 200
case "${cmake_system}" in
*MINGW*)
  cmake_fix_slashes()
  {
    cmd //c echo "$(echo "$1" | sed 's/\\/\//g')" | sed 's/^"//;s/" *$//'
  }
  ;;
*)
  cmake_fix_slashes()
  {
    echo "$1" | sed 's/\\/\//g'
  }
  ;;
esac
201 202 203 204 205 206 207 208 209 210 211 212 213 214

# Choose the default install prefix.
if ${cmake_system_mingw}; then
  if [ "x${PROGRAMFILES}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"`
  elif [ "x${ProgramFiles}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"`
  elif [ "x${SYSTEMDRIVE}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"`
  elif [ "x${SystemDrive}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"`
  else
    cmake_default_prefix="c:/Program Files/CMake"
  fi
215
elif ${cmake_system_haiku}; then
216
  cmake_default_prefix=`finddir B_COMMON_DIRECTORY`
217 218 219 220
else
  cmake_default_prefix="/usr/local"
fi

221
# Lookup default install destinations.
222
cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`"
223 224 225
cmake_data_dir_default="`cmake_install_dest_default DATA ${cmake_data_dir_keyword}`"
cmake_doc_dir_default="`cmake_install_dest_default DOC ${cmake_doc_dir_keyword}`"
cmake_man_dir_default="`cmake_install_dest_default MAN ${cmake_man_dir_keyword}`"
226
cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`"
227

228 229
CMAKE_KNOWN_C_COMPILERS="cc gcc clang xlc icc tcc"
CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icc como "
230
CMAKE_KNOWN_MAKE_PROCESSORS="gmake make"
231

232 233 234 235 236
CMAKE_PROBLEMATIC_FILES="\
  CMakeCache.txt \
  CMakeSystem.cmake \
  CMakeCCompiler.cmake \
  CMakeCXXCompiler.cmake \
237 238 239
  */CMakeSystem.cmake \
  */CMakeCCompiler.cmake \
  */CMakeCXXCompiler.cmake \
240 241 242 243 244 245
  Source/cmConfigure.h \
  Source/CTest/Curl/config.h \
  Utilities/cmexpat/expatConfig.h \
  Utilities/cmexpat/expatDllConfig.h \
  "

246 247 248 249 250 251 252 253
CMAKE_UNUSED_SOURCES="\
  cmGlobalXCodeGenerator \
  cmLocalXCodeGenerator \
  cmXCodeObject \
  cmXCode21Object \
  cmSourceGroup \
"

254
CMAKE_CXX_SOURCES="\
255 256 257 258 259 260 261 262
  cmAddCustomCommandCommand \
  cmAddCustomTargetCommand \
  cmAddDefinitionsCommand \
  cmAddDependenciesCommand \
  cmAddExecutableCommand \
  cmAddLibraryCommand \
  cmAddSubDirectoryCommand \
  cmAddTestCommand \
wahikihiki's avatar
wahikihiki committed
263
  cmArgumentParser \
264 265 266 267 268 269 270 271 272 273 274
  cmBinUtilsLinker \
  cmBinUtilsLinuxELFGetRuntimeDependenciesTool \
  cmBinUtilsLinuxELFLinker \
  cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool \
  cmBinUtilsMacOSMachOGetRuntimeDependenciesTool \
  cmBinUtilsMacOSMachOLinker \
  cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool \
  cmBinUtilsWindowsPEGetRuntimeDependenciesTool \
  cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool \
  cmBinUtilsWindowsPELinker \
  cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool \
275 276 277 278
  cmBreakCommand \
  cmBuildCommand \
  cmCMakeMinimumRequired \
  cmCMakePolicyCommand \
279 280
  cmCPackPropertiesGenerator \
  cmCacheManager \
281
  cmCheckCustomOutputs \
282
  cmCommand \
283 284 285 286 287 288 289 290
  cmCommandArgumentParserHelper \
  cmCommands \
  cmCommonTargetGenerator \
  cmComputeComponentGraph \
  cmComputeLinkDepends \
  cmComputeLinkInformation \
  cmComputeTargetDepends \
  cmConditionEvaluator \
291 292 293 294
  cmConfigureFileCommand \
  cmContinueCommand \
  cmCoreTryCompile \
  cmCreateTestSourceList \
295 296
  cmCustomCommand \
  cmCustomCommandGenerator \
297
  cmDefinePropertyCommand \
298 299 300 301
  cmDefinitions \
  cmDepends \
  cmDependsC \
  cmDocumentationFormatter \
302 303 304 305
  cmEnableLanguageCommand \
  cmEnableTestingCommand \
  cmExecProgramCommand \
  cmExecuteProcessCommand \
306 307 308 309 310 311 312 313
  cmExpandedCommandArgument \
  cmExportBuildFileGenerator \
  cmExportFileGenerator \
  cmExportInstallFileGenerator \
  cmExportSet \
  cmExportTryCompileFileGenerator \
  cmExprParserHelper \
  cmExternalMakefileProjectGenerator \
314
  cmFileCommand \
315 316
  cmFileCopier \
  cmFileInstaller \
Sebastian Holtermann's avatar
Sebastian Holtermann committed
317
  cmFileTime \
318
  cmFileTimeCache \
319
  cmFileTimes \
320 321 322 323 324 325 326 327
  cmFindBase \
  cmFindCommon \
  cmFindFileCommand \
  cmFindLibraryCommand \
  cmFindPackageCommand \
  cmFindPathCommand \
  cmFindProgramCommand \
  cmForEachCommand \
328
  cmFunctionBlocker \
329
  cmFunctionCommand \
330
  cmFSPermissions \
331 332 333 334 335 336 337 338 339 340
  cmGeneratedFileStream \
  cmGeneratorExpression \
  cmGeneratorExpressionContext \
  cmGeneratorExpressionDAGChecker \
  cmGeneratorExpressionEvaluationFile \
  cmGeneratorExpressionEvaluator \
  cmGeneratorExpressionLexer \
  cmGeneratorExpressionNode \
  cmGeneratorExpressionParser \
  cmGeneratorTarget \
341 342 343
  cmGetCMakePropertyCommand \
  cmGetDirectoryPropertyCommand \
  cmGetFilenameComponentCommand \
344
  cmGetPipes \
345 346 347 348
  cmGetPropertyCommand \
  cmGetSourceFilePropertyCommand \
  cmGetTargetPropertyCommand \
  cmGetTestPropertyCommand \
349 350 351
  cmGlobalCommonGenerator \
  cmGlobalGenerator \
  cmGlobalUnixMakefileGenerator3 \
352
  cmGlobVerificationManager \
353 354 355
  cmHexFileConverter \
  cmIfCommand \
  cmIncludeCommand \
356
  cmIncludeGuardCommand \
357 358 359 360
  cmIncludeDirectoryCommand \
  cmIncludeRegularExpressionCommand \
  cmInstallCommand \
  cmInstallCommandArguments \
361 362
  cmInstallDirectoryGenerator \
  cmInstallExportGenerator \
363
  cmInstallFilesCommand \
364 365 366
  cmInstallFilesGenerator \
  cmInstallGenerator \
  cmInstallScriptGenerator \
367
  cmInstallSubdirectoryGenerator \
368
  cmInstallTargetGenerator \
369
  cmInstallTargetsCommand \
370
  cmInstalledFile \
371 372
  cmLDConfigLDConfigTool \
  cmLDConfigTool \
373
  cmLinkDirectoriesCommand \
374
  cmLinkItem \
375
  cmLinkLineComputer \
376
  cmLinkLineDeviceComputer \
377
  cmListCommand \
378 379 380 381 382
  cmListFileCache \
  cmLocalCommonGenerator \
  cmLocalGenerator \
  cmLocalUnixMakefileGenerator3 \
  cmMSVC60LinkLineComputer \
383 384
  cmMacroCommand \
  cmMakeDirectoryCommand \
385 386 387 388 389
  cmMakefile \
  cmMakefileExecutableTargetGenerator \
  cmMakefileLibraryTargetGenerator \
  cmMakefileTargetGenerator \
  cmMakefileUtilityTargetGenerator \
390 391 392
  cmMarkAsAdvancedCommand \
  cmMathCommand \
  cmMessageCommand \
393 394 395
  cmMessenger \
  cmNewLineStyle \
  cmOSXBundleGenerator \
396
  cmOptionCommand \
397 398 399 400 401
  cmOrderDirectories \
  cmOutputConverter \
  cmParseArgumentsCommand \
  cmPathLabel \
  cmPolicies \
402
  cmProcessOutput \
403
  cmProjectCommand \
404 405 406
  cmPropertyDefinition \
  cmPropertyDefinitionMap \
  cmPropertyMap \
407
  cmReturnCommand \
408
  cmRulePlaceholderExpander \
409
  cmRuntimeDependencyArchive \
410 411
  cmScriptGenerator \
  cmSearchPath \
412 413 414 415 416 417 418 419
  cmSeparateArgumentsCommand \
  cmSetCommand \
  cmSetDirectoryPropertiesCommand \
  cmSetPropertyCommand \
  cmSetSourceFilesPropertiesCommand \
  cmSetTargetPropertiesCommand \
  cmSetTestsPropertiesCommand \
  cmSiteNameCommand \
420 421 422 423 424
  cmSourceFile \
  cmSourceFileLocation \
  cmState \
  cmStateDirectory \
  cmStateSnapshot \
Brad King's avatar
Brad King committed
425
  cmString \
426
  cmStringAlgorithms \
427
  cmStringReplaceHelper \
428
  cmStringCommand \
wahikihiki's avatar
wahikihiki committed
429
  cmSubcommandTable \
430
  cmSubdirCommand \
431 432
  cmSystemTools \
  cmTarget \
433 434 435 436
  cmTargetCompileDefinitionsCommand \
  cmTargetCompileFeaturesCommand \
  cmTargetCompileOptionsCommand \
  cmTargetIncludeDirectoriesCommand \
437
  cmTargetLinkLibrariesCommand \
438
  cmTargetPrecompileHeadersCommand \
439
  cmTargetPropCommandBase \
440
  cmTargetPropertyComputer \
441
  cmTargetSourcesCommand \
442 443
  cmTest \
  cmTestGenerator \
444 445 446 447
  cmTimestamp \
  cmTryCompileCommand \
  cmTryRunCommand \
  cmUnsetCommand \
448
  cmUVHandlePtr \
449
  cmUVProcessChain \
450
  cmVersion \
451
  cmWhileCommand \
452
  cmWorkingDirectory \
453 454 455
  cmake  \
  cmakemain \
  cmcmd  \
456
"
457

458 459 460
if ${cmake_system_mingw}; then
  CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
    cmGlobalMSYSMakefileGenerator \
461 462 463
    cmGlobalMinGWMakefileGenerator \
    cmVSSetupHelper \
  "
464 465
fi

466 467 468 469 470 471 472 473 474 475 476
CMAKE_STD_CXX_HEADERS="\
  memory \
  optional \
  shared_mutex \
  string_view \
  utility \
"
CMAKE_STD_CXX_SOURCES="\
  string_view \
"

477 478 479 480 481 482 483 484 485 486
LexerParser_CXX_SOURCES="\
  cmCommandArgumentLexer \
  cmCommandArgumentParser \
  cmExprLexer \
  cmExprParser \
"

LexerParser_C_SOURCES="\
  cmListFileLexer \
"
487

488 489
if ${cmake_system_mingw}; then
  KWSYS_C_SOURCES="\
490
    EncodingC \
491
    ProcessWin32 \
492
    String \
493 494
    System \
    Terminal"
495 496
else
  KWSYS_C_SOURCES="\
497
    EncodingC \
498
    ProcessUNIX \
499
    String \
500 501
    System \
    Terminal"
502
fi
503 504

KWSYS_CXX_SOURCES="\
505
  Directory \
506
  EncodingCXX \
507
  FStream \
Andy Cedilnik's avatar
Andy Cedilnik committed
508
  Glob \
509 510 511 512 513
  RegularExpression \
  SystemTools"

KWSYS_FILES="\
  Directory.hxx \
514 515 516
  Encoding.h \
  Encoding.hxx \
  FStream.hxx \
Andy Cedilnik's avatar
Andy Cedilnik committed
517
  Glob.hxx \
518 519
  Process.h \
  RegularExpression.hxx \
520
  String.h \
521
  String.hxx \
522
  System.h \
523 524
  SystemTools.hxx \
  Terminal.h"
525

526 527 528
if ${cmake_system_mingw}; then
  LIBUV_C_SOURCES="\
    src/fs-poll.c \
529
    src/idna.c
530 531
    src/inet.c \
    src/threadpool.c \
532 533
    src/strscpy.c \
    src/timer.c \
534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561
    src/uv-common.c \
    src/win/async.c \
    src/win/core.c \
    src/win/detect-wakeup.c \
    src/win/dl.c \
    src/win/error.c \
    src/win/fs-event.c \
    src/win/fs.c \
    src/win/getaddrinfo.c \
    src/win/getnameinfo.c \
    src/win/handle.c \
    src/win/loop-watcher.c \
    src/win/pipe.c \
    src/win/poll.c \
    src/win/process-stdio.c \
    src/win/process.c \
    src/win/signal.c \
    src/win/stream.c \
    src/win/tcp.c \
    src/win/thread.c \
    src/win/tty.c \
    src/win/udp.c \
    src/win/util.c \
    src/win/winapi.c \
    src/win/winsock.c \
    "
else
  LIBUV_C_SOURCES="\
562 563
    src/strscpy.c \
    src/timer.c \
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
    src/uv-common.c \
    src/unix/cmake-bootstrap.c \
    src/unix/core.c \
    src/unix/fs.c \
    src/unix/loop.c \
    src/unix/loop-watcher.c \
    src/unix/no-fsevents.c \
    src/unix/pipe.c \
    src/unix/poll.c \
    src/unix/posix-hrtime.c \
    src/unix/posix-poll.c \
    src/unix/process.c \
    src/unix/signal.c \
    src/unix/stream.c \
    "
fi

581
# Display CMake bootstrap usage
582 583
cmake_usage()
{
584
echo '
585
Usage: '"$0"' [<options>...] [-- <cmake-options>...]
586 587 588
Options: [defaults in brackets after descriptions]
Configuration:
  --help                  print this message
589
  --version               only print version information
590
  --verbose               display more information
591 592
  --parallel=n            bootstrap cmake in parallel, where n is
                          number of nodes [1]
593
  --enable-ccache         Enable ccache when building cmake
594
  --init=FILE             load FILE as script to populate cache
595
  --system-libs           use all system-installed third-party libraries
596
                          (for use only by package maintainers)
597
  --no-system-libs        use all cmake-provided third-party libraries
598
                          (default)
599 600 601 602
  --system-curl           use system-installed curl library
  --no-system-curl        use cmake-provided curl library (default)
  --system-expat          use system-installed expat library
  --no-system-expat       use cmake-provided expat library (default)
603 604
  --system-jsoncpp        use system-installed jsoncpp library
  --no-system-jsoncpp     use cmake-provided jsoncpp library (default)
605 606 607 608
  --system-zlib           use system-installed zlib library
  --no-system-zlib        use cmake-provided zlib library (default)
  --system-bzip2          use system-installed bzip2 library
  --no-system-bzip2       use cmake-provided bzip2 library (default)
609 610
  --system-liblzma        use system-installed liblzma library
  --no-system-liblzma     use cmake-provided liblzma library (default)
611 612
  --system-zstd           use system-installed zstd library
  --no-system-zstd        use cmake-provided zstd library (default)
613 614
  --system-libarchive     use system-installed libarchive library
  --no-system-libarchive  use cmake-provided libarchive library (default)
615 616
  --system-librhash       use system-installed librhash library
  --no-system-librhash    use cmake-provided librhash library (default)
617 618
  --system-libuv          use system-installed libuv library
  --no-system-libuv       use cmake-provided libuv library (default)
619

620 621 622
  --qt-gui                build the Qt-based GUI (requires Qt >= 4.2)
  --no-qt-gui             do not build the Qt-based GUI (default)
  --qt-qmake=<qmake>      use <qmake> as the qmake executable to find Qt
623

624
  --sphinx-info           build Info manual with Sphinx
625 626
  --sphinx-man            build man pages with Sphinx
  --sphinx-html           build html help with Sphinx
627
  --sphinx-qthelp         build qch help with Sphinx
628
  --sphinx-build=<sb>     use <sb> as the sphinx-build executable
629
  --sphinx-flags=<flags>  pass <flags> to sphinx-build executable
630

631
Directory and file names:
632
  --prefix=PREFIX         install files in tree rooted at PREFIX
633
                          ['"${cmake_default_prefix}"']
634 635
  --bindir=DIR            install binaries in PREFIX/DIR
                          ['"${cmake_bin_dir_default}"']
636
  --datadir=DIR           install data files in PREFIX/DIR
637
                          ['"${cmake_data_dir_default}"']
638
  --docdir=DIR            install documentation files in PREFIX/DIR
639
                          ['"${cmake_doc_dir_default}"']
640
  --mandir=DIR            install man pages files in PREFIX/DIR/manN
641
                          ['"${cmake_man_dir_default}"']
642 643
  --xdgdatadir=DIR        install XDG specific files in PREFIX/DIR
                          ['"${cmake_xdgdata_dir_default}"']
644
'
645 646 647
  exit 10
}

648
# Display CMake bootstrap usage
649
cmake_version_display()
650
{
651
  echo "CMake ${cmake_version}, ${cmake_copyright}"
652 653 654
}

# Display CMake bootstrap error, display the log file and exit
655 656
cmake_error()
{
657 658
  res=$1
  shift 1
659
  echo "---------------------------------------------"
660
  echo "Error when bootstrapping CMake:"
661 662 663
  echo "$*"
  echo "---------------------------------------------"
  if [ -f cmake_bootstrap.log ]; then
664 665
    echo "Log of errors: `pwd`/cmake_bootstrap.log"
    #cat cmake_bootstrap.log
666 667
    echo "---------------------------------------------"
  fi
668
  exit ${res}
669
}
670

671 672 673 674 675 676 677 678 679 680 681 682
cmake_generate_file ()
{
  OUTFILE="$1"
  CONTENT="$2"
  echo "$CONTENT" > "$OUTFILE.tmp"
  if "${_diff}" "$OUTFILE.tmp" "$OUTFILE" > /dev/null 2> /dev/null ; then
    rm -f "$OUTFILE.tmp"
  else
    mv -f "$OUTFILE.tmp" "$OUTFILE"
  fi
}

683 684 685 686 687 688 689
# Replace KWSYS_NAMESPACE with cmsys
cmake_replace_string ()
{
  INFILE="$1"
  OUTFILE="$2"
  SEARCHFOR="$3"
  REPLACEWITH="$4"
690
  if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then
691
    sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}"
692 693
    if [ -f "${OUTFILE}${_tmp}" ]; then
      if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
694
        #echo "Files are the same"
695
        rm -f "${OUTFILE}${_tmp}"
696
      else
697
        mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
698 699
      fi
    fi
700
  else
701
    cmake_error 1 "Cannot find file ${INFILE}"
702 703 704
  fi
}

705 706 707 708 709 710
cmake_kwsys_config_replace_string ()
{
  INFILE="$1"
  OUTFILE="$2"
  shift 2
  APPEND="$*"
711 712
  if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then
    echo "${APPEND}" > "${OUTFILE}${_tmp}"
713 714 715 716 717 718 719
    sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g;
              s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/g;
              s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g;
              s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g;
              s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g;
              s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g;
              s/@KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/g;
720
              s/@KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP@/${KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP}/g;
721
             }" "${INFILE}" >> "${OUTFILE}${_tmp}"
722 723
    if [ -f "${OUTFILE}${_tmp}" ]; then
      if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
724
        #echo "Files are the same"
725
        rm -f "${OUTFILE}${_tmp}"
726
      else
727
        mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
728 729 730 731 732 733
      fi
    fi
  else
    cmake_error 2 "Cannot find file ${INFILE}"
  fi
}
734
# Write string into a file
735 736 737 738 739 740 741
cmake_report ()
{
  FILE=$1
  shift
  echo "$*" >> ${FILE}
}

742
# Escape spaces in strings
743 744 745 746 747
cmake_escape ()
{
  echo $1 | sed "s/ /\\\\ /g"
}

748 749 750 751 752 753
# Encode object file names.
cmake_obj ()
{
  echo $1 | sed 's/\//-/g' | sed 's/$/\.o/'
}

754 755 756 757 758 759
# Strip prefix from argument
cmake_arg ()
{
  echo "$1" | sed "s/^${2-[^=]*=}//"
}

760
# Write message to the log
761 762 763 764 765
cmake_log ()
{
  echo "$*" >> cmake_bootstrap.log
}

766
# Return temp file
767 768
cmake_tmp_file ()
{
769
  echo "cmake_bootstrap_$$_test"
770 771
}

772 773
# Run a compiler test. First argument is compiler, second one are compiler
# flags, third one is test source file to be compiled
774 775 776 777 778 779 780 781 782 783 784
cmake_try_run ()
{
  COMPILER=$1
  FLAGS=$2
  TESTFILE=$3
  if [ ! -f "${TESTFILE}" ]; then
    echo "Test file ${TESTFILE} missing. Please verify your CMake source tree."
    exit 4
  fi
  TMPFILE=`cmake_tmp_file`
  echo "Try: ${COMPILER}"
785 786
  echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}"
  echo "----------  file   -----------------------"
787
  cat "${TESTFILE}"
788
  echo "------------------------------------------"
789 790 791
  "${COMPILER}" ${FLAGS} "${TESTFILE}" -o "${TMPFILE}"
  RES=$?
  if [ "${RES}" -ne "0" ]; then
792 793
    echo "Test failed to compile"
    return 1
794 795
  fi
  if [ ! -f "${TMPFILE}" ] && [ ! -f "${TMPFILE}.exe" ]; then
796
    echo "Test failed to produce executable"
797 798 799 800 801 802
    return 2
  fi
  ./${TMPFILE}
  RES=$?
  rm -f "${TMPFILE}"
  if [ "${RES}" -ne "0" ]; then
803
    echo "Test produced non-zero return code"
804 805
    return 3
  fi
806
  echo "Test succeeded"
807 808 809
  return 0
}

810
# Run a make test. First argument is the make interpreter.
811 812
cmake_try_make ()
{
813 814
  MAKE_PROC="$1"
  MAKE_FLAGS="$2"
815
  echo "Try: ${MAKE_PROC}"
816
  "${MAKE_PROC}" ${MAKE_FLAGS}
817 818
  RES=$?
  if [ "${RES}" -ne "0" ]; then
819 820
    echo "${MAKE_PROC} does not work"
    return 1
821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
  fi
  if [ ! -f "test" ] && [ ! -f "test.exe" ]; then
    echo "${COMPILER} does not produce output"
    return 2
  fi
  ./test
  RES=$?
  rm -f "test"
  if [ "${RES}" -ne "0" ]; then
    echo "${MAKE_PROC} produces strange executable"
    return 3
  fi
  echo "${MAKE_PROC} works"
  return 0
}

837
# Parse arguments
838
cmake_verbose=
839
cmake_parallel_make=
840
cmake_ccache_enabled=
841
cmake_prefix_dir="${cmake_default_prefix}"
842 843
while test $# != 0; do
  case "$1" in
844 845 846
  --prefix=*) dir=`cmake_arg "$1"`
              cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;;
  --parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;;
847
  --bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;;
848 849 850
  --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;;
  --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;;
  --mandir=*) cmake_man_dir=`cmake_arg "$1"` ;;
851
  --xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;;
852
  --init=*) cmake_init_file=`cmake_arg "$1"` ;;
853 854
  --system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=1" ;;
  --no-system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=0" ;;
855
  --system-bzip2|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma|--system-zstd|--system-libuv)
856 857
    lib=`cmake_arg "$1" "--system-"`
    cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;;
858
  --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-zstd|--no-system-libuv)
859 860
    lib=`cmake_arg "$1" "--no-system-"`
    cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;;
861 862
  --qt-gui) cmake_bootstrap_qt_gui="1" ;;
  --no-qt-gui) cmake_bootstrap_qt_gui="0" ;;
863
  --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;;
864
  --sphinx-info) cmake_sphinx_info="1" ;;
865 866
  --sphinx-man) cmake_sphinx_man="1" ;;
  --sphinx-html) cmake_sphinx_html="1" ;;
867
  --sphinx-qthelp) cmake_sphinx_qthelp="1" ;;
868
  --sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;;
869
  --sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;;
870 871 872 873
  --help) cmake_usage ;;
  --version) cmake_version_display ; exit 2 ;;
  --verbose) cmake_verbose=TRUE ;;
  --enable-ccache) cmake_ccache_enabled=TRUE ;;
874 875 876 877 878
  CC=*) CC=`cmake_arg "$1"` ;;
  CXX=*) CXX=`cmake_arg "$1"` ;;
  CFLAGS=*) CFLAGS=`cmake_arg "$1"` ;;
  CXXFLAGS=*) CXXFLAGS=`cmake_arg "$1"` ;;
  LDFLAGS=*) LDFLAGS=`cmake_arg "$1"` ;;
879
  --) shift; break ;;
880 881 882
  *) die "Unknown option: $1" ;;
  esac
  shift
883 884
done

885
# If verbose, display some information about bootstrap
886 887 888 889 890 891
if [ -n "${cmake_verbose}" ]; then
  echo "---------------------------------------------"
  echo "Source directory: ${cmake_source_dir}"
  echo "Binary directory: ${cmake_binary_dir}"
  echo "Prefix directory: ${cmake_prefix_dir}"
  echo "System:           ${cmake_system}"
892 893 894 895
  if [ "x${cmake_parallel_make}" != "x" ]; then
    echo "Doing parallel make: ${cmake_parallel_make}"
  fi
  echo ""
896 897 898
fi

echo "---------------------------------------------"
899
# Get CMake version
900
echo "`cmake_version_display`"
901

902 903 904 905 906 907 908 909 910 911 912 913 914
# Check for in-source build
cmake_in_source_build=
if [ -f "${cmake_binary_dir}/Source/cmake.cxx" -a \
     -f "${cmake_binary_dir}/Source/cmake.h" ]; then
  if [ -n "${cmake_verbose}" ]; then
    echo "Warning: This is an in-source build"
  fi
  cmake_in_source_build=TRUE
fi

# If this is not an in-source build, then Bootstrap stuff should not exist.
if [ -z "${cmake_in_source_build}" ]; then
  # Did somebody bootstrap in the source tree?
915 916
  if [ -d "${cmake_source_dir}/Bootstrap${_cmk}" ]; then
    cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\".
917
Looks like somebody did bootstrap CMake in the source tree, but now you are
918
trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk}
919 920 921 922
directory from the source tree."
  fi
  # Is there a cache in the source tree?
  for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do
Will Schroeder's avatar
Will Schroeder committed
923
    if [ -f "${cmake_source_dir}/${cmake_problematic_file}" ]; then
924 925 926 927 928 929 930 931
      cmake_error 10 "Found \"${cmake_source_dir}/${cmake_problematic_file}\".
Looks like somebody tried to build CMake in the source tree, but now you are
trying to do bootstrap in the binary tree. Please remove \"${cmake_problematic_file}\"
from the source tree."
    fi
  done
fi

932
# Make bootstrap directory
933 934
[ -d "${cmake_bootstrap_dir}" ] || mkdir "${cmake_bootstrap_dir}"
if [ ! -d "${cmake_bootstrap_dir}" ]; then
935
  cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake."
936 937 938
fi
cd "${cmake_bootstrap_dir}"

939 940
[ -d "cmsys" ] || mkdir "cmsys"
if [ ! -d "cmsys" ]; then
941
  cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys"
942 943
fi

944
# Delete all the bootstrap files
945
rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log"
946 947
rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}"
rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}"
948

949 950 951 952 953 954
# If building in-source, remove any cmConfigure.h that may
# have been created by a previous run of the bootstrap cmake.
if [ -n "${cmake_in_source_build}" ]; then
  rm -f "${cmake_source_dir}/Source/cmConfigure.h"
fi

955
# If exist compiler flags, set them
956 957
cmake_c_flags=${CFLAGS}
cmake_cxx_flags=${CXXFLAGS}
Bill Hoffman's avatar
Bill Hoffman committed
958
cmake_ld_flags=${LDFLAGS}
959

960 961 962 963 964
# Add Cygwin-specific flags
if ${cmake_system_cygwin}; then
  cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import"
fi

965
# Add CoreFoundation framework on Darwin
966
if ${cmake_system_darwin}; then
967
  cmake_ld_flags="${LDFLAGS} -framework CoreFoundation"
968 969
fi

970 971 972 973 974
# Add BeOS toolkits...
if ${cmake_system_beos}; then
  cmake_ld_flags="${LDFLAGS} -lroot -lbe"
fi

975 976 977 978 979
# Add Haiku toolkits...
if ${cmake_system_haiku}; then
  cmake_ld_flags="${LDFLAGS} -lroot -lbe"
fi

980 981 982 983 984 985
#-----------------------------------------------------------------------------
# Detect known toolchains on some platforms.
cmake_toolchains=''
case "${cmake_system}" in
  *AIX*)   cmake_toolchains='XL GNU' ;;
  *CYGWIN*) cmake_toolchains='GNU' ;;
986
  *Darwin*) cmake_toolchains='Clang GNU' ;;
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039
  *Linux*) cmake_toolchains='GNU Clang XL PGI PathScale' ;;
  *MINGW*) cmake_toolchains='GNU' ;;
esac

# Toolchain compiler name table.
cmake_toolchain_Clang_CC='clang'
cmake_toolchain_Clang_CXX='clang++'
cmake_toolchain_GNU_CC='gcc'
cmake_toolchain_GNU_CXX='g++'
cmake_toolchain_PGI_CC='pgcc'
cmake_toolchain_PGI_CXX='pgCC'
cmake_toolchain_PathScale_CC='pathcc'
cmake_toolchain_PathScale_CXX='pathCC'
cmake_toolchain_XL_CC='xlc'
cmake_toolchain_XL_CXX='xlC'

cmake_toolchain_try()
{
  tc="$1"
  TMPFILE=`cmake_tmp_file`

  eval "tc_CC=\${cmake_toolchain_${tc}_CC}"
  echo 'int main() { return 0; }' > "${TMPFILE}.c"
  cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1
  tc_result_CC="$?"
  rm -f "${TMPFILE}.c"
  test "${tc_result_CC}" = "0" || return 1

  eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}"
  echo 'int main() { return 0; }' > "${TMPFILE}.cpp"
  cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1
  tc_result_CXX="$?"
  rm -f "${TMPFILE}.cpp"
  test "${tc_result_CXX}" = "0" || return 1

  cmake_toolchain="$tc"
}

cmake_toolchain_detect()
{
  cmake_toolchain=
  for tc in ${cmake_toolchains}; do
    echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1
    cmake_toolchain_try "$tc" &&
    echo "Found $tc toolchain" &&
    break
  done
}

if [ -z "${CC}" -a -z "${CXX}" ]; then
  cmake_toolchain_detect
fi

1040
thread_flags=''
1041 1042 1043
case "${cmake_system}" in
  *AIX*)   thread_flags='-pthread' ;;
esac
1044

1045
#-----------------------------------------------------------------------------
1046 1047 1048
# Test C compiler
cmake_c_compiler=

1049
# If CC is set, use that for compiler, otherwise use list of known compilers
1050 1051 1052
if [ -n "${cmake_toolchain}" ]; then
  eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}"
elif [ -n "${CC}" ]; then
1053 1054 1055 1056 1057
  cmake_c_compilers="${CC}"
else
  cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}"
fi

1058
# Check if C compiler works
1059
TMPFILE=`cmake_tmp_file`
1060
echo '
1061 1062
#ifdef __cplusplus
# error "The CMAKE_C_COMPILER is set to a C++ compiler"
1063 1064
#endif

1065 1066 1067 1068
#if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
#error "On AIX with GNU we need the -pthread flag."
#endif

1069 1070 1071 1072
#if defined(__sun) && __STDC_VERSION__ < 199901L
#error "On Solaris we need C99."
#endif

1073 1074 1075 1076
#if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409)
#error "On HP-UX we need GCC 4.9 or higher."
#endif

1077
#include <stdio.h>
1078

Andy Cedilnik's avatar
Andy Cedilnik committed
1079
int main(int argc, char* argv[])
1080
{
1081
  printf("%d%c", (argv != 0), (char)0x0a);
1082
  return argc - 1;
1083
}
1084
' > "${TMPFILE}.c"
1085
for std in 11 99 90; do
1086
  std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`"
1087
  for compiler in ${cmake_c_compilers}; do
1088 1089 1090 1091 1092 1093 1094 1095 1096 1097
    for std_flag in '' $std_flags; do
      for thread_flag in '' $thread_flags; do
        echo "Checking whether '${compiler} ${cmake_c_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
        if cmake_try_run "${compiler}" "${cmake_c_flags} ${std_flag} ${thread_flag}" \
          "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then
          cmake_c_compiler="${compiler}"
          cmake_c_flags="${cmake_c_flags} ${std_flag} ${thread_flag}"
          break 3
        fi
      done
1098
    done
1099 1100
  done
done
1101 1102 1103
rm -f "${TMPFILE}.c"

if [ -z "${cmake_c_compiler}" ]; then
1104
  cmake_error 6 "Cannot find appropriate C compiler on this system.
Bill Hoffman's avatar
Bill Hoffman committed
1105 1106 1107
Please specify one using environment variable CC.
See cmake_bootstrap.log for compilers attempted.
"
1108 1109 1110
fi
echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}"

1111
#-----------------------------------------------------------------------------
1112 1113
# Test CXX compiler
cmake_cxx_compiler=
1114

1115 1116
# On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler.

1117
# If CC is set, use that for compiler, otherwise use list of known compilers
1118 1119 1120
if [ -n "${cmake_toolchain}" ]; then
  eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}"
elif [ -n "${CXX}" ]; then
1121 1122 1123 1124 1125
  cmake_cxx_compilers="${CXX}"
else
  cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}"
fi

1126
# Check if C++ compiler works
1127
TMPFILE=`cmake_tmp_file`
1128
echo '
1129 1130
#include <iostream>
#include <memory>
1131
#include <unordered_map>
1132

1133 1134 1135 1136
#if __cplusplus < 201103L
#error "Compiler is not in a mode aware of C++11."
#endif

1137 1138 1139 1140
#if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
#error "On AIX with GNU we need the -pthread flag."