| #!/bin/sh |
| |
| #========================================================================= |
| # |
| # Program: CMake - Cross-Platform Makefile Generator |
| # Module: $RCSfile$ |
| # Language: Bourne Shell |
| # Date: $Date$ |
| # Version: $Revision$ |
| # |
| # Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved. |
| # See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details. |
| # |
| # This software is distributed WITHOUT ANY WARRANTY; without even |
| # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR |
| # PURPOSE. See the above copyright notices for more information. |
| # |
| #========================================================================= |
| |
| # Detect system and directory information. |
| cmake_system=`uname` |
| cmake_source_dir=`echo $0 | sed -n '/\//{s/\/[^\/]*$//;p;}'` |
| cmake_source_dir=`(cd "${cmake_source_dir}";pwd)` |
| cmake_binary_dir=`pwd` |
| cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap.cmk" |
| cmake_data_dir="/share/CMake" |
| cmake_doc_dir="/doc/CMake" |
| cmake_man_dir="/man" |
| cmake_init_file="" |
| |
| # 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 |
| |
| # 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 |
| |
| # Helper function to fix windows paths. |
| cmake_fix_slashes () |
| { |
| echo "$1" | sed 's/\\/\//g' |
| } |
| |
| # 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 |
| 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="\ |
| cmake \ |
| cmakemain \ |
| cmakewizard \ |
| cmCommandArgumentLexer \ |
| cmCommandArgumentParser \ |
| cmCommandArgumentParserHelper \ |
| cmDepends \ |
| cmDependsC \ |
| cmMakeDepend \ |
| cmMakefile \ |
| cmGeneratedFileStream \ |
| cmGlobalGenerator \ |
| cmLocalGenerator \ |
| cmInstallGenerator \ |
| cmInstallFilesGenerator \ |
| cmInstallScriptGenerator \ |
| cmInstallTargetGenerator \ |
| cmSourceFile \ |
| cmSystemTools \ |
| cmFileTimeComparison \ |
| cmGlobalUnixMakefileGenerator3 \ |
| cmLocalUnixMakefileGenerator3 \ |
| cmMakefileExecutableTargetGenerator \ |
| cmMakefileLibraryTargetGenerator \ |
| cmMakefileTargetGenerator \ |
| cmMakefileUtilityTargetGenerator \ |
| cmBootstrapCommands \ |
| cmCommands \ |
| cmTarget \ |
| cmTest \ |
| cmCustomCommand \ |
| cmCacheManager \ |
| cmListFileCache \ |
| cmOrderLinkDirectories \ |
| " |
| |
| 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" |
| KWSYS_C_MINGW_SOURCES="\ |
| ProcessFwd9x \ |
| EncodeExecutable" |
| KWSYS_C_GENERATED_SOURCES="\ |
| cmsysProcessFwd9xEnc" |
| else |
| KWSYS_C_SOURCES="\ |
| ProcessUNIX" |
| KWSYS_C_MINGW_SOURCES="" |
| KWSYS_C_GENERATED_SOURCES="" |
| fi |
| |
| KWSYS_CXX_SOURCES="\ |
| Directory \ |
| Glob \ |
| RegularExpression \ |
| SystemTools" |
| |
| KWSYS_FILES="\ |
| Directory.hxx \ |
| Glob.hxx \ |
| Process.h \ |
| RegularExpression.hxx \ |
| String.hxx \ |
| SystemTools.hxx" |
| |
| KWSYS_IOS_FILES=" |
| fstream \ |
| iosfwd \ |
| iostream \ |
| sstream" |
| |
| # Display CMake bootstrap usage |
| cmake_usage() |
| { |
| cat <<EOF |
| Usage: $0 [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] |
| --init=FILE use FILE for cmake initialization |
| |
| 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] |
| EOF |
| exit 10 |
| } |
| |
| # Display CMake bootstrap usage |
| cmake_version() |
| { |
| # Get CMake version |
| CMAKE_VERSION="" |
| for a in MAJOR MINOR PATCH; do |
| CMake_VERSION=`cat "${cmake_source_dir}/CMakeLists.txt" | \ |
| grep "SET(CMake_VERSION_${a} *[0-9]*)" | sed "s/SET(CMake_VERSION_${a} *\([0-9]*\))/\1/"` |
| CMAKE_VERSION="${CMAKE_VERSION}.${CMake_VERSION}" |
| done |
| if echo "$CMAKE_VERSION" | grep "\.[0-9][0-9]*\.[0-9]*[13579]\.[0-9]" > /dev/null 2>&1; then |
| |
| CMake_DATE=`cat "${cmake_source_dir}/Source/cmVersion.cxx" | grep "\".Date: [0-9][0-9]*/[0-9][0-9]*/[0-9][0-9]* [0-9][0-9]*:[0-9][0-9]*:[0-9][0-9]* .\";"` |
| CMake_DATE=`echo "${CMake_DATE}" | sed "s/.*Date: \([0-9][0-9]*\)\/\([0-9][0-9]*\)\/\([0-9][0-9]*\) .*/\1\2\3/" ` |
| CMAKE_VERSION=`echo $CMAKE_VERSION | sed "s/\.\([0-9][0-9]*\)\.\([0-9][0-9]*\)\.\([0-9][0-9]*\)/\1.\2-${CMake_DATE}/"` |
| else |
| CMAKE_VERSION=`echo $CMAKE_VERSION | sed "s/\.\([0-9][0-9]*\)\.\([0-9][0-9]*\)\.\([0-9][0-9]*\)/\1.\2-\3/"` |
| fi |
| echo "CMake ${CMAKE_VERSION}, Copyright (c) 2006 Kitware, Inc., Insight Consortium" |
| } |
| |
| # 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}" ]; 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}" ]; then |
| echo "${APPEND}" > "${OUTFILE}.tmp" |
| cat "${INFILE}" | |
| sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g; |
| s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/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_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" |
| } |
| |
| # 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_prefix_dir="${cmake_default_prefix}" |
| for a in "$@"; do |
| if echo $a | grep "^--prefix=" > /dev/null 2> /dev/null; then |
| cmake_prefix_dir=`echo $a | sed "s/^--prefix=//"` |
| cmake_prefix_dir=`cmake_fix_slashes "${cmake_prefix_dir}"` |
| fi |
| if echo $a | grep "^--parallel=" > /dev/null 2> /dev/null; then |
| cmake_parallel_make=`echo $a | sed "s/^--parallel=//" | grep "[0-9][0-9]*"` |
| fi |
| if echo $a | grep "^--datadir=" > /dev/null 2> /dev/null; then |
| cmake_data_dir=`echo $a | sed "s/^--datadir=//"` |
| fi |
| if echo $a | grep "^--docdir=" > /dev/null 2> /dev/null; then |
| cmake_doc_dir=`echo $a | sed "s/^--docdir=//"` |
| fi |
| if echo $a | grep "^--mandir=" > /dev/null 2> /dev/null; then |
| cmake_man_dir=`echo $a | sed "s/^--mandir=//"` |
| fi |
| if echo $a | grep "^--init=" > /dev/null 2> /dev/null; then |
| cmake_init_file=`echo $a | sed "s/^--init=//"` |
| fi |
| if echo $a | grep "^--help" > /dev/null 2> /dev/null; then |
| cmake_usage |
| fi |
| if echo $a | grep "^--version" > /dev/null 2> /dev/null; then |
| cmake_version |
| exit 2 |
| fi |
| if echo $a | grep "^--verbose" > /dev/null 2> /dev/null; then |
| cmake_verbose=TRUE |
| fi |
| 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`" |
| |
| # 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" |
| |
| # If exist compiler flags, set them |
| cmake_c_flags=${CFLAGS} |
| cmake_cxx_flags=${CXXFLAGS} |
| |
| # Add Carbon framework on Darwin |
| if ${cmake_system_darwin}; then |
| cmake_ld_flags="${LDFLAGS} -framework Carbon" |
| else |
| cmake_ld_flags=${LDFLAGS} |
| fi |
| |
| # Test C compiler |
| cmake_c_compiler= |
| |
| # If CC is set, use that for compiler, otherwise use list of known compilers |
| if [ -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` |
| cat > "${TMPFILE}.c" <<EOF |
| #include<stdio.h> |
| int main() |
| { |
| printf("1\n"); |
| return 0; |
| } |
| EOF |
| 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 "${CXX}" ]; then |
| cmake_cxx_compilers="${CXX}" |
| else |
| cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}" |
| fi |
| |
| # Check if C++ compiler works |
| TMPFILE=`cmake_tmp_file` |
| cat > "${TMPFILE}.cxx" <<EOF |
| #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; |
| } |
| EOF |
| 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}" |
| cat>"Makefile"<<EOF |
| test: test.c |
| "${cmake_c_compiler}" -o test test.c |
| EOF |
| cat>"test.c"<<EOF |
| #include <stdio.h> |
| int main(){ printf("1\n"); return 0; } |
| EOF |
| 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}" |
| rm -rf "${cmake_bootstrap_dir}/${TMPFILE}" |
| |
| 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 |
| 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` |
| cat > ${TMPFILE}.cxx <<EOF |
| #if defined(__GNUC__) && !defined(__INTEL_COMPILER) |
| #include <iostream> |
| int main() { std::cout << "This is GNU" << std::endl; return 0;} |
| #endif |
| EOF |
| 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` |
| cat > ${TMPFILE}.cxx <<EOF |
| #include <iostream> |
| int main() { std::cout << "No need for ${cmake_test_flags}" << std::endl; return 0;} |
| EOF |
| 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` |
| cat > ${TMPFILE}.cxx <<EOF |
| #include <iostream> |
| int main() { std::cout << "We need ${cmake_test_flags}" << std::endl; return 0;} |
| EOF |
| 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` |
| cat > ${TMPFILE}.cxx <<EOF |
| #include <iostream> |
| int main() { std::cout << "We need ${cmake_test_flags}" << std::endl; return 0;} |
| EOF |
| 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` |
| cat > ${TMPFILE}.c <<EOF |
| int main(int argc, char** argv) { (void)argc; (void)argv; return 0; } |
| EOF |
| 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_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_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_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_STL_HAVE_STD" \ |
| "${cmake_source_dir}/Source/kwsys/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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/kwsysPlatformCxxTests.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 |
| |
| # 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 |
| for a in MAJOR MINOR PATCH; do |
| CMake_VERSION=`cat "${cmake_source_dir}/CMakeLists.txt" | \ |
| grep "SET(CMake_VERSION_${a} *[0-9]*)" | sed "s/SET(CMake_VERSION_${a} *\([0-9]*\))/\1/"` |
| cmake_report cmConfigure.h.tmp "#define CMake_VERSION_${a} ${CMake_VERSION}" |
| done |
| 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 real cmConfigure.h |
| if diff cmConfigure.h cmConfigure.h.tmp > /dev/null 2> /dev/null; then |
| rm -f cmConfigure.h.tmp |
| else |
| mv -f cmConfigure.h.tmp cmConfigure.h |
| fi |
| |
| # 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.in" KWSYS_STL_HEADER_EXTRA "" |
| |
| cmake_replace_string "${cmake_bootstrap_dir}/cmsys/stl/stl.hxx.in" \ |
| "${cmake_bootstrap_dir}/cmsys/stl/stl.h.in" KWSYS_NAMESPACE cmsys |
| |
| for a in string vector map; do |
| cmake_replace_string "${cmake_bootstrap_dir}/cmsys/stl/stl.h.in" \ |
| "${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="${cmake_c_flags}-I`cmake_escape \"${cmake_source_dir}/Source\"` \ |
| -I`cmake_escape \"${cmake_bootstrap_dir}\"`" |
| cmake_cxx_flags="${cmake_cxx_flags}-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"` |
| echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" |
| echo " ${cmake_c_compiler} ${cmake_c_flags} -DKWSYS_NAMESPACE=cmsys -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"` |
| echo "${a}.o : ${src} ${dep}" >> "${cmake_bootstrap_dir}/Makefile" |
| echo " ${cmake_cxx_compiler} ${cmake_cxx_flags} -DKWSYS_NAMESPACE=cmsys -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 |
| cat>>"${cmake_bootstrap_dir}/Makefile"<<EOF |
| rebuild_cache: |
| cd "${cmake_binary_dir}" && "${cmake_source_dir}/bootstrap" |
| EOF |
| |
| # Write our default settings to Bootstrap.cmk/InitialCacheFlags.cmake. |
| cat > "${cmake_bootstrap_dir}/InitialCacheFlags.cmake" <<EOF |
| # 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) |
| EOF |
| |
| # 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}" |
| MAKE="${cmake_make_processor}" |
| export CC |
| export CXX |
| export MAKE |
| |
| # Run bootstrap CMake to configure real CMake |
| "${cmake_bootstrap_dir}/cmake" "${cmake_source_dir}" "-C${cmake_bootstrap_dir}/InitialCacheFlags.cmake" "-G${cmake_bootstrap_generator}" |
| 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}." |