#!/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 icc tcc"
CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icc como "
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 \
  cmCMakeLanguageCommand \
  cmCMakeMinimumRequired \
  cmList \
  cmCMakePath \
  cmCMakePathCommand \
  cmCMakePolicyCommand \
  cmCPackPropertiesGenerator \
  cmCacheManager \
  cmCommand \
  cmCommandArgumentParserHelper \
  cmCommands \
  cmCommonTargetGenerator \
  cmComputeComponentGraph \
  cmComputeLinkDepends \
  cmComputeLinkInformation \
  cmComputeTargetDepends \
  cmConsoleBuf \
  cmConditionEvaluator \
  cmConfigureFileCommand \
  cmContinueCommand \
  cmCoreTryCompile \
  cmCreateTestSourceList \
  cmCryptoHash \
  cmCustomCommand \
  cmCustomCommandGenerator \
  cmCustomCommandLines \
  cmCxxModuleMapper \
  cmDefinePropertyCommand \
  cmDefinitions \
  cmDocumentationFormatter \
  cmELF \
  cmEnableLanguageCommand \
  cmEnableTestingCommand \
  cmEvaluatedTargetProperty \
  cmExecProgramCommand \
  cmExecuteProcessCommand \
  cmExpandedCommandArgument \
  cmExperimental \
  cmExportBuildFileGenerator \
  cmExportFileGenerator \
  cmExportInstallFileGenerator \
  cmExportSet \
  cmExportTryCompileFileGenerator \
  cmExprParserHelper \
  cmExternalMakefileProjectGenerator \
  cmFileCommand \
  cmFileCopier \
  cmFileInstaller \
  cmFileSet \
  cmFileTime \
  cmFileTimeCache \
  cmFileTimes \
  cmFindBase \
  cmFindCommon \
  cmFindFileCommand \
  cmFindLibraryCommand \
  cmFindPackageCommand \
  cmFindPathCommand \
  cmFindProgramCommand \
  cmForEachCommand \
  cmFunctionBlocker \
  cmFunctionCommand \
  cmFSPermissions \
  cmGeneratedFileStream \
  cmGeneratorExpression \
  cmGeneratorExpressionContext \
  cmGeneratorExpressionDAGChecker \
  cmGeneratorExpressionEvaluationFile \
  cmGeneratorExpressionEvaluator \
  cmGeneratorExpressionLexer \
  cmGeneratorExpressionNode \
  cmGeneratorExpressionParser \
  cmGeneratorTarget \
  cmGetCMakePropertyCommand \
  cmGetDirectoryPropertyCommand \
  cmGetFilenameComponentCommand \
  cmGetPipes \
  cmGetPropertyCommand \
  cmGetSourceFilePropertyCommand \
  cmGetTargetPropertyCommand \
  cmGetTestPropertyCommand \
  cmGlobalCommonGenerator \
  cmGlobalGenerator \
  cmGlobVerificationManager \
  cmHexFileConverter \
  cmIfCommand \
  cmIncludeCommand \
  cmIncludeGuardCommand \
  cmIncludeDirectoryCommand \
  cmIncludeRegularExpressionCommand \
  cmInstallCommand \
  cmInstallCommandArguments \
  cmInstallCxxModuleBmiGenerator \
  cmInstallDirectoryGenerator \
  cmInstallExportGenerator \
  cmInstallFileSetGenerator \
  cmInstallFilesCommand \
  cmInstallFilesGenerator \
  cmInstallGenerator \
  cmInstallGetRuntimeDependenciesGenerator \
  cmInstallImportedRuntimeArtifactsGenerator \
  cmInstallRuntimeDependencySet \
  cmInstallRuntimeDependencySetGenerator \
  cmInstallScriptGenerator \
  cmInstallSubdirectoryGenerator \
  cmInstallTargetGenerator \
  cmInstallTargetsCommand \
  cmInstalledFile \
  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 \
  cmPolicies \
  cmProcessOutput \
  cmProjectCommand \
  cmValue \
  cmPropertyDefinition \
  cmPropertyMap \
  cmGccDepfileLexerHelper \
  cmGccDepfileReader \
  cmReturnCommand \
  cmPlaceholderExpander \
  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 \
  cmTest \
  cmTestGenerator \
  cmTimestamp \
  cmTransformDepfile \
  cmTryCompileCommand \
  cmTryRunCommand \
  cmUnsetCommand \
  cmUVHandlePtr \
  cmUVProcessChain \
  cmVersion \
  cmWhileCommand \
  cmWindowsRegistry \
  cmWorkingDirectory \
  cmake  \
  cmakemain \
  cmcmd  \
"

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 \
  "

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-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)
  --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;
              s/@KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP@/${KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP}/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-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-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 \
    "

  JSONCPP_CXX_SOURCES="\
    src/lib_json/json_reader.cpp \
    src/lib_json/json_value.cpp \
    src/lib_json/json_writer.cpp \
    "
else
  CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES} \
    cmDepends \
    cmDependsC \
    cmDependsCompiler \
    cmGlobalUnixMakefileGenerator3 \
    cmLocalUnixMakefileGenerator3 \
    cmMakefileExecutableTargetGenerator \
    cmMakefileLibraryTargetGenerator \
    cmMakefileTargetGenerator \
    cmMakefileUtilityTargetGenerator \
    cmProcessTools \
    "

  JSONCPP_CXX_SOURCES=
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
KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP=1

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_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 "${cmake_bootstrap_generator}" = "Ninja"; then
  if test "x${bootstrap_system_jsoncpp}" = "x"; then
    for a in ${JSONCPP_CXX_SOURCES}; do
      objs="${objs} jsoncpp-`cmake_obj ${a}`"
    done
  fi
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"
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*)
      # Normally libuv uses '-D_XOPEN_SOURCE=500 -std=c90' on Solaris 5.10,
      # but we do not need to do that because we bootstrap using POSIX APIs.
      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`"
    cmake_c_flags="${cmake_c_flags} ${use_uv_flags}"
    cmake_cxx_flags="${cmake_cxx_flags} ${use_uv_flags}"
  fi
  libs="${libs} -luv"
fi

if test "x${bootstrap_system_librhash}" != "x"; then
  if test `which pkg-config`; then
    use_librhash_flags="`pkg-config --cflags librhash`"
    cmake_c_flags="${cmake_c_flags} ${use_librhash_flags}"
    cmake_cxx_flags="${cmake_cxx_flags} ${use_librhash_flags}"
  fi
  libs="${libs} -lrhash"
fi

if test "${cmake_bootstrap_generator}" = "Ninja"; then
  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`"
      cmake_cxx_flags="${cmake_cxx_flags} ${use_jsoncpp_flags}"
    fi
    libs="${libs} -ljsoncpp"
  fi
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}" ""
  done
fi
if test "${cmake_bootstrap_generator}" = "Ninja"; then
  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
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}."