| #!/bin/sh | |
| # Distributed under the OSI-approved BSD 3-Clause License. See accompanying | |
| # file Copyright.txt or https://cmake.org/licensing for details. | |
| die() { | |
| echo "$@" 1>&2 ; exit 1 | |
| } | |
| # Compile flag extraction function. | |
| cmake_extract_standard_flags() | |
| { | |
| id="${1:-*}" | |
| lang="${2}" | |
| ver="${3}" | |
| sed -n "s/ *set *( *CMAKE_${lang}${ver}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \ | |
| "${cmake_source_dir}/Modules/Compiler/"${id}-${lang}.cmake \ | |
| 2>/dev/null | tr ';' ' ' | |
| # Clang's CXX compiler flags are in the common module. | |
| sed -n "s/ *set *( *CMAKE_\\\${lang}${ver}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \ | |
| "${cmake_source_dir}/Modules/Compiler/Clang.cmake" \ | |
| 2>/dev/null | tr ';' ' ' | |
| } | |
| # Version number extraction function. | |
| cmake_version_component() | |
| { | |
| sed -n " | |
| /^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\)).*/\1/;p;} | |
| " "${cmake_source_dir}/Source/CMakeVersion.cmake" | |
| } | |
| # Install destination extraction function. | |
| cmake_install_dest_default() | |
| { | |
| sed -n ' | |
| /^ *set(CMAKE_'"${1}"'_DIR_DEFAULT.*) # '"${2}"'$/ { | |
| 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 | |
| } | |
| ' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake" | |
| } | |
| cmake_toupper() | |
| { | |
| echo "$1" | tr '[a-z]' '[A-Z]' | |
| } | |
| # Detect system and directory information. | |
| cmake_system=`uname` | |
| cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd` | |
| cmake_binary_dir=`pwd` | |
| # Load version information. | |
| cmake_version_major="`cmake_version_component MAJOR`" | |
| cmake_version_minor="`cmake_version_component MINOR`" | |
| cmake_version_patch="`cmake_version_component PATCH`" | |
| cmake_version="${cmake_version_major}.${cmake_version_minor}.${cmake_version_patch}" | |
| cmake_version_rc="`cmake_version_component RC`" | |
| if test "$cmake_version_rc" != ""; then | |
| cmake_version="${cmake_version}-rc${cmake_version_rc}" | |
| fi | |
| cmake_copyright="`grep '^Copyright .* Kitware' "${cmake_source_dir}/Copyright.txt"`" | |
| cmake_bin_dir_keyword="OTHER" | |
| cmake_data_dir_keyword="OTHER" | |
| cmake_doc_dir_keyword="OTHER" | |
| cmake_man_dir_keyword="OTHER" | |
| cmake_xdgdata_dir_keyword="OTHER" | |
| cmake_bin_dir="" | |
| cmake_data_dir="" | |
| cmake_doc_dir="" | |
| cmake_man_dir="" | |
| cmake_xdgdata_dir="" | |
| cmake_init_file="" | |
| cmake_bootstrap_system_libs="" | |
| cmake_bootstrap_qt_gui="" | |
| cmake_bootstrap_qt_qmake="" | |
| cmake_bootstrap_debugger="" | |
| cmake_sphinx_info="" | |
| cmake_sphinx_man="" | |
| cmake_sphinx_html="" | |
| cmake_sphinx_qthelp="" | |
| cmake_sphinx_latexpdf="" | |
| cmake_sphinx_build="" | |
| cmake_sphinx_flags="" | |
| # Determine whether this is a Cygwin environment. | |
| if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then | |
| cmake_system_cygwin=true | |
| cmake_doc_dir_keyword="CYGWIN" | |
| cmake_man_dir_keyword="CYGWIN" | |
| else | |
| cmake_system_cygwin=false | |
| fi | |
| # Determine whether this is a MSYS environment. | |
| if echo "${cmake_system}" | grep MSYS >/dev/null 2>&1; then | |
| cmake_system_msys=true | |
| cmake_doc_dir_keyword="MSYS" | |
| cmake_man_dir_keyword="MSYS" | |
| else | |
| cmake_system_msys=false | |
| fi | |
| # Determine whether this is a MinGW environment. | |
| if echo "${cmake_system}" | grep 'MINGW' >/dev/null 2>&1; then | |
| cmake_system_mingw=true | |
| else | |
| cmake_system_mingw=false | |
| fi | |
| # Determine whether this is OS X | |
| if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then | |
| cmake_system_darwin=true | |
| else | |
| cmake_system_darwin=false | |
| fi | |
| # Determine whether this is BeOS | |
| if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then | |
| cmake_system_beos=true | |
| cmake_doc_dir_keyword="HAIKU" | |
| cmake_man_dir_keyword="HAIKU" | |
| else | |
| cmake_system_beos=false | |
| fi | |
| # Determine whether this is Haiku | |
| if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then | |
| cmake_system_haiku=true | |
| cmake_doc_dir_keyword="HAIKU" | |
| cmake_man_dir_keyword="HAIKU" | |
| else | |
| cmake_system_haiku=false | |
| fi | |
| # Determine whether this is OpenVMS | |
| if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then | |
| cmake_system_openvms=true | |
| else | |
| cmake_system_openvms=false | |
| fi | |
| # Determine whether this is HP-UX | |
| if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then | |
| die 'CMake no longer compiles on HP-UX. See | |
| https://gitlab.kitware.com/cmake/cmake/-/issues/17137 | |
| Use CMake 3.9 or lower instead.' | |
| cmake_system_hpux=true | |
| else | |
| cmake_system_hpux=false | |
| fi | |
| # Determine whether this is AIX | |
| if echo "${cmake_system}" | grep AIX >/dev/null 2>&1; then | |
| cmake_system_aix=true | |
| else | |
| cmake_system_aix=false | |
| fi | |
| # Determine whether this is Linux | |
| if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then | |
| cmake_system_linux=true | |
| 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 | |
| if uname -m | grep parisc >/dev/null 2>&1; then | |
| cmake_machine_parisc=true | |
| fi | |
| elif ${cmake_system_hpux}; then | |
| if uname -m | grep ia64 >/dev/null 2>&1; then : ; else | |
| cmake_machine_parisc=true | |
| fi | |
| fi | |
| # 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 | |
| # 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}" | |
| # Helper function to fix windows paths. | |
| 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 | |
| # Choose the default install prefix. | |
| if ${cmake_system_mingw}; then | |
| if test "x${PROGRAMFILES}" != "x"; then | |
| cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"` | |
| elif test "x${ProgramFiles}" != "x"; then | |
| cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"` | |
| elif test "x${SYSTEMDRIVE}" != "x"; then | |
| cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"` | |
| elif test "x${SystemDrive}" != "x"; then | |
| cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"` | |
| else | |
| cmake_default_prefix="c:/Program Files/CMake" | |
| fi | |
| elif ${cmake_system_haiku}; then | |
| cmake_default_prefix=`finddir B_COMMON_DIRECTORY` | |
| else | |
| cmake_default_prefix="/usr/local" | |
| fi | |
| # Lookup default install destinations. | |
| cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`" | |
| 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}`" | |
| cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`" | |
| CMAKE_KNOWN_C_COMPILERS="cc gcc clang xlc icx tcc" | |
| CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icpx" | |
| CMAKE_KNOWN_MAKE_PROCESSORS="gmake make smake" | |
| CMAKE_KNOWN_NINJA_PROCESSORS="ninja-build ninja samu" | |
| CMAKE_PROBLEMATIC_FILES="\ | |
| CMakeCache.txt \ | |
| CMakeSystem.cmake \ | |
| CMakeCCompiler.cmake \ | |
| CMakeCXXCompiler.cmake \ | |
| */CMakeSystem.cmake \ | |
| */CMakeCCompiler.cmake \ | |
| */CMakeCXXCompiler.cmake \ | |
| Source/cmConfigure.h \ | |
| Source/CTest/Curl/config.h \ | |
| Utilities/cmThirdParty.h \ | |
| Utilities/cmcurl/lib/curl_config.h \ | |
| Utilities/cmlibarchive/config.h \ | |
| Utilities/cmliblzma/config.h \ | |
| Utilities/cmnghttp2/config.h \ | |
| " | |
| CMAKE_UNUSED_SOURCES="\ | |
| cmGlobalXCodeGenerator \ | |
| cmLocalXCodeGenerator \ | |
| cmXCodeObject \ | |
| cmXCode21Object \ | |
| cmSourceGroup \ | |
| " | |
| CMAKE_CXX_SOURCES="\ | |
| cmAddCompileDefinitionsCommand \ | |
| cmAddCustomCommandCommand \ | |
| cmAddCustomTargetCommand \ | |
| cmAddDefinitionsCommand \ | |
| cmAddDependenciesCommand \ | |
| cmAddExecutableCommand \ | |
| cmAddLibraryCommand \ | |
| cmAddSubDirectoryCommand \ | |
| cmAddTestCommand \ | |
| cmArgumentParser \ | |
| cmBinUtilsLinker \ | |
| cmBinUtilsLinuxELFGetRuntimeDependenciesTool \ | |
| cmBinUtilsLinuxELFLinker \ | |
| cmBinUtilsLinuxELFObjdumpGetRuntimeDependenciesTool \ | |
| cmBinUtilsMacOSMachOGetRuntimeDependenciesTool \ | |
| cmBinUtilsMacOSMachOLinker \ | |
| cmBinUtilsMacOSMachOOToolGetRuntimeDependenciesTool \ | |
| cmBinUtilsWindowsPEGetRuntimeDependenciesTool \ | |
| cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool \ | |
| cmBinUtilsWindowsPELinker \ | |
| cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool \ | |
| cmBlockCommand \ | |
| cmBreakCommand \ | |
| cmBuildCommand \ | |
| cmBuildDatabase \ | |
| cmCMakeLanguageCommand \ | |
| cmCMakeMinimumRequired \ | |
| cmList \ | |
| cmCMakePath \ | |
| cmCMakePathCommand \ | |
| cmCMakePolicyCommand \ | |
| cmCPackPropertiesGenerator \ | |
| cmCacheManager \ | |
| cmCommandArgumentParserHelper \ | |
| cmCommands \ | |
| cmCommonTargetGenerator \ | |
| cmComputeComponentGraph \ | |
| cmComputeLinkDepends \ | |
| cmComputeLinkInformation \ | |
| cmComputeTargetDepends \ | |
| cmConsoleBuf \ | |
| cmConditionEvaluator \ | |
| cmConfigureFileCommand \ | |
| cmContinueCommand \ | |
| cmCoreTryCompile \ | |
| cmCreateTestSourceList \ | |
| cmCryptoHash \ | |
| cmCustomCommand \ | |
| cmCustomCommandGenerator \ | |
| cmCustomCommandLines \ | |
| cmCxxModuleMapper \ | |
| cmCxxModuleUsageEffects \ | |
| cmDefinePropertyCommand \ | |
| cmDefinitions \ | |
| cmDocumentationFormatter \ | |
| cmELF \ | |
| cmEnableLanguageCommand \ | |
| cmEnableTestingCommand \ | |
| cmEvaluatedTargetProperty \ | |
| cmExecProgramCommand \ | |
| cmExecuteProcessCommand \ | |
| cmExpandedCommandArgument \ | |
| cmExperimental \ | |
| cmExportBuildCMakeConfigGenerator \ | |
| cmExportBuildFileGenerator \ | |
| cmExportCMakeConfigGenerator \ | |
| cmExportFileGenerator \ | |
| cmExportInstallCMakeConfigGenerator \ | |
| cmExportInstallFileGenerator \ | |
| cmExportSet \ | |
| cmExportTryCompileFileGenerator \ | |
| cmExprParserHelper \ | |
| cmExternalMakefileProjectGenerator \ | |
| cmFileCommand \ | |
| cmFileCommand_ReadMacho \ | |
| cmFileCopier \ | |
| cmFileInstaller \ | |
| cmFileSet \ | |
| cmFileTime \ | |
| cmFileTimeCache \ | |
| cmFileTimes \ | |
| cmFindBase \ | |
| cmFindCommon \ | |
| cmFindFileCommand \ | |
| cmFindLibraryCommand \ | |
| cmFindPackageCommand \ | |
| cmFindPackageStack \ | |
| cmFindPathCommand \ | |
| cmFindProgramCommand \ | |
| cmForEachCommand \ | |
| cmFunctionBlocker \ | |
| cmFunctionCommand \ | |
| cmFSPermissions \ | |
| cmGeneratedFileStream \ | |
| cmGeneratorExpression \ | |
| cmGeneratorExpressionContext \ | |
| cmGeneratorExpressionDAGChecker \ | |
| cmGeneratorExpressionEvaluationFile \ | |
| cmGeneratorExpressionEvaluator \ | |
| cmGeneratorExpressionLexer \ | |
| cmGeneratorExpressionNode \ | |
| cmGeneratorExpressionParser \ | |
| cmGeneratorTarget \ | |
| cmGeneratorTarget_CompatibleInterface \ | |
| cmGeneratorTarget_IncludeDirectories \ | |
| cmGeneratorTarget_Link \ | |
| cmGeneratorTarget_LinkDirectories \ | |
| cmGeneratorTarget_Options \ | |
| cmGeneratorTarget_Sources \ | |
| cmGeneratorTarget_TargetPropertyEntry \ | |
| cmGeneratorTarget_TransitiveProperty \ | |
| cmGetCMakePropertyCommand \ | |
| cmGetDirectoryPropertyCommand \ | |
| cmGetFilenameComponentCommand \ | |
| cmGetPipes \ | |
| cmGetPropertyCommand \ | |
| cmGetSourceFilePropertyCommand \ | |
| cmGetTargetPropertyCommand \ | |
| cmGetTestPropertyCommand \ | |
| cmGlobalCommonGenerator \ | |
| cmGlobalGenerator \ | |
| cmGlobVerificationManager \ | |
| cmHexFileConverter \ | |
| cmIfCommand \ | |
| cmImportedCxxModuleInfo \ | |
| cmIncludeCommand \ | |
| cmIncludeGuardCommand \ | |
| cmIncludeDirectoryCommand \ | |
| cmIncludeRegularExpressionCommand \ | |
| cmInstallCMakeConfigExportGenerator \ | |
| cmInstallCommand \ | |
| cmInstallCommandArguments \ | |
| cmInstallCxxModuleBmiGenerator \ | |
| cmInstallDirectoryGenerator \ | |
| cmInstallExportGenerator \ | |
| cmInstallFileSetGenerator \ | |
| cmInstallFilesCommand \ | |
| cmInstallFilesGenerator \ | |
| cmInstallGenerator \ | |
| cmInstallGetRuntimeDependenciesGenerator \ | |
| cmInstallImportedRuntimeArtifactsGenerator \ | |
| cmInstallRuntimeDependencySet \ | |
| cmInstallRuntimeDependencySetGenerator \ | |
| cmInstallScriptGenerator \ | |
| cmInstallSubdirectoryGenerator \ | |
| cmInstallTargetGenerator \ | |
| cmInstallTargetsCommand \ | |
| cmInstalledFile \ | |
| cmJSONHelpers \ | |
| cmJSONState \ | |
| cmLDConfigLDConfigTool \ | |
| cmLDConfigTool \ | |
| cmLinkDirectoriesCommand \ | |
| cmLinkItem \ | |
| cmLinkItemGraphVisitor \ | |
| cmLinkLineComputer \ | |
| cmLinkLineDeviceComputer \ | |
| cmListCommand \ | |
| cmListFileCache \ | |
| cmLocalCommonGenerator \ | |
| cmLocalGenerator \ | |
| cmMSVC60LinkLineComputer \ | |
| cmMacroCommand \ | |
| cmMakeDirectoryCommand \ | |
| cmMakefile \ | |
| cmMarkAsAdvancedCommand \ | |
| cmMathCommand \ | |
| cmMessageCommand \ | |
| cmMessenger \ | |
| cmNewLineStyle \ | |
| cmOSXBundleGenerator \ | |
| cmOptionCommand \ | |
| cmOrderDirectories \ | |
| cmOutputConverter \ | |
| cmParseArgumentsCommand \ | |
| cmPathLabel \ | |
| cmPathResolver \ | |
| cmPolicies \ | |
| cmProcessOutput \ | |
| cmProjectCommand \ | |
| cmValue \ | |
| cmPropertyDefinition \ | |
| cmPropertyMap \ | |
| cmGccDepfileLexerHelper \ | |
| cmGccDepfileReader \ | |
| cmReturnCommand \ | |
| cmPackageInfoReader \ | |
| cmPlaceholderExpander \ | |
| cmPlistParser \ | |
| cmRulePlaceholderExpander \ | |
| cmRuntimeDependencyArchive \ | |
| cmScriptGenerator \ | |
| cmSearchPath \ | |
| cmSeparateArgumentsCommand \ | |
| cmSetCommand \ | |
| cmSetDirectoryPropertiesCommand \ | |
| cmSetPropertyCommand \ | |
| cmSetSourceFilesPropertiesCommand \ | |
| cmSetTargetPropertiesCommand \ | |
| cmSetTestsPropertiesCommand \ | |
| cmSiteNameCommand \ | |
| cmSourceFile \ | |
| cmSourceFileLocation \ | |
| cmStandardLevelResolver \ | |
| cmState \ | |
| cmStateDirectory \ | |
| cmStateSnapshot \ | |
| cmString \ | |
| cmStringAlgorithms \ | |
| cmStringReplaceHelper \ | |
| cmStringCommand \ | |
| cmSubcommandTable \ | |
| cmSubdirCommand \ | |
| cmSystemTools \ | |
| cmTarget \ | |
| cmTargetCompileDefinitionsCommand \ | |
| cmTargetCompileFeaturesCommand \ | |
| cmTargetCompileOptionsCommand \ | |
| cmTargetIncludeDirectoriesCommand \ | |
| cmTargetLinkLibrariesCommand \ | |
| cmTargetLinkOptionsCommand \ | |
| cmTargetPrecompileHeadersCommand \ | |
| cmTargetPropCommandBase \ | |
| cmTargetPropertyComputer \ | |
| cmTargetSourcesCommand \ | |
| cmTargetTraceDependencies \ | |
| cmTest \ | |
| cmTestGenerator \ | |
| cmTimestamp \ | |
| cmTransformDepfile \ | |
| cmTryCompileCommand \ | |
| cmTryRunCommand \ | |
| cmUnsetCommand \ | |
| cmUVHandlePtr \ | |
| cmUVProcessChain \ | |
| cmVersion \ | |
| cmWhileCommand \ | |
| cmWindowsRegistry \ | |
| cmWorkingDirectory \ | |
| cmXcFramework \ | |
| cmake \ | |
| cmakemain \ | |
| cmcmd \ | |
| cm_fileno \ | |
| " | |
| if ${cmake_system_darwin}; then | |
| CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\ | |
| cmMachO \ | |
| " | |
| fi | |
| if ${cmake_system_mingw}; then | |
| CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\ | |
| cmGlobalMSYSMakefileGenerator \ | |
| cmGlobalMinGWMakefileGenerator \ | |
| cmVSSetupHelper \ | |
| " | |
| fi | |
| CMAKE_STD_CXX_HEADERS="\ | |
| filesystem \ | |
| memory \ | |
| optional \ | |
| shared_mutex \ | |
| string_view \ | |
| utility \ | |
| " | |
| CMAKE_STD_CXX_SOURCES="\ | |
| fs_path \ | |
| string_view \ | |
| " | |
| LexerParser_CXX_SOURCES="\ | |
| cmCommandArgumentLexer \ | |
| cmCommandArgumentParser \ | |
| cmExprLexer \ | |
| cmExprParser \ | |
| cmGccDepfileLexer \ | |
| " | |
| LexerParser_C_SOURCES="\ | |
| cmListFileLexer \ | |
| " | |
| if ${cmake_system_mingw}; then | |
| KWSYS_C_SOURCES="\ | |
| EncodingC \ | |
| ProcessWin32 \ | |
| String \ | |
| System \ | |
| Terminal" | |
| else | |
| KWSYS_C_SOURCES="\ | |
| EncodingC \ | |
| ProcessUNIX \ | |
| String \ | |
| System \ | |
| Terminal" | |
| fi | |
| KWSYS_CXX_SOURCES="\ | |
| Directory \ | |
| EncodingCXX \ | |
| FStream \ | |
| Glob \ | |
| RegularExpression \ | |
| Status \ | |
| SystemTools" | |
| KWSYS_FILES="\ | |
| Directory.hxx \ | |
| Encoding.h \ | |
| Encoding.hxx \ | |
| FStream.hxx \ | |
| Glob.hxx \ | |
| Process.h \ | |
| RegularExpression.hxx \ | |
| Status.hxx \ | |
| String.h \ | |
| System.h \ | |
| SystemTools.hxx \ | |
| Terminal.h" | |
| LIBRHASH_C_SOURCES="\ | |
| librhash/algorithms.c \ | |
| librhash/byte_order.c \ | |
| librhash/hex.c \ | |
| librhash/md5.c \ | |
| librhash/rhash.c \ | |
| librhash/sha1.c \ | |
| librhash/sha256.c \ | |
| librhash/sha3.c \ | |
| librhash/sha512.c \ | |
| librhash/util.c \ | |
| " | |
| JSONCPP_CXX_SOURCES="\ | |
| src/lib_json/json_reader.cpp \ | |
| src/lib_json/json_value.cpp \ | |
| src/lib_json/json_writer.cpp \ | |
| " | |
| if ${cmake_system_mingw}; then | |
| LIBUV_C_SOURCES="\ | |
| src/fs-poll.c \ | |
| src/idna.c | |
| src/inet.c \ | |
| src/threadpool.c \ | |
| src/strscpy.c \ | |
| src/strtok.c \ | |
| src/timer.c \ | |
| 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="\ | |
| src/strscpy.c \ | |
| src/strtok.c \ | |
| src/timer.c \ | |
| 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 \ | |
| src/unix/tcp.c \ | |
| src/unix/tty.c \ | |
| " | |
| fi | |
| # Display CMake bootstrap usage | |
| cmake_usage() | |
| { | |
| echo ' | |
| Usage: '"$0"' [<options>...] [-- <cmake-options>...] | |
| Options: [defaults in brackets after descriptions] | |
| Configuration: | |
| --help print this message | |
| --version only print version information | |
| --verbose display more information | |
| --parallel=n bootstrap cmake in parallel, where n is | |
| number of nodes [1] | |
| --generator=<generator> generator to use (MSYS Makefiles, Unix Makefiles, | |
| or Ninja) | |
| --enable-ccache Enable ccache when building cmake | |
| --init=FILE load FILE as script to populate cache | |
| --system-libs use all system-installed third-party libraries | |
| (for use only by package maintainers) | |
| --no-system-libs use all cmake-provided third-party libraries | |
| (default) | |
| --system-cppdap use system-installed cppdap library | |
| --no-system-cppdap use cmake-provided cppdap library (default) | |
| --system-curl use system-installed curl library (default on macOS) | |
| --no-system-curl use cmake-provided curl library (default elsewhere) | |
| --system-expat use system-installed expat library | |
| --no-system-expat use cmake-provided expat library (default) | |
| --system-jsoncpp use system-installed jsoncpp library | |
| --no-system-jsoncpp use cmake-provided jsoncpp library (default) | |
| --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) | |
| --system-liblzma use system-installed liblzma library | |
| --no-system-liblzma use cmake-provided liblzma library (default) | |
| --system-nghttp2 use system-installed nghttp2 library | |
| --no-system-nghttp2 use cmake-provided nghttp2 library (default) | |
| --system-zstd use system-installed zstd library | |
| --no-system-zstd use cmake-provided zstd library (default) | |
| --system-libarchive use system-installed libarchive library | |
| --no-system-libarchive use cmake-provided libarchive library (default) | |
| --system-librhash use system-installed librhash library | |
| --no-system-librhash use cmake-provided librhash library (default) | |
| --system-libuv use system-installed libuv library | |
| --no-system-libuv use cmake-provided libuv library (default) | |
| --bootstrap-system-libuv use system-installed libuv library for bootstrap | |
| --bootstrap-system-jsoncpp use system-installed jsoncpp library for bootstrap | |
| --bootstrap-system-librhash use system-installed librhash library for bootstrap | |
| --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 | |
| --debugger enable debugger support (default if supported) | |
| --no-debugger disable debugger support | |
| --sphinx-info build Info manual with Sphinx | |
| --sphinx-man build man pages with Sphinx | |
| --sphinx-html build html help with Sphinx | |
| --sphinx-qthelp build qch help with Sphinx | |
| --sphinx-latexpdf build PDF with Sphinx using LaTeX | |
| --sphinx-build=<sb> use <sb> as the sphinx-build executable | |
| --sphinx-flags=<flags> pass <flags> to sphinx-build executable | |
| Directory and file names: | |
| --prefix=PREFIX install files in tree rooted at PREFIX | |
| ['"${cmake_default_prefix}"'] | |
| --bindir=DIR install binaries in PREFIX/DIR | |
| ['"${cmake_bin_dir_default}"'] | |
| --datadir=DIR install data files in PREFIX/DIR | |
| ['"${cmake_data_dir_default}"'] | |
| --docdir=DIR install documentation files in PREFIX/DIR | |
| ['"${cmake_doc_dir_default}"'] | |
| --mandir=DIR install man pages files in PREFIX/DIR/manN | |
| ['"${cmake_man_dir_default}"'] | |
| --xdgdatadir=DIR install XDG specific files in PREFIX/DIR | |
| ['"${cmake_xdgdata_dir_default}"'] | |
| ' | |
| exit 10 | |
| } | |
| # Display CMake bootstrap usage | |
| cmake_version_display() | |
| { | |
| echo "CMake ${cmake_version}, ${cmake_copyright}" | |
| } | |
| # Display CMake bootstrap error, display the log file and exit | |
| cmake_error() | |
| { | |
| res=$1 | |
| shift 1 | |
| echo "---------------------------------------------" | |
| echo "Error when bootstrapping CMake:" | |
| echo "$*" | |
| echo "---------------------------------------------" | |
| if test -f cmake_bootstrap.log; then | |
| echo "Log of errors: `pwd`/cmake_bootstrap.log" | |
| #cat cmake_bootstrap.log | |
| echo "---------------------------------------------" | |
| fi | |
| exit ${res} | |
| } | |
| cmake_generate_file_tmp () | |
| { | |
| OUTFILE="$1" | |
| TMPFILE="$2" | |
| if "${_diff}" "$TMPFILE" "$OUTFILE" > /dev/null 2> /dev/null ; then | |
| rm -f "$TMPFILE" | |
| else | |
| mv -f "$TMPFILE" "$OUTFILE" | |
| fi | |
| } | |
| cmake_generate_file () | |
| { | |
| OUTFILE="$1" | |
| CONTENT="$2" | |
| echo "$CONTENT" > "$OUTFILE.tmp" | |
| cmake_generate_file_tmp "$OUTFILE" "$OUTFILE.tmp" | |
| } | |
| # Replace KWSYS_NAMESPACE with cmsys | |
| cmake_replace_string () | |
| { | |
| INFILE="$1" | |
| OUTFILE="$2" | |
| SEARCHFOR="$3" | |
| REPLACEWITH="$4" | |
| if test -f "${INFILE}" || ${cmake_system_openvms}; then | |
| sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}" | |
| if test -f "${OUTFILE}${_tmp}"; then | |
| if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then | |
| #echo "Files are the same" | |
| rm -f "${OUTFILE}${_tmp}" | |
| else | |
| mv -f "${OUTFILE}${_tmp}" "${OUTFILE}" | |
| fi | |
| fi | |
| else | |
| cmake_error 1 "Cannot find file ${INFILE}" | |
| fi | |
| } | |
| cmake_kwsys_config_replace_string () | |
| { | |
| INFILE="$1" | |
| OUTFILE="$2" | |
| shift 2 | |
| APPEND="$*" | |
| if test -f "${INFILE}" || ${cmake_system_openvms}; then | |
| echo "${APPEND}" > "${OUTFILE}${_tmp}" | |
| 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; | |
| }" "${INFILE}" >> "${OUTFILE}${_tmp}" | |
| if test -f "${OUTFILE}${_tmp}"; then | |
| if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then | |
| #echo "Files are the same" | |
| rm -f "${OUTFILE}${_tmp}" | |
| else | |
| mv -f "${OUTFILE}${_tmp}" "${OUTFILE}" | |
| fi | |
| fi | |
| else | |
| cmake_error 2 "Cannot find file ${INFILE}" | |
| fi | |
| } | |
| # Write string into a file | |
| cmake_report () | |
| { | |
| FILE=$1 | |
| shift | |
| echo "$*" >> ${FILE} | |
| } | |
| # Escape spaces in strings for artifacts | |
| cmake_escape_artifact () | |
| { | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| echo $1 | sed "s/ /$ /g" | |
| else | |
| echo $1 | sed "s/ /\\\\ /g" | |
| fi | |
| } | |
| # Escape spaces in strings for shell | |
| cmake_escape_shell () | |
| { | |
| echo $1 | sed "s/ /\\\\ /g" | |
| } | |
| # Encode object file names. | |
| cmake_obj () | |
| { | |
| echo $1 | sed 's/\//-/g' | sed 's/$/\.o/' | |
| } | |
| # Strip prefix from argument | |
| cmake_arg () | |
| { | |
| echo "$1" | sed "s/^${2-[^=]*=}//" | |
| } | |
| # Write message to the log | |
| cmake_log () | |
| { | |
| echo "$*" >> cmake_bootstrap.log | |
| } | |
| # Return temp file | |
| cmake_tmp_file () | |
| { | |
| echo "cmake_bootstrap_$$_test" | |
| } | |
| # Run a compiler test. First argument is compiler, second one are compiler | |
| # flags, third one is test source file to be compiled | |
| cmake_try_run () | |
| { | |
| COMPILER=$1 | |
| FLAGS=$2 | |
| TESTFILE=$3 | |
| if test ! -f "${TESTFILE}"; then | |
| echo "Test file ${TESTFILE} missing. Please verify your CMake source tree." | |
| exit 4 | |
| fi | |
| TMPFILE=`cmake_tmp_file` | |
| echo "Try: ${COMPILER}" | |
| echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}" | |
| echo "---------- file -----------------------" | |
| cat "${TESTFILE}" | |
| echo "------------------------------------------" | |
| ${COMPILER} ${FLAGS} "${TESTFILE}" -o "${TMPFILE}" | |
| RES=$? | |
| if test "${RES}" -ne "0"; then | |
| echo "Test failed to compile" | |
| return 1 | |
| fi | |
| if test ! -f "${TMPFILE}" && test ! -f "${TMPFILE}.exe"; then | |
| echo "Test failed to produce executable" | |
| return 2 | |
| fi | |
| ./${TMPFILE} | |
| RES=$? | |
| rm -f "${TMPFILE}" | |
| if test "${RES}" -ne "0"; then | |
| echo "Test produced non-zero return code" | |
| return 3 | |
| fi | |
| echo "Test succeeded" | |
| return 0 | |
| } | |
| # Run a make test. First argument is the make interpreter. | |
| cmake_try_make () | |
| { | |
| MAKE_PROC="$1" | |
| MAKE_FLAGS="$2" | |
| echo "Try: ${MAKE_PROC}" | |
| "${MAKE_PROC}" ${MAKE_FLAGS} | |
| RES=$? | |
| if test "${RES}" -ne "0"; then | |
| echo "${MAKE_PROC} does not work" | |
| return 1 | |
| fi | |
| if test ! -f "test" && test ! -f "test.exe"; then | |
| echo "${COMPILER} does not produce output" | |
| return 2 | |
| fi | |
| ./test | |
| RES=$? | |
| rm -f "test" | |
| if test "${RES}" -ne "0"; then | |
| echo "${MAKE_PROC} produces strange executable" | |
| return 3 | |
| fi | |
| echo "${MAKE_PROC} works" | |
| return 0 | |
| } | |
| # Parse arguments | |
| cmake_verbose= | |
| cmake_parallel_make= | |
| cmake_ccache_enabled= | |
| cmake_prefix_dir="${cmake_default_prefix}" | |
| bootstrap_system_libuv= | |
| bootstrap_system_jsoncpp= | |
| bootstrap_system_librhash= | |
| while test $# != 0; do | |
| case "$1" in | |
| --prefix=*) dir=`cmake_arg "$1"` | |
| cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;; | |
| --parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;; | |
| --generator=*) cmake_bootstrap_generator=`cmake_arg "$1"` ;; | |
| --bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;; | |
| --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;; | |
| --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;; | |
| --mandir=*) cmake_man_dir=`cmake_arg "$1"` ;; | |
| --xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;; | |
| --init=*) cmake_init_file=`cmake_arg "$1"` ;; | |
| --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" ;; | |
| --system-bzip2|--system-cppdap|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma|--system-nghttp2|--system-zstd|--system-libuv) | |
| lib=`cmake_arg "$1" "--system-"` | |
| cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;; | |
| --no-system-bzip2|--no-system-cppdap|--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) | |
| lib=`cmake_arg "$1" "--no-system-"` | |
| cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;; | |
| --bootstrap-system-libuv) bootstrap_system_libuv="1" ;; | |
| --bootstrap-system-jsoncpp) bootstrap_system_jsoncpp="1" ;; | |
| --bootstrap-system-librhash) bootstrap_system_librhash="1" ;; | |
| --qt-gui) cmake_bootstrap_qt_gui="1" ;; | |
| --no-qt-gui) cmake_bootstrap_qt_gui="0" ;; | |
| --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;; | |
| --debugger) cmake_bootstrap_debugger="1" ;; | |
| --no-debugger) cmake_bootstrap_debugger="0" ;; | |
| --sphinx-info) cmake_sphinx_info="1" ;; | |
| --sphinx-man) cmake_sphinx_man="1" ;; | |
| --sphinx-html) cmake_sphinx_html="1" ;; | |
| --sphinx-qthelp) cmake_sphinx_qthelp="1" ;; | |
| --sphinx-latexpdf) cmake_sphinx_latexpdf="1" ;; | |
| --sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;; | |
| --sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;; | |
| --help) cmake_usage ;; | |
| --version) cmake_version_display ; exit 2 ;; | |
| --verbose) cmake_verbose=TRUE ;; | |
| --enable-ccache) cmake_ccache_enabled=TRUE ;; | |
| 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"` ;; | |
| --) shift; break ;; | |
| *) die "Unknown option: $1" ;; | |
| esac | |
| shift | |
| done | |
| # Make sure the generator is valid | |
| case "${cmake_bootstrap_generator}" in | |
| 'MSYS Makefiles'|'Unix Makefiles'|'Ninja') ;; | |
| *) cmake_error 10 "Invalid generator: ${cmake_bootstrap_generator}" | |
| esac | |
| # If verbose, display some information about bootstrap | |
| if test -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}" | |
| echo "Generator: ${cmake_bootstrap_generator}" | |
| if test "x${cmake_parallel_make}" != "x"; then | |
| echo "Doing parallel make: ${cmake_parallel_make}" | |
| fi | |
| echo "" | |
| fi | |
| echo "---------------------------------------------" | |
| # Get CMake version | |
| echo "`cmake_version_display`" | |
| # Check for in-source build | |
| cmake_in_source_build= | |
| if test -f "${cmake_binary_dir}/Source/cmake.cxx" && | |
| test -f "${cmake_binary_dir}/Source/cmake.h"; then | |
| if test -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 test -z "${cmake_in_source_build}"; then | |
| # Did somebody bootstrap in the source tree? | |
| if test -d "${cmake_source_dir}/Bootstrap${_cmk}"; then | |
| cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\". | |
| Looks like somebody did bootstrap CMake in the source tree, but now you are | |
| trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk} | |
| directory from the source tree." | |
| fi | |
| # Is there a cache in the source tree? | |
| for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do | |
| if test -f "${cmake_source_dir}/${cmake_problematic_file}"; then | |
| 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 | |
| # Make bootstrap directory | |
| test -d "${cmake_bootstrap_dir}" || mkdir "${cmake_bootstrap_dir}" | |
| if test ! -d "${cmake_bootstrap_dir}"; then | |
| cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake." | |
| fi | |
| cd "${cmake_bootstrap_dir}" | |
| test -d "cmsys" || mkdir "cmsys" | |
| if test ! -d "cmsys"; then | |
| cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys" | |
| fi | |
| # Delete all the bootstrap files | |
| rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log" | |
| rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}" | |
| rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}" | |
| # If building in-source, remove any cmConfigure.h that may | |
| # have been created by a previous run of the bootstrap cmake. | |
| if test -n "${cmake_in_source_build}"; then | |
| rm -f "${cmake_source_dir}/Source/cmConfigure.h" | |
| fi | |
| # If exist compiler flags, set them | |
| cmake_c_flags=${CFLAGS} | |
| cmake_cxx_flags=${CXXFLAGS} | |
| cmake_ld_flags=${LDFLAGS} | |
| # Add generator-specific files | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \ | |
| cmFortranParserImpl \ | |
| cmGlobalNinjaGenerator \ | |
| cmLocalNinjaGenerator \ | |
| cmNinjaLinkLineComputer \ | |
| cmNinjaLinkLineDeviceComputer \ | |
| cmNinjaNormalTargetGenerator \ | |
| cmNinjaTargetGenerator \ | |
| cmNinjaUtilityTargetGenerator \ | |
| " | |
| LexerParser_CXX_SOURCES="${LexerParser_CXX_SOURCES} \ | |
| cmFortranLexer \ | |
| cmFortranParser \ | |
| " | |
| else | |
| CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \ | |
| cmDepends \ | |
| cmDependsC \ | |
| cmDependsCompiler \ | |
| cmGlobalUnixMakefileGenerator3 \ | |
| cmLocalUnixMakefileGenerator3 \ | |
| cmMakefileExecutableTargetGenerator \ | |
| cmMakefileLibraryTargetGenerator \ | |
| cmMakefileTargetGenerator \ | |
| cmMakefileUtilityTargetGenerator \ | |
| cmProcessTools \ | |
| " | |
| fi | |
| # Add Cygwin-specific flags | |
| if ${cmake_system_cygwin} || ${cmake_system_msys}; then | |
| cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import" | |
| fi | |
| # Add CoreFoundation framework on Darwin | |
| if ${cmake_system_darwin}; then | |
| cmake_ld_flags="${LDFLAGS} -framework CoreFoundation" | |
| fi | |
| # Add BeOS toolkits... | |
| if ${cmake_system_beos}; then | |
| cmake_ld_flags="${LDFLAGS} -lroot -lbe" | |
| fi | |
| # Add Haiku toolkits... | |
| if ${cmake_system_haiku}; then | |
| cmake_ld_flags="${LDFLAGS} -lroot -lbe" | |
| fi | |
| # Add AIX arch-specific link flags. | |
| if ${cmake_system_aix}; then | |
| if uname -p | grep powerpc >/dev/null 2>&1; then | |
| cmake_ld_flags="${LDFLAGS} -Wl,-bbigtoc" | |
| fi | |
| fi | |
| #----------------------------------------------------------------------------- | |
| # Detect known toolchains on some platforms. | |
| cmake_toolchains='' | |
| case "${cmake_system}" in | |
| *AIX*) cmake_toolchains='XL GNU' ;; | |
| *CYGWIN*) cmake_toolchains='GNU' ;; | |
| *MSYS*) cmake_toolchains='GNU' ;; | |
| *Darwin*) cmake_toolchains='Clang GNU' ;; | |
| *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 test -z "${CC}" && test -z "${CXX}"; then | |
| cmake_toolchain_detect | |
| fi | |
| thread_flags='' | |
| case "${cmake_system}" in | |
| *AIX*) thread_flags='-pthread' ;; | |
| esac | |
| #----------------------------------------------------------------------------- | |
| # Test C compiler | |
| cmake_c_compiler= | |
| # If CC is set, use that for compiler, otherwise use list of known compilers | |
| if test -n "${cmake_toolchain}"; then | |
| eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}" | |
| else | |
| cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}" | |
| fi | |
| cmake_c_compiler_try_set() | |
| { | |
| test_compiler="$1" | |
| test_thread_flags="$2" | |
| # Check if C compiler works | |
| TMPFILE=`cmake_tmp_file` | |
| echo ' | |
| #ifdef __cplusplus | |
| # error "The CMAKE_C_COMPILER is set to a C++ compiler" | |
| #endif | |
| #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE) | |
| #error "On AIX with GNU we need the -pthread flag." | |
| #endif | |
| #if defined(__sun) && __STDC_VERSION__ < 199901L | |
| #error "On Solaris we need C99." | |
| #endif | |
| #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409) | |
| #error "On HP-UX we need GCC 4.9 or higher." | |
| #endif | |
| #include <stdio.h> | |
| int main(int argc, char* argv[]) | |
| { | |
| printf("%d%c", (argv != 0), (char)0x0a); | |
| return argc - 1; | |
| } | |
| ' > "${TMPFILE}.c" | |
| for std in 11 99 90; do | |
| std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`" | |
| for std_flag in '' $std_flags; do | |
| for thread_flag in '' $test_thread_flags; do | |
| echo "Checking whether '${test_compiler} ${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1 | |
| if cmake_try_run "${test_compiler}" "${cmake_c_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \ | |
| "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then | |
| cmake_c_compiler="${test_compiler}" | |
| cmake_c_flags="${cmake_c_flags} ${std_flag} ${thread_flag}" | |
| rm -f "${TMPFILE}.c" | |
| return 0 | |
| fi | |
| done | |
| done | |
| done | |
| rm -f "${TMPFILE}.c" | |
| return 1 | |
| } | |
| if test -n "${CC}"; then | |
| cmake_c_compiler_try_set "${CC}" "${thread_flags}" | |
| else | |
| for compiler in ${cmake_c_compilers}; do | |
| if cmake_c_compiler_try_set "${compiler}" "${thread_flags}"; then | |
| break | |
| fi | |
| done | |
| fi | |
| if test -z "${cmake_c_compiler}"; then | |
| cmake_error 6 "Cannot find appropriate C compiler on this system. | |
| Please specify one using environment variable CC. | |
| See cmake_bootstrap.log for compilers attempted. | |
| " | |
| fi | |
| echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}" | |
| #----------------------------------------------------------------------------- | |
| # Test CXX compiler | |
| cmake_cxx_compiler= | |
| # On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler. | |
| # If CC is set, use that for compiler, otherwise use list of known compilers | |
| if test -n "${cmake_toolchain}"; then | |
| eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}" | |
| else | |
| cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}" | |
| fi | |
| # Check if C++ compiler works | |
| cmake_cxx_compiler_try_set() | |
| { | |
| test_compiler="$1" | |
| test_thread_flags="$2" | |
| TMPFILE=`cmake_tmp_file` | |
| echo ' | |
| #include <iostream> | |
| #include <memory> | |
| #include <unordered_map> | |
| #if __cplusplus < 201103L | |
| #error "Compiler is not in a mode aware of C++11." | |
| #endif | |
| #if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE) | |
| #error "On AIX with GNU we need the -pthread flag." | |
| #endif | |
| #if defined(__SUNPRO_CC) && __SUNPRO_CC < 0x5140 | |
| #error "SunPro <= 5.13 mode not supported due to bug in move semantics." | |
| #endif | |
| #if defined(__hpux) && !(defined(__GNUC__) && ((__GNUC__ * 100) + __GNUC_MINOR__) >= 409) | |
| #error "On HP-UX we need GCC 4.9 or higher." | |
| #endif | |
| #if __cplusplus > 201103L | |
| #include <iterator> | |
| int check_cxx14() | |
| { | |
| int a[] = { 0, 1, 2 }; | |
| auto ai = std::cbegin(a); | |
| int b[] = { 2, 1, 0 }; | |
| auto bi = std::cend(b); | |
| return *ai + *(bi - 1); | |
| } | |
| #else | |
| int check_cxx14() | |
| { | |
| return 0; | |
| } | |
| #endif | |
| #if (__cplusplus >= 201703L || defined(__INTEL_COMPILER) && defined(__cpp_deduction_guides)) | |
| #include <optional> | |
| template <typename T, | |
| typename std::invoke_result<decltype(&T::get), T>::type = nullptr> | |
| typename T::pointer get_ptr(T& item) | |
| { | |
| return item.get(); | |
| } | |
| int check_cxx17() | |
| { | |
| // Intel compiler do not handle correctly 'decltype' inside 'invoke_result' | |
| std::unique_ptr<int> u(new int(0)); | |
| get_ptr(u); | |
| std::optional<int> oi = 0; | |
| return oi.value(); | |
| } | |
| #else | |
| int check_cxx17() | |
| { | |
| return 0; | |
| } | |
| #endif | |
| class Class | |
| { | |
| public: | |
| int Get() const { return this->Member; } | |
| private: | |
| int Member = 1; | |
| }; | |
| int main() | |
| { | |
| auto const c = std::unique_ptr<Class>(new Class); | |
| std::cout << c->Get() << check_cxx14() << check_cxx17() << std::endl; | |
| return 0; | |
| } | |
| ' > "${TMPFILE}.cxx" | |
| for std in 17 14 11; do | |
| std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" CXX \"${std}\"`" | |
| for std_flag in '' $std_flags; do | |
| for thread_flag in '' $test_thread_flags; do | |
| echo "Checking whether '${test_compiler} ${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1 | |
| if cmake_try_run "${test_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags} ${std_flag} ${thread_flag}" \ | |
| "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then | |
| cmake_cxx_compiler="${test_compiler}" | |
| cmake_cxx_flags="${cmake_cxx_flags} ${std_flag} ${thread_flag} " | |
| rm -f "${TMPFILE}.cxx" | |
| return 0 | |
| fi | |
| done | |
| done | |
| done | |
| rm -f "${TMPFILE}.cxx" | |
| return 1 | |
| } | |
| if test -n "${CXX}"; then | |
| cmake_cxx_compiler_try_set "${CXX}" "${thread_flags}" | |
| else | |
| for compiler in ${cmake_cxx_compilers}; do | |
| if cmake_cxx_compiler_try_set "${compiler}" "${thread_flags}"; then | |
| break | |
| fi | |
| done | |
| fi | |
| if test -z "${cmake_cxx_compiler}"; then | |
| cmake_error 7 "Cannot find a C++ compiler that supports both C++11 and the specified C++ flags. | |
| Please specify one using environment variable CXX. | |
| The C++ flags are \"$cmake_cxx_flags\". | |
| They can be changed using the environment variable CXXFLAGS. | |
| See cmake_bootstrap.log for compilers attempted." | |
| fi | |
| echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}" | |
| #----------------------------------------------------------------------------- | |
| # Test CXX features | |
| cmake_cxx_features="make_unique filesystem" | |
| for feature in ${cmake_cxx_features}; do | |
| eval "cmake_have_cxx_${feature}=0" | |
| echo "Checking whether '${cmake_cxx_compiler} ${cmake_cxx_flags} ${cmake_ld_flags}' supports '${feature}'." >> cmake_bootstrap.log 2>&1 | |
| if cmake_try_run "${cmake_cxx_compiler}" "${cmake_cxx_flags} ${cmake_ld_flags}" \ | |
| "${cmake_source_dir}/Source/Checks/cm_cxx_${feature}.cxx" >> cmake_bootstrap.log 2>&1; then | |
| eval "cmake_have_cxx_${feature}=1" | |
| fi | |
| done | |
| cmake_have_cxx_features="" | |
| for feature in ${cmake_cxx_features}; do | |
| feature_variable="cmake_have_cxx_${feature}" | |
| eval "feature_value=\${${feature_variable}}" | |
| if test "${feature_value}" -eq "1"; then | |
| cmake_have_cxx_features="${cmake_have_cxx_features} -DCMake_HAVE_CXX_`cmake_toupper ${feature}`=${feature_value}" | |
| fi | |
| done | |
| cmake_generate_file "${cmake_bootstrap_dir}/cmSTL.hxx" "" | |
| #----------------------------------------------------------------------------- | |
| # Test Make | |
| cmake_make_processor= | |
| cmake_make_flags= | |
| # If MAKE is set, use that for make processor, otherwise use list of known make | |
| if test -n "${MAKE}"; then | |
| cmake_make_processors="${MAKE}" | |
| elif test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| cmake_make_processors="${CMAKE_KNOWN_NINJA_PROCESSORS}" | |
| else | |
| cmake_make_processors="${CMAKE_KNOWN_MAKE_PROCESSORS}" | |
| fi | |
| TMPFILE="`cmake_tmp_file`_dir" | |
| rm -rf "${cmake_bootstrap_dir}/${TMPFILE}" | |
| mkdir "${cmake_bootstrap_dir}/${TMPFILE}" | |
| cd "${cmake_bootstrap_dir}/${TMPFILE}" | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| echo ' | |
| rule cc | |
| command = '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o $out $in | |
| build test: cc test.c | |
| '>"build.ninja" | |
| else | |
| echo ' | |
| test: test.c | |
| '"${cmake_c_compiler}"' '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c | |
| '>"Makefile" | |
| fi | |
| echo ' | |
| #include <stdio.h> | |
| int main(){ printf("1%c", (char)0x0a); return 0; } | |
| ' > "test.c" | |
| cmake_original_make_flags="${cmake_make_flags}" | |
| if test "x${cmake_parallel_make}" != "x"; then | |
| cmake_make_flags="${cmake_make_flags} -j ${cmake_parallel_make}" | |
| fi | |
| for a in ${cmake_make_processors}; do | |
| if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then | |
| cmake_make_processor="${a}" | |
| fi | |
| done | |
| cmake_full_make_flags="${cmake_make_flags}" | |
| if test "x${cmake_original_make_flags}" != "x${cmake_make_flags}"; then | |
| if test -z "${cmake_make_processor}"; then | |
| cmake_make_flags="${cmake_original_make_flags}" | |
| for a in ${cmake_make_processors}; do | |
| if test -z "${cmake_make_processor}" && cmake_try_make "${a}" "${cmake_make_flags}" >> ../cmake_bootstrap.log 2>&1; then | |
| cmake_make_processor="${a}" | |
| fi | |
| done | |
| fi | |
| fi | |
| cd "${cmake_bootstrap_dir}" | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| mf_str=Ninja | |
| else | |
| mf_str=Makefile | |
| fi | |
| if test -z "${cmake_make_processor}"; then | |
| cmake_error 8 "Cannot find appropriate ${mf_str} processor on this system. | |
| Please specify one using environment variable MAKE." | |
| fi | |
| rm -rf "${cmake_bootstrap_dir}/${TMPFILE}" | |
| echo "${mf_str} processor on this system is: ${cmake_make_processor}" | |
| if test "x${cmake_full_make_flags}" != "x${cmake_make_flags}"; then | |
| echo "---------------------------------------------" | |
| echo "${mf_str} processor ${cmake_make_processor} does not support parallel build" | |
| echo "---------------------------------------------" | |
| fi | |
| # Test for kwsys features | |
| KWSYS_NAME_IS_KWSYS=0 | |
| KWSYS_BUILD_SHARED=0 | |
| KWSYS_LFS_AVAILABLE=0 | |
| KWSYS_LFS_REQUESTED=0 | |
| KWSYS_STL_HAS_WSTRING=0 | |
| KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=0 | |
| KWSYS_CXX_HAS_SETENV=0 | |
| KWSYS_CXX_HAS_UNSETENV=0 | |
| KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0 | |
| KWSYS_CXX_HAS_UTIMENSAT=0 | |
| KWSYS_CXX_HAS_UTIMES=0 | |
| if cmake_try_run "${cmake_cxx_compiler}" \ | |
| "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_SETENV" \ | |
| "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then | |
| KWSYS_CXX_HAS_SETENV=1 | |
| echo "${cmake_cxx_compiler} has setenv" | |
| else | |
| echo "${cmake_cxx_compiler} does not have setenv" | |
| fi | |
| if cmake_try_run "${cmake_cxx_compiler}" \ | |
| "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_UNSETENV" \ | |
| "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then | |
| KWSYS_CXX_HAS_UNSETENV=1 | |
| echo "${cmake_cxx_compiler} has unsetenv" | |
| else | |
| echo "${cmake_cxx_compiler} does not have unsetenv" | |
| fi | |
| if cmake_try_run "${cmake_cxx_compiler}" \ | |
| "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H" \ | |
| "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then | |
| KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=1 | |
| echo "${cmake_cxx_compiler} has environ in stdlib.h" | |
| else | |
| echo "${cmake_cxx_compiler} does not have environ in stdlib.h" | |
| fi | |
| if cmake_try_run "${cmake_cxx_compiler}" \ | |
| "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_STL_HAS_WSTRING" \ | |
| "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then | |
| KWSYS_STL_HAS_WSTRING=1 | |
| echo "${cmake_cxx_compiler} has stl wstring" | |
| else | |
| echo "${cmake_cxx_compiler} does not have stl wstring" | |
| fi | |
| if cmake_try_run "${cmake_cxx_compiler}" \ | |
| "${cmake_cxx_flags} ${cmake_ld_flags} -DTEST_KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H" \ | |
| "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then | |
| KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H=1 | |
| echo "${cmake_cxx_compiler} has <ext/stdio_filebuf.h>" | |
| else | |
| echo "${cmake_cxx_compiler} does not have <ext/stdio_filebuf.h>" | |
| fi | |
| if test -n "${cmake_ccache_enabled}"; then | |
| echo "Building CMake with ccache" | |
| cmake_c_compiler="ccache ${cmake_c_compiler}" | |
| cmake_cxx_compiler="ccache ${cmake_cxx_compiler}" | |
| fi | |
| # Just to be safe, let us store compiler and flags to the header file | |
| cmake_bootstrap_version='$Revision$' | |
| cmake_compiler_settings_comment="/* | |
| * Generated by ${cmake_source_dir}/bootstrap | |
| * Version: ${cmake_bootstrap_version} | |
| * | |
| * Source directory: ${cmake_source_dir} | |
| * Binary directory: ${cmake_bootstrap_dir} | |
| * | |
| * C compiler: ${cmake_c_compiler} | |
| * C flags: ${cmake_c_flags} | |
| * | |
| * C++ compiler: ${cmake_cxx_compiler} | |
| * C++ flags: ${cmake_cxx_flags} | |
| * | |
| * Make: ${cmake_make_processor} | |
| * | |
| * Sources: | |
| * ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES} | |
| * STD Sources: | |
| * ${CMAKE_STD_CXX_HEADERS} ${CMAKE_STD_CXX_SOURCES} | |
| * LexerParser Sources: | |
| * ${LexerParser_CXX_SOURCES} ${LexerParser_C_SOURCES} | |
| * kwSys Sources: | |
| * ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES} | |
| * libuv Sources: | |
| * ${LIBUV_C_SOURCES} | |
| * jsoncpp Sources: | |
| * ${JSONCPP_CXX_SOURCES} | |
| * librhash Sources: | |
| * ${LIBRHASH_C_SOURCES} | |
| */ | |
| " | |
| cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}" | |
| # When bootstrapping on MinGW with MSYS we must convert the source | |
| # directory to a windows path. | |
| if ${cmake_system_mingw}; then | |
| CMAKE_BOOTSTRAP_SOURCE_DIR=`cd "${cmake_source_dir}"; pwd -W` | |
| CMAKE_BOOTSTRAP_BINARY_DIR=`cd "${cmake_binary_dir}"; pwd -W` | |
| else | |
| CMAKE_BOOTSTRAP_SOURCE_DIR="${cmake_source_dir}" | |
| CMAKE_BOOTSTRAP_BINARY_DIR="${cmake_binary_dir}" | |
| fi | |
| # Write CMake version | |
| cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MAJOR ${cmake_version_major}" | |
| cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_MINOR ${cmake_version_minor}" | |
| cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION_PATCH ${cmake_version_patch}" | |
| cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION \"${cmake_version}\"" | |
| cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_SOURCE_DIR \"${CMAKE_BOOTSTRAP_SOURCE_DIR}\"" | |
| cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_BINARY_DIR \"${CMAKE_BOOTSTRAP_BINARY_DIR}\"" | |
| cmake_report cmConfigure.h${_tmp} "#define CMake_DEFAULT_RECURSION_LIMIT 400" | |
| cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insalled\"" | |
| cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\"" | |
| cmake_report cmConfigure.h${_tmp} "#define CM_FALLTHROUGH" | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_NINJA" | |
| else | |
| cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_MAKEFILES" | |
| fi | |
| if ${cmake_system_darwin}; then | |
| cmake_report cmConfigure.h${_tmp} "#define CMake_USE_MACH_PARSER" | |
| fi | |
| if ${cmake_system_mingw}; then | |
| cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(NOMINMAX)" | |
| cmake_report cmConfigure.h${_tmp} "# define NOMINMAX" | |
| cmake_report cmConfigure.h${_tmp} "#endif" | |
| cmake_report cmConfigure.h${_tmp} "#if defined(_WIN32) && !defined(KWSYS_ENCODING_DEFAULT_CODEPAGE)" | |
| cmake_report cmConfigure.h${_tmp} "# define KWSYS_ENCODING_DEFAULT_CODEPAGE CP_UTF8" | |
| cmake_report cmConfigure.h${_tmp} "#endif" | |
| fi | |
| # Regenerate configured headers | |
| for h in Configure VersionConfig; do | |
| if "${_diff}" cm${h}.h cm${h}.h${_tmp} > /dev/null 2> /dev/null; then | |
| rm -f cm${h}.h${_tmp} | |
| else | |
| mv -f cm${h}.h${_tmp} cm${h}.h | |
| fi | |
| done | |
| # Prepare KWSYS | |
| cmsys_header_files="cmsys/Configure.h cmsys/Configure.hxx" | |
| cmake_kwsys_config_replace_string \ | |
| "${cmake_source_dir}/Source/kwsys/Configure.hxx.in" \ | |
| "${cmake_bootstrap_dir}/cmsys/Configure.hxx" \ | |
| "${cmake_compiler_settings_comment}" | |
| cmake_kwsys_config_replace_string \ | |
| "${cmake_source_dir}/Source/kwsys/Configure.h.in" \ | |
| "${cmake_bootstrap_dir}/cmsys/Configure.h" \ | |
| "${cmake_compiler_settings_comment}" | |
| for a in ${KWSYS_FILES}; do | |
| cmake_replace_string "${cmake_source_dir}/Source/kwsys/${a}.in" \ | |
| "${cmake_bootstrap_dir}/cmsys/${a}" KWSYS_NAMESPACE cmsys | |
| cmsys_header_files="${cmsys_header_files} cmsys/${a}" | |
| done | |
| echo "#pragma once" > "${cmake_bootstrap_dir}/cmThirdParty.h.tmp" | |
| if test "x${bootstrap_system_libuv}" != "x"; then | |
| echo "#define CMAKE_USE_SYSTEM_LIBUV" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp" | |
| fi | |
| if test "x${bootstrap_system_jsoncpp}" != "x"; then | |
| echo "#define CMAKE_USE_SYSTEM_JSONCPP" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp" | |
| fi | |
| if test "x${bootstrap_system_librhash}" != "x"; then | |
| echo "#define CMAKE_USE_SYSTEM_LIBRHASH" >> "${cmake_bootstrap_dir}/cmThirdParty.h.tmp" | |
| fi | |
| cmake_generate_file_tmp "${cmake_bootstrap_dir}/cmThirdParty.h" "${cmake_bootstrap_dir}/cmThirdParty.h.tmp" | |
| # Generate Makefile | |
| dep="cmConfigure.h ${cmsys_header_files}" | |
| for h in "${cmake_source_dir}"/Source/*.hxx; do | |
| dep="${dep} `cmake_escape_artifact \"${h}\"`" | |
| done | |
| for h in "${cmake_source_dir}"/Source/*.h; do | |
| dep="${dep} `cmake_escape_artifact \"${h}\"`" | |
| done | |
| for h in ${CMAKE_STD_CXX_HEADERS}; do | |
| dep="${dep} `cmake_escape_artifact \"${cmake_source_dir}\"`/Utilities/std/cm/${h}" | |
| done | |
| objs="" | |
| 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 | |
| objs="${objs} ${a}.o" | |
| done | |
| if test "x${bootstrap_system_libuv}" = "x"; then | |
| for a in ${LIBUV_C_SOURCES}; do | |
| objs="${objs} uv-`cmake_obj ${a}`" | |
| done | |
| fi | |
| if test "x${bootstrap_system_librhash}" = "x"; then | |
| for a in ${LIBRHASH_C_SOURCES}; do | |
| objs="${objs} rhash-`cmake_obj ${a}`" | |
| done | |
| fi | |
| if test "x${bootstrap_system_jsoncpp}" = "x"; then | |
| for a in ${JSONCPP_CXX_SOURCES}; do | |
| objs="${objs} jsoncpp-`cmake_obj ${a}`" | |
| done | |
| fi | |
| libs="" | |
| uv_c_flags="" | |
| if ${cmake_system_mingw}; then | |
| uv_c_flags="${uv_c_flags} -DWIN32_LEAN_AND_MEAN -D_WIN32_WINNT=0x0600" | |
| libs="${libs} -lws2_32 -lpsapi -liphlpapi -lshell32 -luserenv -lole32 -loleaut32 -luuid" | |
| else | |
| case "${cmake_system}" in | |
| *AIX*) | |
| uv_c_flags="${uv_c_flags} -D_ALL_SOURCE -D_XOPEN_SOURCE=500 -D_LINUX_SOURCE_COMPAT" | |
| libs="${libs} -lperfstat" | |
| ;; | |
| *Darwin*) | |
| uv_c_flags="${uv_c_flags} -D_DARWIN_USE_64_BIT_INODE=1 -D_DARWIN_UNLIMITED_SELECT=1" | |
| ;; | |
| *HP-UX*) | |
| uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE_EXTENDED" | |
| ;; | |
| *Linux*) | |
| uv_c_flags="${uv_c_flags} -D_GNU_SOURCE" | |
| libs="${libs} -ldl -lrt" | |
| ;; | |
| *kFreeBSD*) | |
| libs="${libs} -lkvm -lfreebsd-glue" | |
| ;; | |
| *BSD*) | |
| libs="${libs} -lkvm" | |
| ;; | |
| *SunOS*) | |
| uv_c_flags="${uv_c_flags} -D__EXTENSIONS__ -D_XOPEN_SOURCE=600" | |
| libs="${libs} -lkstat -lnsl -lsendfile -lsocket -lrt" | |
| ;; | |
| *QNX*) | |
| uv_c_flags="${uv_c_flags} -D_XOPEN_SOURCE=700" | |
| libs="${libs} -lsocket" | |
| ;; | |
| esac | |
| fi | |
| if test "x${bootstrap_system_libuv}" = "x"; then | |
| uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/include"`" | |
| if ${cmake_system_mingw}; then | |
| uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/win"`" | |
| else | |
| uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src/unix"`" | |
| fi | |
| uv_c_flags="${uv_c_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmlibuv/src"`" | |
| else | |
| if test `which pkg-config`; then | |
| use_uv_flags="`pkg-config --cflags libuv`" | |
| use_uv_ldflags="`pkg-config --libs libuv`" | |
| cmake_c_flags="${cmake_c_flags} ${use_uv_flags}" | |
| cmake_cxx_flags="${cmake_cxx_flags} ${use_uv_flags}" | |
| else | |
| use_uv_ldflags="-luv" | |
| fi | |
| libs="${libs} ${use_uv_ldflags}" | |
| fi | |
| librhash_c_flags="-DNO_IMPORT_EXPORT" | |
| if test "x${bootstrap_system_librhash}" != "x"; then | |
| if test `which pkg-config`; then | |
| use_librhash_flags="`pkg-config --cflags librhash`" | |
| use_librhash_ldflags="`pkg-config --libs librhash`" | |
| cmake_c_flags="${cmake_c_flags} ${use_librhash_flags}" | |
| cmake_cxx_flags="${cmake_cxx_flags} ${use_librhash_flags}" | |
| else | |
| use_librhash_ldflags="-lrhash" | |
| fi | |
| libs="${libs} ${use_librhash_ldflags}" | |
| fi | |
| jsoncpp_cxx_flags= | |
| if test "x${bootstrap_system_jsoncpp}" = "x"; then | |
| jsoncpp_cxx_flags="${jsoncpp_cxx_flags} `cmake_escape_shell "-I${cmake_source_dir}/Utilities/cmjsoncpp/include"`" | |
| else | |
| if test `which pkg-config`; then | |
| use_jsoncpp_flags="`pkg-config --cflags jsoncpp`" | |
| use_jsoncpp_ldflags="`pkg-config --libs jsoncpp`" | |
| cmake_cxx_flags="${cmake_cxx_flags} ${use_jsoncpp_flags}" | |
| else | |
| use_jsoncpp_ldflags="-ljsoncpp" | |
| fi | |
| libs="${libs} ${use_jsoncpp_ldflags}" | |
| fi | |
| if test "x${cmake_ansi_cxx_flags}" != "x"; then | |
| cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}" | |
| fi | |
| system_flags='' | |
| case "${cmake_system}" in | |
| # Ensure filesystem access uses 64-bit offsets even on 32-bit hosts. | |
| *Linux*) system_flags='-D_FILE_OFFSET_BITS=64' ;; | |
| esac | |
| if test "x${system_flags}" != "x"; then | |
| cmake_c_flags="${cmake_c_flags} ${system_flags}" | |
| cmake_cxx_flags="${cmake_cxx_flags} ${system_flags}" | |
| fi | |
| if test "x${cmake_c_flags}" != "x"; then | |
| cmake_c_flags="${cmake_c_flags} " | |
| fi | |
| if test "x${cmake_cxx_flags}" != "x"; then | |
| cmake_cxx_flags="${cmake_cxx_flags} " | |
| fi | |
| write_source_rule() { | |
| lang="$1" | |
| obj="$2" | |
| src="$3" | |
| src_flags="$4" | |
| if test "${lang}" = "c"; then | |
| ninja_rule=cc | |
| compiler="${cmake_c_compiler}" | |
| flags="${cmake_c_flags}" | |
| elif test "${lang}" = "cxx"; then | |
| ninja_rule=cxx | |
| compiler="${cmake_cxx_compiler}" | |
| flags="${cmake_cxx_flags}" | |
| fi | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| echo "build ${obj} : ${ninja_rule} ${src} | ${dep}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo " srcflags = ${src_flags}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| else | |
| echo "${obj} : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" | |
| echo " ${compiler} ${flags} ${src_flags} -c ${src} -o ${obj}" >> "${cmake_bootstrap_dir}/Makefile" | |
| fi | |
| } | |
| cmake_c_flags_String="-DKWSYS_STRING_C" | |
| if ${cmake_system_mingw}; then | |
| cmake_c_flags_EncodingC="-DKWSYS_ENCODING_DEFAULT_CODEPAGE=CP_ACP" | |
| cmake_cxx_flags_EncodingCXX="${cmake_c_flags_EncodingC}" | |
| cmake_cxx_flags_cmProcessOutput="${cmake_c_flags_EncodingC}" | |
| fi | |
| cmake_cxx_flags_SystemTools=" | |
| -DKWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV} | |
| -DKWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV} | |
| -DKWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H} | |
| -DKWSYS_CXX_HAS_UTIMENSAT=${KWSYS_CXX_HAS_UTIMENSAT} | |
| -DKWSYS_CXX_HAS_UTIMES=${KWSYS_CXX_HAS_UTIMES} | |
| " | |
| cmake_c_flags="${cmake_c_flags} \ | |
| -DCMAKE_BOOTSTRAP \ | |
| -I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`" | |
| cmake_cxx_flags="${cmake_cxx_flags} \ | |
| -DCMAKE_BOOTSTRAP \ | |
| ${cmake_have_cxx_features} \ | |
| -I`cmake_escape_shell \"${cmake_bootstrap_dir}\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Source\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Source/LexerParser\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Utilities/std\"` \ | |
| -I`cmake_escape_shell \"${cmake_source_dir}/Utilities\"`" | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| echo "cc = ${cmake_c_compiler}" > "${cmake_bootstrap_dir}/build.ninja" | |
| echo "cxx = ${cmake_cxx_compiler}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "cflags = ${cmake_c_flags}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "cxxflags = ${cmake_cxx_flags}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "ldflags = ${cmake_ld_flags}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "rule cc" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo " command = \$cc \$cflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "rule cxx" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo " command = \$cxx \$cxxflags \$srcflags -c \$in -o \$out" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "rule link" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo " command = \$cxx \$ldflags \$cxxflags \$in \$libs -o \$out" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo "build cmake: link ${objs}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| echo " libs = ${libs}" >> "${cmake_bootstrap_dir}/build.ninja" | |
| else | |
| echo "cmake: ${objs}" > "${cmake_bootstrap_dir}/Makefile" | |
| echo " ${cmake_cxx_compiler} ${cmake_ld_flags} ${cmake_cxx_flags} ${objs} ${libs} -o cmake" >> "${cmake_bootstrap_dir}/Makefile" | |
| fi | |
| for a in ${CMAKE_CXX_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.cxx"` | |
| src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` | |
| write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}" | |
| done | |
| for a in ${CMAKE_C_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Source/${a}.c"` | |
| write_source_rule "c" "${a}.o" "${src}" "" | |
| done | |
| for a in ${CMAKE_STD_CXX_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/std/cm/bits/${a}.cxx"` | |
| src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` | |
| write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}" | |
| done | |
| for a in ${LexerParser_CXX_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.cxx"` | |
| src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` | |
| write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}" | |
| done | |
| for a in ${LexerParser_C_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Source/LexerParser/${a}.c"` | |
| write_source_rule "c" "${a}.o" "${src}" "" | |
| done | |
| for a in ${KWSYS_C_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.c"` | |
| src_flags="`eval echo \\${cmake_c_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys" | |
| write_source_rule "c" "${a}.o" "${src}" "${src_flags}" | |
| done | |
| for a in ${KWSYS_CXX_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Source/kwsys/${a}.cxx"` | |
| src_flags="`eval echo \\${cmake_cxx_flags_\${a}}` -DKWSYS_NAMESPACE=cmsys" | |
| write_source_rule "cxx" "${a}.o" "${src}" "${src_flags}" | |
| done | |
| if test "x${bootstrap_system_libuv}" = "x"; then | |
| for a in ${LIBUV_C_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibuv/${a}"` | |
| write_source_rule "c" "uv-`cmake_obj ${a}`" "${src}" "${uv_c_flags}" | |
| done | |
| fi | |
| if test "x${bootstrap_system_librhash}" = "x"; then | |
| for a in ${LIBRHASH_C_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmlibrhash/${a}"` | |
| write_source_rule "c" "rhash-`cmake_obj ${a}`" "${src}" "${librhash_c_flags}" | |
| done | |
| fi | |
| if test "x${bootstrap_system_jsoncpp}" = "x"; then | |
| for a in ${JSONCPP_CXX_SOURCES}; do | |
| src=`cmake_escape_artifact "${cmake_source_dir}/Utilities/cmjsoncpp/${a}"` | |
| write_source_rule "cxx" "jsoncpp-`cmake_obj ${a}`" "${src}" "${jsoncpp_cxx_flags}" | |
| done | |
| fi | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| echo " | |
| rule rebuild_cache | |
| command = cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\" | |
| generator = 1 | |
| build build.ninja : rebuild_cache | |
| " >> "${cmake_bootstrap_dir}/build.ninja" | |
| else | |
| echo " | |
| rebuild_cache: | |
| cd \"${cmake_binary_dir}\" && \"${cmake_source_dir}/bootstrap\" --generator=\"${cmake_bootstrap_generator}\" | |
| " >> "${cmake_bootstrap_dir}/Makefile" | |
| fi | |
| # Write our default settings to Bootstrap${_cmk}/InitialCacheFlags.cmake. | |
| echo ' | |
| # Generated by '"${cmake_source_dir}"'/bootstrap | |
| # Default cmake settings. These may be overridden any settings below. | |
| set (CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build.") # not FORCE to preserve defaults specified elsewhere | |
| set (CMAKE_INSTALL_PREFIX "'"${cmake_prefix_dir}"'" CACHE PATH "Install path prefix, prepended onto install directories." FORCE) | |
| set (CMAKE_DOC_DIR "'"${cmake_doc_dir}"'" CACHE PATH "Install location for documentation (relative to prefix)." FORCE) | |
| set (CMAKE_MAN_DIR "'"${cmake_man_dir}"'" CACHE PATH "Install location for man pages (relative to prefix)." FORCE) | |
| set (CMAKE_BIN_DIR "'"${cmake_bin_dir}"'" CACHE PATH "Install location for binaries (relative to prefix)." FORCE) | |
| set (CMAKE_DATA_DIR "'"${cmake_data_dir}"'" CACHE PATH "Install location for data (relative to prefix)." FORCE) | |
| set (CMAKE_XDGDATA_DIR "'"${cmake_xdgdata_dir}"'" CACHE PATH "Install location for XDG specific files (relative to prefix)." FORCE) | |
| ' > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| # Add configuration settings given as command-line options. | |
| if test "x${cmake_bootstrap_qt_gui}" != "x"; then | |
| echo ' | |
| set (BUILD_QtDialog '"${cmake_bootstrap_qt_gui}"' CACHE BOOL "Build Qt dialog for CMake" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_bootstrap_qt_qmake}" != "x"; then | |
| echo ' | |
| set (QT_QMAKE_EXECUTABLE "'"${cmake_bootstrap_qt_qmake}"'" CACHE FILEPATH "Location of Qt qmake" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_bootstrap_debugger}" != "x"; then | |
| echo ' | |
| set (CMake_ENABLE_DEBUGGER '"${cmake_bootstrap_debugger}"' CACHE BOOL "Enable CMake debugger support" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_info}" != "x"; then | |
| echo ' | |
| set (SPHINX_INFO "'"${cmake_sphinx_info}"'" CACHE BOOL "Build Info manual with Sphinx" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_man}" != "x"; then | |
| echo ' | |
| set (SPHINX_MAN "'"${cmake_sphinx_man}"'" CACHE BOOL "Build man pages with Sphinx" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_html}" != "x"; then | |
| echo ' | |
| set (SPHINX_HTML "'"${cmake_sphinx_html}"'" CACHE BOOL "Build html help with Sphinx" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_qthelp}" != "x"; then | |
| echo ' | |
| set (SPHINX_QTHELP "'"${cmake_sphinx_qthelp}"'" CACHE BOOL "Build qch help with Sphinx" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_latexpdf}" != "x"; then | |
| echo ' | |
| set (SPHINX_LATEXPDF "'"${cmake_sphinx_latexpdf}"'" CACHE BOOL "Build PDF help with Sphinx using LaTeX" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_build}" != "x"; then | |
| echo ' | |
| set (SPHINX_EXECUTABLE "'"${cmake_sphinx_build}"'" CACHE FILEPATH "Location of Qt sphinx-build" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| if test "x${cmake_sphinx_flags}" != "x"; then | |
| echo ' | |
| set (SPHINX_FLAGS [==['"${cmake_sphinx_flags}"']==] CACHE STRING "Flags to pass to sphinx-build" FORCE) | |
| ' >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| # Add user-specified settings. Handle relative-path case for | |
| # specification of cmake_init_file. | |
| ( | |
| cd "${cmake_binary_dir}" | |
| if test -f "${cmake_init_file}"; then | |
| cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" | |
| fi | |
| ) | |
| echo "---------------------------------------------" | |
| # Run make to build bootstrap cmake | |
| if test "${cmake_bootstrap_generator}" = "Ninja"; then | |
| ninja_v=-v | |
| else | |
| ninja_v= | |
| fi | |
| if test "x${cmake_parallel_make}" != "x"; then | |
| ${cmake_make_processor} ${cmake_make_flags} ${ninja_v} | |
| else | |
| ${cmake_make_processor} ${ninja_v} | |
| fi | |
| RES=$? | |
| if test "${RES}" -ne "0"; then | |
| cmake_error 9 "Problem while running ${cmake_make_processor}" | |
| fi | |
| cd "${cmake_binary_dir}" | |
| # Set C, CXX, and MAKE environment variables, so that real real cmake will be | |
| # build with same compiler and make | |
| CC="${cmake_c_compiler}" | |
| CXX="${cmake_cxx_compiler}" | |
| MAKE="${cmake_make_processor}" | |
| export CC | |
| export CXX | |
| export MAKE | |
| export CFLAGS | |
| export CXXFLAGS | |
| export LDFLAGS | |
| # Run bootstrap CMake to configure real CMake | |
| cmake_options="-DCMAKE_BOOTSTRAP=1" | |
| if test -n "${cmake_verbose}"; then | |
| cmake_options="${cmake_options} -DCMAKE_VERBOSE_MAKEFILE=1" | |
| fi | |
| "${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" ${cmake_options} ${cmake_bootstrap_system_libs} "$@" | |
| RES=$? | |
| if test "${RES}" -ne "0"; then | |
| cmake_error 11 "Problem while running initial CMake" | |
| fi | |
| echo "---------------------------------------------" | |
| # And we are done. Now just run make | |
| echo "CMake has bootstrapped. Now run ${cmake_make_processor}." |