diff options
Diffstat (limited to 'bootstrap')
| -rwxr-xr-x | bootstrap | 1564 |
1 files changed, 1564 insertions, 0 deletions
diff --git a/bootstrap b/bootstrap new file mode 100755 index 000000000..801882d7a --- /dev/null +++ b/bootstrap @@ -0,0 +1,1564 @@ +#!/bin/sh +#============================================================================= +# CMake - Cross Platform Makefile Generator +# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium +# +# Distributed under the OSI-approved BSD License (the "License"); +# see accompanying file Copyright.txt for details. +# +# This software is distributed WITHOUT ANY WARRANTY; without even the +# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. +# See the License for more information. +#============================================================================= + +die() { + echo "$@" 1>&2 ; exit 1 +} + +# Version number extraction function. +cmake_version_component() +{ + cat "${cmake_source_dir}/Source/CMakeVersion.cmake" | sed -n " +/^SET(CMake_VERSION_${1}/ {s/SET(CMake_VERSION_${1} *\([0-9]*\))/\1/;p;} +" +} + +cmake_toupper() +{ + echo "$1" | sed 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/' +} + +# 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_tweak="`cmake_version_component TWEAK`" +if [ "$cmake_version_tweak" != "0" ]; then + cmake_version="${cmake_version}.${cmake_version_tweak}" +fi + +cmake_data_dir="/share/cmake-${cmake_version_major}.${cmake_version_minor}" +cmake_doc_dir="/doc/cmake-${cmake_version_major}.${cmake_version_minor}" +cmake_man_dir="/man" +cmake_init_file="" +cmake_bootstrap_system_libs="" +cmake_bootstrap_qt_gui="" +cmake_bootstrap_qt_qmake="" + +# Determine whether this is a Cygwin environment. +if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then + cmake_system_cygwin=true +else + cmake_system_cygwin=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 +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 +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 + +# 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 [ "x${PROGRAMFILES}" != "x" ]; then + cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"` + elif [ "x${ProgramFiles}" != "x" ]; then + cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"` + elif [ "x${SYSTEMDRIVE}" != "x" ]; then + cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"` + elif [ "x${SystemDrive}" != "x" ]; then + cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"` + else + cmake_default_prefix="c:/Program Files/CMake" + fi +elif ${cmake_system_haiku}; then + cmake_default_prefix=`/bin/finddir B_COMMON_DIRECTORY` +else + cmake_default_prefix="/usr/local" +fi + +CMAKE_KNOWN_C_COMPILERS="cc gcc xlc icc tcc" +CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ c++ icc como " +CMAKE_KNOWN_MAKE_PROCESSORS="gmake make" + +CMAKE_PROBLEMATIC_FILES="\ + CMakeCache.txt \ + CMakeSystem.cmake \ + CMakeCCompiler.cmake \ + CMakeCXXCompiler.cmake \ + Source/cmConfigure.h \ + Source/CTest/Curl/config.h \ + Utilities/cmexpat/expatConfig.h \ + Utilities/cmexpat/expatDllConfig.h \ + " + +CMAKE_UNUSED_SOURCES="\ + cmGlobalXCodeGenerator \ + cmLocalXCodeGenerator \ + cmXCodeObject \ + cmXCode21Object \ + cmSourceGroup \ +" + +CMAKE_CXX_SOURCES="\ + cmStandardIncludes \ + cmake \ + cmakemain \ + cmakewizard \ + cmCommandArgumentLexer \ + cmCommandArgumentParser \ + cmCommandArgumentParserHelper \ + cmDefinitions \ + cmDepends \ + cmDependsC \ + cmDocumentationFormatter \ + cmDocumentationFormatterText \ + cmPolicies \ + cmProperty \ + cmPropertyMap \ + cmPropertyDefinition \ + cmPropertyDefinitionMap \ + cmMakeDepend \ + cmMakefile \ + cmExportFileGenerator \ + cmExportInstallFileGenerator \ + cmInstallDirectoryGenerator \ + cmGeneratedFileStream \ + cmGeneratorTarget \ + cmGeneratorExpression \ + cmGlobalGenerator \ + cmLocalGenerator \ + cmInstallGenerator \ + cmInstallExportGenerator \ + cmInstallFilesGenerator \ + cmInstallScriptGenerator \ + cmInstallTargetGenerator \ + cmScriptGenerator \ + cmSourceFile \ + cmSourceFileLocation \ + cmSystemTools \ + cmTestGenerator \ + cmVersion \ + cmFileTimeComparison \ + cmGlobalUnixMakefileGenerator3 \ + cmLocalUnixMakefileGenerator3 \ + cmMakefileExecutableTargetGenerator \ + cmMakefileLibraryTargetGenerator \ + cmMakefileTargetGenerator \ + cmMakefileUtilityTargetGenerator \ + cmOSXBundleGenerator \ + cmNewLineStyle \ + cmBootstrapCommands \ + cmCommands \ + cmTarget \ + cmTest \ + cmCustomCommand \ + cmCustomCommandGenerator \ + cmDocumentVariables \ + cmCacheManager \ + cmListFileCache \ + cmComputeLinkDepends \ + cmComputeLinkInformation \ + cmOrderDirectories \ + cmComputeTargetDepends \ + cmComputeComponentGraph \ + cmExprLexer \ + cmExprParser \ + cmExprParserHelper \ + cmGlobalNinjaGenerator \ + cmLocalNinjaGenerator \ + cmNinjaTargetGenerator \ + cmNinjaNormalTargetGenerator \ + cmNinjaUtilityTargetGenerator \ +" + +if ${cmake_system_mingw}; then + CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\ + cmGlobalMSYSMakefileGenerator \ + cmGlobalMinGWMakefileGenerator \ + cmWin32ProcessExecution" +fi + +CMAKE_C_SOURCES="\ + cmListFileLexer \ + " + +if ${cmake_system_mingw}; then + KWSYS_C_SOURCES="\ + ProcessWin32 \ + String \ + System" + KWSYS_C_MINGW_SOURCES="\ + ProcessFwd9x \ + EncodeExecutable" + KWSYS_C_GENERATED_SOURCES="\ + cmsysProcessFwd9xEnc" +else + KWSYS_C_SOURCES="\ + ProcessUNIX \ + String \ + System" + KWSYS_C_MINGW_SOURCES="" + KWSYS_C_GENERATED_SOURCES="" +fi + +KWSYS_CXX_SOURCES="\ + Directory \ + Glob \ + RegularExpression \ + SystemTools" + +KWSYS_FILES="\ + auto_ptr.hxx \ + Directory.hxx \ + Glob.hxx \ + Process.h \ + RegularExpression.hxx \ + String.h \ + String.hxx \ + System.h \ + SystemTools.hxx" + +KWSYS_IOS_FILES=" + fstream \ + iosfwd \ + iostream \ + sstream" + +# 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] + --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-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-libarchive use system-installed libarchive library + --no-system-libarchive use cmake-provided libarchive library (default) + + --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 + +Directory and file names: + --prefix=PREFIX install files in tree rooted at PREFIX + [${cmake_default_prefix}] + --datadir=DIR install data files in PREFIX/DIR + [/share/CMake] + --docdir=DIR install documentation files in PREFIX/DIR + [/doc/CMake] + --mandir=DIR install man pages files in PREFIX/DIR/manN + [/man] +' + exit 10 +} + +# Display CMake bootstrap usage +cmake_version_display() +{ + echo "CMake ${cmake_version}, Copyright 2000-2011 Kitware, Inc." +} + +# 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 [ -f cmake_bootstrap.log ]; then + echo "Log of errors: `pwd`/cmake_bootstrap.log" + #cat cmake_bootstrap.log + echo "---------------------------------------------" + fi + exit ${res} +} + +# Replace KWSYS_NAMESPACE with cmsys +cmake_replace_string () +{ + INFILE="$1" + OUTFILE="$2" + SEARCHFOR="$3" + REPLACEWITH="$4" + if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then + cat "${INFILE}" | + sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" > "${OUTFILE}${_tmp}" + if [ -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 [ -f "${INFILE}" ] || ${cmake_system_openvms}; then + echo "${APPEND}" > "${OUTFILE}${_tmp}" + cat "${INFILE}" | + 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_IOS_USE_ANSI@/${KWSYS_IOS_USE_ANSI}/g; + s/@KWSYS_IOS_HAVE_STD@/${KWSYS_IOS_HAVE_STD}/g; + s/@KWSYS_IOS_USE_SSTREAM@/${KWSYS_IOS_USE_SSTREAM}/g; + s/@KWSYS_IOS_USE_STRSTREAM_H@/${KWSYS_IOS_USE_STRSTREAM_H}/g; + s/@KWSYS_IOS_USE_STRSTREA_H@/${KWSYS_IOS_USE_STRSTREA_H}/g; + s/@KWSYS_IOS_HAVE_BINARY@/${KWSYS_IOS_HAVE_BINARY}/g; + s/@KWSYS_STL_HAVE_STD@/${KWSYS_STL_HAVE_STD}/g; + s/@KWSYS_STL_STRING_HAVE_ISTREAM@/${KWSYS_STL_STRING_HAVE_ISTREAM}/g; + s/@KWSYS_STL_STRING_HAVE_OSTREAM@/${KWSYS_STL_STRING_HAVE_OSTREAM}/g; + s/@KWSYS_STL_STRING_HAVE_NEQ_CHAR@/${KWSYS_STL_STRING_HAVE_NEQ_CHAR}/g; + s/@KWSYS_STL_HAS_ITERATOR_TRAITS@/${KWSYS_STL_HAS_ITERATOR_TRAITS}/g; + s/@KWSYS_STL_HAS_ITERATOR_CATEGORY@/${KWSYS_STL_HAS_ITERATOR_CATEGORY}/g; + s/@KWSYS_STL_HAS___ITERATOR_CATEGORY@/${KWSYS_STL_HAS___ITERATOR_CATEGORY}/g; + s/@KWSYS_STL_HAS_ALLOCATOR_TEMPLATE@/${KWSYS_STL_HAS_ALLOCATOR_TEMPLATE}/g; + s/@KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE@/${KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE}/g; + s/@KWSYS_STL_HAS_ALLOCATOR_REBIND@/${KWSYS_STL_HAS_ALLOCATOR_REBIND}/g; + s/@KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT@/${KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT}/g; + s/@KWSYS_STL_HAS_ALLOCATOR_OBJECTS@/${KWSYS_STL_HAS_ALLOCATOR_OBJECTS}/g; + s/@KWSYS_CXX_HAS_CSTDDEF@/${KWSYS_CXX_HAS_CSTDDEF}/g; + s/@KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS@/${KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS}/g; + s/@KWSYS_CXX_HAS_MEMBER_TEMPLATES@/${KWSYS_CXX_HAS_MEMBER_TEMPLATES}/g; + s/@KWSYS_CXX_HAS_FULL_SPECIALIZATION@/${KWSYS_CXX_HAS_FULL_SPECIALIZATION}/g; + s/@KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP@/${KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP}/g; + s/@KWSYS_STAT_HAS_ST_MTIM@/${KWSYS_STAT_HAS_ST_MTIM}/g;}" >> "${OUTFILE}${_tmp}" + if [ -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 +cmake_escape () +{ + echo $1 | sed "s/ /\\\\ /g" +} + +# 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 [ ! -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 [ "${RES}" -ne "0" ]; then + echo "Test failed to compile" + return 1 + fi + if [ ! -f "${TMPFILE}" ] && [ ! -f "${TMPFILE}.exe" ]; then + echo "Test failed to produce executable" + return 2 + fi + ./${TMPFILE} + RES=$? + rm -f "${TMPFILE}" + if [ "${RES}" -ne "0" ]; then + echo "Test produced non-zero return code" + return 3 + fi + echo "Test succeded" + 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 [ "${RES}" -ne "0" ]; then + echo "${MAKE_PROC} does not work" + return 1 + fi + if [ ! -f "test" ] && [ ! -f "test.exe" ]; then + echo "${COMPILER} does not produce output" + return 2 + fi + ./test + RES=$? + rm -f "test" + if [ "${RES}" -ne "0" ]; then + echo "${MAKE_PROC} produces strange executable" + return 3 + fi + echo "${MAKE_PROC} works" + return 0 +} + +# Parse arguments +cmake_verbose= +cmake_parallel_make= +cmake_ccache_enabled= +cmake_prefix_dir="${cmake_default_prefix}" +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"` ;; + --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;; + --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;; + --mandir=*) cmake_man_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-libarchive|--system-zlib) + 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-libarchive|--no-system-zlib) + lib=`cmake_arg "$1" "--no-system-"` + cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;; + --qt-gui) cmake_bootstrap_qt_gui="1" ;; + --no-qt-gui) cmake_bootstrap_qt_gui="0" ;; + --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;; + --help) cmake_usage ;; + --version) cmake_version_display ; exit 2 ;; + --verbose) cmake_verbose=TRUE ;; + --enable-ccache) cmake_ccache_enabled=TRUE ;; + --) shift; break ;; + *) die "Unknown option: $1" ;; + esac + shift +done + +# If verbose, display some information about bootstrap +if [ -n "${cmake_verbose}" ]; then + echo "---------------------------------------------" + echo "Source directory: ${cmake_source_dir}" + echo "Binary directory: ${cmake_binary_dir}" + echo "Prefix directory: ${cmake_prefix_dir}" + echo "System: ${cmake_system}" + if [ "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 [ -f "${cmake_binary_dir}/Source/cmake.cxx" -a \ + -f "${cmake_binary_dir}/Source/cmake.h" ]; then + if [ -n "${cmake_verbose}" ]; then + echo "Warning: This is an in-source build" + fi + cmake_in_source_build=TRUE +fi + +# If this is not an in-source build, then Bootstrap stuff should not exist. +if [ -z "${cmake_in_source_build}" ]; then + # Did somebody bootstrap in the source tree? + if [ -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 [ -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 +[ -d "${cmake_bootstrap_dir}" ] || mkdir "${cmake_bootstrap_dir}" +if [ ! -d "${cmake_bootstrap_dir}" ]; then + cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake." +fi +cd "${cmake_bootstrap_dir}" + +[ -d "cmsys" ] || mkdir "cmsys" +if [ ! -d "cmsys" ]; then + cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys" +fi + +for a in stl ios; do + [ -d "cmsys/${a}" ] || mkdir "cmsys/${a}" + if [ ! -d "cmsys/${a}" ]; then + cmake_error 5 "Cannot create directory ${cmake_bootstrap_dir}/cmsys/${a}" + fi +done + +# 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 exist compiler flags, set them +cmake_c_flags=${CFLAGS} +cmake_cxx_flags=${CXXFLAGS} +cmake_ld_flags=${LDFLAGS} + +# Add Cygwin-specific flags +if ${cmake_system_cygwin}; 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 + +#----------------------------------------------------------------------------- +# Detect known toolchains on some platforms. +cmake_toolchains='' +case "${cmake_system}" in + *AIX*) cmake_toolchains='XL GNU' ;; + *CYGWIN*) cmake_toolchains='GNU' ;; + *Darwin*) cmake_toolchains='GNU Clang' ;; + *Linux*) cmake_toolchains='GNU Clang XL PGI PathScale' ;; + *MINGW*) cmake_toolchains='GNU' ;; +esac + +# Toolchain compiler name table. +cmake_toolchain_Clang_CC='clang' +cmake_toolchain_Clang_CXX='clang++' +cmake_toolchain_GNU_CC='gcc' +cmake_toolchain_GNU_CXX='g++' +cmake_toolchain_PGI_CC='pgcc' +cmake_toolchain_PGI_CXX='pgCC' +cmake_toolchain_PathScale_CC='pathcc' +cmake_toolchain_PathScale_CXX='pathCC' +cmake_toolchain_XL_CC='xlc' +cmake_toolchain_XL_CXX='xlC' + +cmake_toolchain_try() +{ + tc="$1" + TMPFILE=`cmake_tmp_file` + + eval "tc_CC=\${cmake_toolchain_${tc}_CC}" + echo 'int main() { return 0; }' > "${TMPFILE}.c" + cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1 + tc_result_CC="$?" + rm -f "${TMPFILE}.c" + test "${tc_result_CC}" = "0" || return 1 + + eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}" + echo 'int main() { return 0; }' > "${TMPFILE}.cpp" + cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1 + tc_result_CXX="$?" + rm -f "${TMPFILE}.cpp" + test "${tc_result_CXX}" = "0" || return 1 + + cmake_toolchain="$tc" +} + +cmake_toolchain_detect() +{ + cmake_toolchain= + for tc in ${cmake_toolchains}; do + echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1 + cmake_toolchain_try "$tc" && + echo "Found $tc toolchain" && + break + done +} + +if [ -z "${CC}" -a -z "${CXX}" ]; then + cmake_toolchain_detect +fi + +#----------------------------------------------------------------------------- +# Test C compiler +cmake_c_compiler= + +# If CC is set, use that for compiler, otherwise use list of known compilers +if [ -n "${cmake_toolchain}" ]; then + eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}" +elif [ -n "${CC}" ]; then + cmake_c_compilers="${CC}" +else + cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}" +fi + +# Check if C compiler works +TMPFILE=`cmake_tmp_file` +echo ' +#ifdef __cplusplus +# error "The CMAKE_C_COMPILER is set to a C++ compiler" +#endif + +#include<stdio.h> + +#if defined(__CLASSIC_C__) +int main(argc, argv) + int argc; + char* argv[]; +#else +int main(int argc, char* argv[]) +#endif +{ + printf("%d%c", (argv != 0), (char)0x0a); + return argc-1; +} +' > "${TMPFILE}.c" +for a in ${cmake_c_compilers}; do + if [ -z "${cmake_c_compiler}" ] && \ + cmake_try_run "${a}" "${cmake_c_flags}" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then + cmake_c_compiler="${a}" + fi +done +rm -f "${TMPFILE}.c" + +if [ -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 [ -n "${cmake_toolchain}" ]; then + eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}" +elif [ -n "${CXX}" ]; then + cmake_cxx_compilers="${CXX}" +else + cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}" +fi + +# Check if C++ compiler works +TMPFILE=`cmake_tmp_file` +echo ' +#if defined(TEST1) +# include <iostream> +#else +# include <iostream.h> +#endif + +class NeedCXX +{ +public: + NeedCXX() { this->Foo = 1; } + int GetFoo() { return this->Foo; } +private: + int Foo; +}; +int main() +{ + NeedCXX c; +#ifdef TEST3 + cout << c.GetFoo() << endl; +#else + std::cout << c.GetFoo() << std::endl; +#endif + return 0; +} +' > "${TMPFILE}.cxx" +for a in ${cmake_cxx_compilers}; do + for b in 1 2 3; do + if [ -z "${cmake_cxx_compiler}" ] && \ + cmake_try_run "${a}" "${cmake_cxx_flags} -DTEST${b}" "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then + cmake_cxx_compiler="${a}" + fi + done +done +rm -f "${TMPFILE}.cxx" + +if [ -z "${cmake_cxx_compiler}" ]; then + cmake_error 7 "Cannot find appropriate C++ compiler on this system. +Please specify one using environment variable CXX. +See cmake_bootstrap.log for compilers attempted." +fi +echo "C++ compiler on this system is: ${cmake_cxx_compiler} ${cmake_cxx_flags}" + +#----------------------------------------------------------------------------- +# Test Make + +cmake_make_processor= +cmake_make_flags= + +# If MAKE is set, use that for make processor, otherwise use list of known make +if [ -n "${MAKE}" ]; then + cmake_make_processors="${MAKE}" +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}" +echo ' +test: test.c + "'"${cmake_c_compiler}"'" '"${cmake_ld_flags} ${cmake_c_flags}"' -o test test.c +'>"Makefile" +echo ' +#include <stdio.h> +int main(){ printf("1%c", (char)0x0a); return 0; } +' > "test.c" +cmake_original_make_flags="${cmake_make_flags}" +if [ "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 [ -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 [ "x${cmake_original_make_flags}" != "x${cmake_make_flags}" ]; then + if [ -z "${cmake_make_processor}" ]; then + cmake_make_flags="${cmake_original_make_flags}" + for a in ${cmake_make_processors}; do + if [ -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 [ -z "${cmake_make_processor}" ]; then + cmake_error 8 "Cannot find appropriate Makefile processor on this system. +Please specify one using environment variable MAKE." +fi +rm -rf "${cmake_bootstrap_dir}/${TMPFILE}" +echo "Makefile processor on this system is: ${cmake_make_processor}" +if [ "x${cmake_full_make_flags}" != "x${cmake_make_flags}" ]; then + echo "---------------------------------------------" + echo "Makefile processor ${cmake_make_processor} does not support parallel build" + echo "---------------------------------------------" +fi + +# Ok, we have CC, CXX, and MAKE. + +# Test C++ compiler features + +# Are we GCC? + +TMPFILE=`cmake_tmp_file` +echo ' +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +#include <iostream> +int main() { std::cout << "This is GNU" << std::endl; return 0;} +#endif +' > ${TMPFILE}.cxx +cmake_cxx_compiler_is_gnu=0 +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags}" "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then + cmake_cxx_compiler_is_gnu=1 +fi +if [ "x${cmake_cxx_compiler_is_gnu}" = "x1" ]; then + echo "${cmake_cxx_compiler} is GNU compiler" +else + echo "${cmake_cxx_compiler} is not GNU compiler" +fi +rm -f "${TMPFILE}.cxx" + +if [ "x${cmake_cxx_compiler_is_gnu}" != "x1" ]; then + # Check for non-GNU compiler flags + + # If we are on IRIX, check for -LANG:std + cmake_test_flags="-LANG:std" + if [ "x${cmake_system}" = "xIRIX64" ]; then + TMPFILE=`cmake_tmp_file` + echo ' + #include <iostream> + int main() { std::cout << "No need for '"${cmake_test_flags}"'" << std::endl; return 0;} +' > ${TMPFILE}.cxx + cmake_need_lang_std=0 + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags}" "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then + : + else + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} ${cmake_test_flags}" "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then + cmake_need_lang_std=1 + fi + fi + if [ "x${cmake_need_lang_std}" = "x1" ]; then + cmake_cxx_flags="${cmake_cxx_flags} ${cmake_test_flags}" + echo "${cmake_cxx_compiler} needs ${cmake_test_flags}" + else + echo "${cmake_cxx_compiler} does not need ${cmake_test_flags}" + fi + rm -f "${TMPFILE}.cxx" + fi + cmake_test_flags= + + # If we are on OSF, check for -timplicit_local -no_implicit_include + cmake_test_flags="-timplicit_local -no_implicit_include" + if [ "x${cmake_system}" = "xOSF1" ]; then + TMPFILE=`cmake_tmp_file` + echo ' + #include <iostream> + int main() { std::cout << "We need '"${cmake_test_flags}"'" << std::endl; return 0;} +' > ${TMPFILE}.cxx + cmake_need_flags=1 + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} ${cmake_test_flags}" "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then + : + else + cmake_need_flags=0 + fi + if [ "x${cmake_need_flags}" = "x1" ]; then + cmake_cxx_flags="${cmake_cxx_flags} ${cmake_test_flags}" + echo "${cmake_cxx_compiler} needs ${cmake_test_flags}" + else + echo "${cmake_cxx_compiler} does not need ${cmake_test_flags}" + fi + rm -f "${TMPFILE}.cxx" + fi + cmake_test_flags= + + # If we are on OSF, check for -std strict_ansi -nopure_cname + cmake_test_flags="-std strict_ansi -nopure_cname" + if [ "x${cmake_system}" = "xOSF1" ]; then + TMPFILE=`cmake_tmp_file` + echo ' + #include <iostream> + int main() { std::cout << "We need '"${cmake_test_flags}"'" << std::endl; return 0;} +' > ${TMPFILE}.cxx + cmake_need_flags=1 + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} ${cmake_test_flags}" "${TMPFILE}.cxx" >> cmake_bootstrap.log 2>&1; then + : + else + cmake_need_flags=0 + fi + if [ "x${cmake_need_flags}" = "x1" ]; then + cmake_cxx_flags="${cmake_cxx_flags} ${cmake_test_flags}" + echo "${cmake_cxx_compiler} needs ${cmake_test_flags}" + else + echo "${cmake_cxx_compiler} does not need ${cmake_test_flags}" + fi + rm -f "${TMPFILE}.cxx" + fi + cmake_test_flags= + + # If we are on HP-UX, check for -Ae for the C compiler. + cmake_test_flags="-Ae" + if [ "x${cmake_system}" = "xHP-UX" ]; then + TMPFILE=`cmake_tmp_file` + echo ' + int main(int argc, char** argv) { (void)argc; (void)argv; return 0; } +' > ${TMPFILE}.c + cmake_need_Ae=0 + if cmake_try_run "${cmake_c_compiler}" "${cmake_c_flags}" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then + : + else + if cmake_try_run "${cmake_c_compiler}" \ + "${cmake_c_flags} ${cmake_test_flags}" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then + cmake_need_Ae=1 + fi + fi + if [ "x${cmake_need_Ae}" = "x1" ]; then + cmake_c_flags="${cmake_c_flags} ${cmake_test_flags}" + echo "${cmake_c_compiler} needs ${cmake_test_flags}" + else + echo "${cmake_c_compiler} does not need ${cmake_test_flags}" + fi + rm -f "${TMPFILE}.c" + fi + cmake_test_flags= +fi + +# Test for kwsys features +KWSYS_NAME_IS_KWSYS=0 +KWSYS_BUILD_SHARED=0 +KWSYS_LFS_AVAILABLE=0 +KWSYS_LFS_REQUESTED=0 +KWSYS_IOS_USE_STRSTREAM_H=0 +KWSYS_IOS_USE_STRSTREA_H=0 +KWSYS_IOS_HAVE_STD=0 +KWSYS_IOS_USE_SSTREAM=0 +KWSYS_IOS_USE_ANSI=0 +KWSYS_IOS_HAVE_BINARY=0 +KWSYS_STL_HAVE_STD=0 +KWSYS_STAT_HAS_ST_MTIM=0 +KWSYS_STL_STRING_HAVE_NEQ_CHAR=0 +KWSYS_STL_HAS_ITERATOR_TRAITS=0 +KWSYS_STL_HAS_ITERATOR_CATEGORY=0 +KWSYS_STL_HAS___ITERATOR_CATEGORY=0 +KWSYS_STL_HAS_ALLOCATOR_TEMPLATE=0 +KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE=0 +KWSYS_STL_HAS_ALLOCATOR_REBIND=0 +KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT=0 +KWSYS_STL_HAS_ALLOCATOR_OBJECTS=0 +KWSYS_CXX_HAS_SETENV=0 +KWSYS_CXX_HAS_UNSETENV=0 +KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=0 +KWSYS_CXX_HAS_CSTDDEF=0 +KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS=0 +KWSYS_CXX_HAS_MEMBER_TEMPLATES=0 +KWSYS_CXX_HAS_FULL_SPECIALIZATION=0 +KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP=0 + +# Hardcode these kwsys features. They work on all known UNIX compilers anyway. +KWSYS_STL_STRING_HAVE_ISTREAM=1 +KWSYS_STL_STRING_HAVE_OSTREAM=1 + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_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} -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} -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} -DTEST_KWSYS_STL_HAVE_STD" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAVE_STD=1 + echo "${cmake_cxx_compiler} has STL in std:: namespace" +else + echo "${cmake_cxx_compiler} does not have STL in std:: namespace" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_ANSI" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_IOS_USE_ANSI=1 + echo "${cmake_cxx_compiler} has ANSI streams" +else + echo "${cmake_cxx_compiler} does not have ANSI streams" +fi + +if [ "x$KWSYS_IOS_USE_ANSI" = "x1" ]; then + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_IOS_HAVE_STD" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_IOS_HAVE_STD=1 + echo "${cmake_cxx_compiler} has streams in std:: namespace" + else + echo "${cmake_cxx_compiler} does not have streams in std:: namespace" + fi + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_SSTREAM" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_IOS_USE_SSTREAM=1 + echo "${cmake_cxx_compiler} has sstream" + else + echo "${cmake_cxx_compiler} does not have sstream" + fi +fi + +if [ "x$KWSYS_IOS_USE_SSTREAM" = "x0" ]; then + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_STRSTREAM_H" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_IOS_USE_STRSTREAM_H=1 + echo "${cmake_cxx_compiler} has strstream.h" + else + echo "${cmake_cxx_compiler} does not have strstream.h" + fi + if [ "x$KWSYS_IOS_USE_STRSTREAM_H" = "x0" ]; then + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_IOS_USE_STRSTREA_H" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_IOS_USE_STRSTREA_H=1 + echo "${cmake_cxx_compiler} has strstrea.h" + else + echo "${cmake_cxx_compiler} does not have strstrea.h" + fi + fi +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_STRING_HAVE_NEQ_CHAR=1 + echo "${cmake_cxx_compiler} has operator!=(string, char*)" +else + echo "${cmake_cxx_compiler} does not have operator!=(string, char*)" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ITERATOR_TRAITS -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ITERATOR_TRAITS=1 + echo "${cmake_cxx_compiler} has stl iterator_traits" +else + echo "${cmake_cxx_compiler} does not have stl iterator_traits" +fi + +if [ "x${KWSYS_STL_HAS_ITERATOR_TRAITS}" = "x0" ]; then + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ITERATOR_CATEGORY -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ITERATOR_CATEGORY=1 + echo "${cmake_cxx_compiler} has old iterator_category" + else + echo "${cmake_cxx_compiler} does not have old iterator_category" + fi + if [ "x${KWSYS_STL_HAS_ITERATOR_CATEGORY}" = "x0" ]; then + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS___ITERATOR_CATEGORY -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS___ITERATOR_CATEGORY=1 + echo "${cmake_cxx_compiler} has old __iterator_category" + else + echo "${cmake_cxx_compiler} does not have old __iterator_category" + fi + fi +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ALLOCATOR_TEMPLATE=1 + echo "${cmake_cxx_compiler} has standard template allocator" +else + echo "${cmake_cxx_compiler} does not have standard template allocator" +fi + +if [ "x${KWSYS_STL_HAS_ALLOCATOR_TEMPLATE}" = "x1" ]; then + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_REBIND -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ALLOCATOR_REBIND=1 + echo "${cmake_cxx_compiler} has allocator<>::rebind<>" + else + echo "${cmake_cxx_compiler} does not have allocator<>::rebind<>" + fi + + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT=1 + echo "${cmake_cxx_compiler} has non-standard allocator<>::max_size argument" + else + echo "${cmake_cxx_compiler} does not have non-standard allocator<>::max_size argument" + fi +else + if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE=1 + echo "${cmake_cxx_compiler} has old non-template allocator" + else + echo "${cmake_cxx_compiler} does not have old non-template allocator" + fi +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STL_HAS_ALLOCATOR_OBJECTS=1 + echo "${cmake_cxx_compiler} has stl containers supporting allocator objects" +else + echo "${cmake_cxx_compiler} does not have stl containers supporting allocator objects" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_CSTDDEF" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_CXX_HAS_CSTDDEF=1 + echo "${cmake_cxx_compiler} has header cstddef" +else + echo "${cmake_cxx_compiler} does not have header cstddef" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + echo "${cmake_cxx_compiler} does not require template friends to use <>" +else + KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS=1 + echo "${cmake_cxx_compiler} requires template friends to use <>" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_CXX_HAS_MEMBER_TEMPLATES=1 + echo "${cmake_cxx_compiler} supports member templates" +else + echo "${cmake_cxx_compiler} does not support member templates" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_CXX_HAS_FULL_SPECIALIZATION=1 + echo "${cmake_cxx_compiler} has standard template specialization syntax" +else + echo "${cmake_cxx_compiler} does not have standard template specialization syntax" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP=1 + echo "${cmake_cxx_compiler} has argument dependent lookup" +else + echo "${cmake_cxx_compiler} does not have argument dependent lookup" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_STAT_HAS_ST_MTIM" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_STAT_HAS_ST_MTIM=1 + echo "${cmake_cxx_compiler} has struct stat with st_mtim member" +else + echo "${cmake_cxx_compiler} does not have struct stat with st_mtim member" +fi + +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags} -DTEST_KWSYS_IOS_HAVE_BINARY -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI} -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD}" \ + "${cmake_source_dir}/Source/kwsys/kwsysPlatformTestsCXX.cxx" >> cmake_bootstrap.log 2>&1; then + KWSYS_IOS_HAVE_BINARY=1 + echo "${cmake_cxx_compiler} has ios::binary openmode" +else + echo "${cmake_cxx_compiler} does not have ios::binary openmode" +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} + * kwSys Sources: + * ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES} ${KWSYS_C_MINGW_SOURCES} + */ +" + +cmake_report cmConfigure.h${_tmp} "${cmake_compiler_settings_comment}" + +if [ "x$KWSYS_STL_HAVE_STD" = "x1" ]; then + cmake_report cmConfigure.h${_tmp} "/* #undef CMAKE_NO_STD_NAMESPACE */" +else + cmake_report cmConfigure.h${_tmp} "#define CMAKE_NO_STD_NAMESPACE 1" +fi + +if [ "x$KWSYS_IOS_USE_ANSI" = "x1" ]; then + cmake_report cmConfigure.h${_tmp} "/* #undef CMAKE_NO_ANSI_STREAM_HEADERS */" +else + cmake_report cmConfigure.h${_tmp} "#define CMAKE_NO_ANSI_STREAM_HEADERS 1" +fi + +if [ "x$KWSYS_IOS_USE_SSTREAM" = "x1" ]; then + cmake_report cmConfigure.h${_tmp} "/* #undef CMAKE_NO_ANSI_STRING_STREAM */" +else + cmake_report cmConfigure.h${_tmp} "#define CMAKE_NO_ANSI_STRING_STREAM 1" +fi + +# Test for ansi FOR scope +if cmake_try_run "${cmake_cxx_compiler}" \ + "${cmake_cxx_flags}" \ + "${cmake_source_dir}/Modules/TestForAnsiForScope.cxx" >> cmake_bootstrap.log 2>&1; then + cmake_report cmConfigure.h${_tmp} "/* #undef CMAKE_NO_ANSI_FOR_SCOPE */" + echo "${cmake_cxx_compiler} has ANSI for scoping" +else + cmake_report cmConfigure.h${_tmp} "#define CMAKE_NO_ANSI_FOR_SCOPE 1" + echo "${cmake_cxx_compiler} does not have ANSI for scoping" +fi + +# When bootstrapping on MinGW with MSYS we must convert the source +# directory to a windows path. +if ${cmake_system_mingw}; then + cmake_root_dir=`cd "${cmake_source_dir}"; pwd -W` +else + cmake_root_dir="${cmake_source_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_TWEAK ${cmake_version_tweak}" +cmake_report cmVersionConfig.h${_tmp} "#define CMake_VERSION \"${cmake_version}\"" +cmake_report cmConfigure.h${_tmp} "#define CMAKE_ROOT_DIR \"${cmake_root_dir}\"" +cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"${cmake_data_dir}\"" +cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP" + +# 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 +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 +done + +for a in ${KWSYS_IOS_FILES}; do + cmake_replace_string "${cmake_source_dir}/Source/kwsys/kwsys_ios_${a}.h.in" \ + "${cmake_bootstrap_dir}/cmsys/ios/${a}" KWSYS_NAMESPACE cmsys +done + +cmake_replace_string "${cmake_source_dir}/Source/kwsys/kwsys_stl.hxx.in" \ + "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_a" KWSYS_STL_HEADER_EXTRA "" + +cmake_replace_string "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_a" \ + "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_b" KWSYS_NAMESPACE cmsys + +for a in string vector set map algorithm; do + cmake_replace_string "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx_b" \ + "${cmake_bootstrap_dir}/cmsys/stl/${a}" KWSYS_STL_HEADER ${a} +done + +# Generate Makefile +dep="cmConfigure.h cmsys/*.hxx cmsys/*.h `cmake_escape \"${cmake_source_dir}\"`/Source/*.h" +objs="" +for a in ${CMAKE_CXX_SOURCES} ${CMAKE_C_SOURCES} ${KWSYS_CXX_SOURCES} ${KWSYS_C_SOURCES} ${KWSYS_C_GENERATED_SOURCES}; do + objs="${objs} ${a}.o" +done + +# Generate dependencies for cmBootstrapCommands.cxx +for file in `grep "#include.*cm[^.]*.cxx" "${cmake_source_dir}/Source/cmBootstrapCommands.cxx" | sed "s/.* \"\(.*\)\"/\1/"`; do + cmBootstrapCommandsDeps="${cmBootstrapCommandsDeps} `cmake_escape "${cmake_source_dir}/Source/$file"`" +done +cmBootstrapCommandsDeps=`echo $cmBootstrapCommandsDeps` + +if [ "x${cmake_ansi_cxx_flags}" != "x" ]; then + cmake_cxx_flags="${cmake_ansi_cxx_flags} ${cmake_cxx_flags}" +fi + +if [ "x${cmake_c_flags}" != "x" ]; then + cmake_c_flags="${cmake_c_flags} " +fi + +if [ "x${cmake_cxx_flags}" != "x" ]; then + cmake_cxx_flags="${cmake_cxx_flags} " +fi + +cmake_c_flags_String="-DKWSYS_STRING_C" +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}" +cmake_c_flags="${cmake_c_flags}-I`cmake_escape \"${cmake_bootstrap_dir}\"` -I`cmake_escape \"${cmake_source_dir}/Source\"` \ + -I`cmake_escape \"${cmake_bootstrap_dir}\"`" +cmake_cxx_flags="${cmake_cxx_flags} -I`cmake_escape \"${cmake_bootstrap_dir}\"` -I`cmake_escape \"${cmake_source_dir}/Source\"` \ + -I`cmake_escape \"${cmake_bootstrap_dir}\"`" +echo "cmake: ${objs}" > "${cmake_bootstrap_dir}/Makefile" +echo " ${cmake_cxx_compiler} ${cmake_ld_flags} ${cmake_cxx_flags} ${objs} -o cmake" >> "${cmake_bootstrap_dir}/Makefile" +for a in ${CMAKE_CXX_SOURCES}; do + src=`cmake_escape "${cmake_source_dir}/Source/${a}.cxx"` + echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_cxx_compiler} ${cmake_cxx_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" +done +echo "cmBootstrapCommands.o : $cmBootstrapCommandsDeps" >> "${cmake_bootstrap_dir}/Makefile" +for a in ${CMAKE_C_SOURCES}; do + src=`cmake_escape "${cmake_source_dir}/Source/${a}.c"` + echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_c_compiler} ${cmake_c_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" +done +for a in ${KWSYS_C_SOURCES} ${KWSYS_C_MINGW_SOURCES}; do + src=`cmake_escape "${cmake_source_dir}/Source/kwsys/${a}.c"` + src_flags=`eval echo \\${cmake_c_flags_\${a}}` + echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_c_compiler} ${cmake_c_flags} -DKWSYS_NAMESPACE=cmsys ${src_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" +done +for a in ${KWSYS_CXX_SOURCES}; do + src=`cmake_escape "${cmake_source_dir}/Source/kwsys/${a}.cxx"` + src_flags=`eval echo \\${cmake_cxx_flags_\${a}}` + echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_cxx_compiler} ${cmake_cxx_flags} -DKWSYS_NAMESPACE=cmsys ${src_flags} -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" +done +if ${cmake_system_mingw}; then + src=`cmake_escape "${cmake_bootstrap_dir}/cmsysProcessFwd9xEnc.c"` + in=`cmake_escape "${cmake_bootstrap_dir}/cmsysProcessFwd9x.exe"` + cmd=`cmake_escape "${cmake_bootstrap_dir}/cmsysEncodeExecutable.exe"` + a="cmsysProcessFwd9xEnc" + echo "${cmd} : EncodeExecutable.o" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_c_compiler} ${cmake_ld_flags} ${cmake_c_flags} EncodeExecutable.o -o ${cmd}" >> "${cmake_bootstrap_dir}/Makefile" + echo "${in} : ProcessFwd9x.o" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_c_compiler} ${cmake_ld_flags} ${cmake_c_flags} ProcessFwd9x.o -o ${in}" >> "${cmake_bootstrap_dir}/Makefile" + echo "${src} : ${cmd} ${in}" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmd} ${in} ${src} cmsys ProcessFwd9x" >> "${cmake_bootstrap_dir}/Makefile" + echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" + echo " ${cmake_c_compiler} ${cmake_c_flags} -I`cmake_escape \"${cmake_source_dir}/Source/kwsys\"` -DKWSYS_NAMESPACE=cmsys -c ${src} -o ${a}.o" >> "${cmake_bootstrap_dir}/Makefile" +fi +echo ' +rebuild_cache: + cd "${cmake_binary_dir}" && "${cmake_source_dir}/bootstrap" +' >> "${cmake_bootstrap_dir}/Makefile" + +# 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_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_DATA_DIR "'"${cmake_data_dir}"'" CACHE PATH "Install location for data (relative to prefix)." FORCE) +' > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" + +# Add configuration settings given as command-line options. +if [ "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 [ "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 + +# Add user-specified settings. Handle relative-path case for +# specification of cmake_init_file. +( +cd "${cmake_binary_dir}" +if [ -f "${cmake_init_file}" ]; then + cat "${cmake_init_file}" >> "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" +fi +) + +echo "---------------------------------------------" + +# Run make to build bootstrap cmake +if [ "x${cmake_parallel_make}" != "x" ]; then + ${cmake_make_processor} ${cmake_make_flags} +else + ${cmake_make_processor} +fi +RES=$? +if [ "${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}" +if [ -n "${cmake_ccache_enabled}" ]; then + CC="ccache ${CC}" + CXX="ccache ${CXX}" +fi +MAKE="${cmake_make_processor}" +export CC +export CXX +export MAKE + +# Run bootstrap CMake to configure real CMake +cmake_options="-DCMAKE_BOOTSTRAP=1" +if [ -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 [ "${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}." |