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
  cmLinkItemGraphVisitor \
376
  cmLinkLineComputer \
377
  cmLinkLineDeviceComputer \
378
  cmListCommand \
379 380 381 382 383
  cmListFileCache \
  cmLocalCommonGenerator \
  cmLocalGenerator \
  cmLocalUnixMakefileGenerator3 \
  cmMSVC60LinkLineComputer \
384 385
  cmMacroCommand \
  cmMakeDirectoryCommand \
386 387 388 389 390
  cmMakefile \
  cmMakefileExecutableTargetGenerator \
  cmMakefileLibraryTargetGenerator \
  cmMakefileTargetGenerator \
  cmMakefileUtilityTargetGenerator \
391 392 393
  cmMarkAsAdvancedCommand \
  cmMathCommand \
  cmMessageCommand \
394 395 396
  cmMessenger \
  cmNewLineStyle \
  cmOSXBundleGenerator \
397
  cmOptionCommand \
398 399 400 401 402
  cmOrderDirectories \
  cmOutputConverter \
  cmParseArgumentsCommand \
  cmPathLabel \
  cmPolicies \
403
  cmProcessOutput \
404
  cmProjectCommand \
405 406 407
  cmPropertyDefinition \
  cmPropertyDefinitionMap \
  cmPropertyMap \
408
  cmReturnCommand \
409
  cmRulePlaceholderExpander \
410
  cmRuntimeDependencyArchive \
411 412
  cmScriptGenerator \
  cmSearchPath \
413 414 415 416 417 418 419 420
  cmSeparateArgumentsCommand \
  cmSetCommand \
  cmSetDirectoryPropertiesCommand \
  cmSetPropertyCommand \
  cmSetSourceFilesPropertiesCommand \
  cmSetTargetPropertiesCommand \
  cmSetTestsPropertiesCommand \
  cmSiteNameCommand \
421 422 423 424 425
  cmSourceFile \
  cmSourceFileLocation \
  cmState \
  cmStateDirectory \
  cmStateSnapshot \
Brad King's avatar
Brad King committed
426
  cmString \
427
  cmStringAlgorithms \
428
  cmStringReplaceHelper \
429
  cmStringCommand \
wahikihiki's avatar
wahikihiki committed
430
  cmSubcommandTable \
431
  cmSubdirCommand \
432 433
  cmSystemTools \
  cmTarget \
434 435 436 437
  cmTargetCompileDefinitionsCommand \
  cmTargetCompileFeaturesCommand \
  cmTargetCompileOptionsCommand \
  cmTargetIncludeDirectoriesCommand \
438
  cmTargetLinkLibrariesCommand \
439
  cmTargetPrecompileHeadersCommand \
440
  cmTargetPropCommandBase \
441
  cmTargetPropertyComputer \
442
  cmTargetSourcesCommand \
443 444
  cmTest \
  cmTestGenerator \
445 446 447 448
  cmTimestamp \
  cmTryCompileCommand \
  cmTryRunCommand \
  cmUnsetCommand \
449
  cmUVHandlePtr \
450
  cmUVProcessChain \
451
  cmVersion \
452
  cmWhileCommand \
453
  cmWorkingDirectory \
454 455 456
  cmake  \
  cmakemain \
  cmcmd  \
457
"
458

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

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

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

LexerParser_C_SOURCES="\
  cmListFileLexer \
"
488

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

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

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

527 528 529
if ${cmake_system_mingw}; then
  LIBUV_C_SOURCES="\
    src/fs-poll.c \
530
    src/idna.c
531 532
    src/inet.c \
    src/threadpool.c \
533 534
    src/strscpy.c \
    src/timer.c \
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 562
    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="\
563 564
    src/strscpy.c \
    src/timer.c \
565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581
    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

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

621 622 623
  --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
624

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

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

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

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

672 673 674 675 676 677 678 679 680 681 682 683
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
}

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

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

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

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

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

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

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

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

811
# Run a make test. First argument is the make interpreter.
812 813
cmake_try_make ()
{
814 815
  MAKE_PROC="$1"
  MAKE_FLAGS="$2"
816
  echo "Try: ${MAKE_PROC}"
817
  "${MAKE_PROC}" ${MAKE_FLAGS}
818 819
  RES=$?
  if [ "${RES}" -ne "0" ]; then
820 821
    echo "${MAKE_PROC} does not work"
    return 1
822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
  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
}

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

886
# If verbose, display some information about bootstrap
887 888 889 890 891 892
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}"
893 894 895 896
  if [ "x${cmake_parallel_make}" != "x" ]; then
    echo "Doing parallel make: ${cmake_parallel_make}"
  fi
  echo ""
897 898 899
fi

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

903 904 905 906 907 908 909 910 911 912 913 914 915
# 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?
916 917
  if [ -d "${cmake_source_dir}/Bootstrap${_cmk}" ]; then
    cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\".
918
Looks like somebody did bootstrap CMake in the source tree, but now you are
919
trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk}
920 921 922 923
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
924
    if [ -f "${cmake_source_dir}/${cmake_problematic_file}" ]; then
925 926 927 928 929 930 931 932
      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

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

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

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

950 951 952 953 954 955
# 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

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

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

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

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

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

981 982 983 984 985 986
#-----------------------------------------------------------------------------
# Detect known toolchains on some platforms.
cmake_toolchains=''
case "${cmake_system}" in
  *AIX*)   cmake_toolchains='XL GNU' ;;
  *CYGWIN*) cmake_toolchains='GNU' ;;
987
  *Darwin*) cmake_toolchains='Clang GNU' ;;
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 1040
  *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

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

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

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

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

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

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

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

1078
#include <stdio.h>
1079

Andy Cedilnik's avatar
Andy Cedilnik committed
1080
int main(int argc, char* argv[])
1081
{
1082
  printf("%d%c", (argv != 0), (char)0x0a);
1083
  return argc - 1;
1084
}
1085
' > "${TMPFILE}.c"
1086
for std in 11 99 90; do
1087
  std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`"
1088
  for compiler in ${cmake_c_compilers}; do
1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
    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
1099
    done
1100 1101
  done
done
1102 1103 1104
rm -f "${TMPFILE}.c"

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

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

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

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

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

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

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