Merge branch 'honor-explicit-zero-timeout' into resolve/mingw-cross-compile-resources/honor-explicit-zero-timeout

Conflicts:
	Tests/CMakeLists.txt

CMakeLists.txt

@@ -10,6 +10,7 @@
 # See the License for more information.
 #=============================================================================
 CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5 FATAL_ERROR)
+SET(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
 PROJECT(CMake)
 IF(COMMAND CMAKE_POLICY)
   CMAKE_POLICY(SET CMP0003 NEW)

Modules/CMakeDetermineFortranCompiler.cmake

@@ -218,6 +218,10 @@ ENDIF(NOT CMAKE_Fortran_COMPILER_ID_RUN)
 
 INCLUDE(CMakeFindBinUtils)
 
+IF(MSVC_Fortran_ARCHITECTURE_ID)
+  SET(SET_MSVC_Fortran_ARCHITECTURE_ID
+    "SET(MSVC_Fortran_ARCHITECTURE_ID ${MSVC_Fortran_ARCHITECTURE_ID})")
+ENDIF()
 # configure variables set in this file for fast reload later on
 CONFIGURE_FILE(${CMAKE_ROOT}/Modules/CMakeFortranCompiler.cmake.in
   ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeFortranCompiler.cmake

Modules/CMakeFortranCompiler.cmake.in

@@ -2,6 +2,7 @@ SET(CMAKE_Fortran_COMPILER "@CMAKE_Fortran_COMPILER@")
 SET(CMAKE_Fortran_COMPILER_ARG1 "@CMAKE_Fortran_COMPILER_ARG1@")
 SET(CMAKE_Fortran_COMPILER_ID "@CMAKE_Fortran_COMPILER_ID@")
 SET(CMAKE_Fortran_PLATFORM_ID "@CMAKE_Fortran_PLATFORM_ID@")
+@SET_MSVC_Fortran_ARCHITECTURE_ID@
 SET(CMAKE_AR "@CMAKE_AR@")
 SET(CMAKE_RANLIB "@CMAKE_RANLIB@")
 SET(CMAKE_COMPILER_IS_GNUG77 @CMAKE_COMPILER_IS_GNUG77@)

Modules/CMakeFortranCompilerId.F.in

@@ -108,5 +108,14 @@
 !       SGI preprocessor which produces both the __sgi and else blocks.
 #       endif
         PRINT *, 'INFO:platform[]'
+#endif
+#if defined(_WIN32) && (defined(__INTEL_COMPILER) || defined(__ICC))
+# if defined(_M_IA64)
+        PRINT *, 'INFO:arch[IA64]'
+# elif defined(_M_X64) || defined(_M_AMD64)
+        PRINT *, 'INFO:arch[x64]'
+# elif defined(_M_IX86)
+        PRINT *, 'INFO:arch[X86]'
+# endif
 #endif
       END

Modules/CheckCCompilerFlag.cmake

@@ -25,7 +25,7 @@ INCLUDE(CheckCSourceCompiles)
 MACRO (CHECK_C_COMPILER_FLAG _FLAG _RESULT)
    SET(SAFE_CMAKE_REQUIRED_DEFINITIONS "${CMAKE_REQUIRED_DEFINITIONS}")
    SET(CMAKE_REQUIRED_DEFINITIONS "${_FLAG}")
-   CHECK_C_SOURCE_COMPILES("int main() { return 0;}" ${_RESULT}
+   CHECK_C_SOURCE_COMPILES("int main(void) { return 0; }" ${_RESULT}
      # Some compilers do not fail with a bad flag
      FAIL_REGEX "unrecognized .*option"                     # GNU
      FAIL_REGEX "ignoring unknown option"                   # MSVC

Modules/FindBLAS.cmake

@@ -40,16 +40,11 @@
 #  License text for the above reference.)
 
 get_property(_LANGUAGES_ GLOBAL PROPERTY ENABLED_LANGUAGES)
-if(NOT _LANGUAGES_ MATCHES Fortran)
+if (NOT _LANGUAGES_ MATCHES Fortran)
-  if(BLAS_FIND_REQUIRED)
+include(CheckFunctionExists)
-    message(FATAL_ERROR "FindBLAS is Fortran-only so Fortran must be enabled.")
+else ()
-  else(BLAS_FIND_REQUIRED)
-    message(STATUS "Looking for BLAS... - NOT found (Fortran not enabled)") #
-    return()
-  endif(BLAS_FIND_REQUIRED)
-endif(NOT _LANGUAGES_ MATCHES Fortran)
-
 include(CheckFortranFunctionExists)
+endif()
 
 macro(Check_Fortran_Libraries LIBRARIES _prefix _name _flags _list _threads)
 # This macro checks for the existence of the combination of fortran libraries
@@ -107,7 +102,11 @@ if(_libraries_work)
   # Test this combination of libraries.
   set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_threads})
 #  message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
-  check_fortran_function_exists(${_name} ${_prefix}${_combined_name}_WORKS)
+  if (_LANGUAGES_ MATCHES Fortran)
+    check_fortran_function_exists("${_name}" ${_prefix}${_combined_name}_WORKS)
+  else()
+    check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS)
+  endif()
   set(CMAKE_REQUIRED_LIBRARIES)
   mark_as_advanced(${_prefix}${_combined_name}_WORKS)
   set(_libraries_work ${${_prefix}${_combined_name}_WORKS})
@@ -246,13 +245,24 @@ endif (BLA_VENDOR STREQUAL "IBMESSL" OR BLA_VENDOR STREQUAL "All")
 
 #BLAS in acml library?
 if (BLA_VENDOR STREQUAL "ACML" OR BLA_VENDOR STREQUAL "All")
+ # Either acml or acml_mp should be in LD_LIBRARY_PATH but not both
  if(NOT BLAS_LIBRARIES)
   check_fortran_libraries(
   BLAS_LIBRARIES
   BLAS
   sgemm
   ""
-  "acml"
+  "acml;acml_mv"
+  ""
+  )
+ endif(NOT BLAS_LIBRARIES)
+ if(NOT BLAS_LIBRARIES)
+  check_fortran_libraries(
+  BLAS_LIBRARIES
+  BLAS
+  sgemm
+  ""
+  "acml_mp;acml_mv"
   ""
   )
  endif(NOT BLAS_LIBRARIES)
@@ -300,6 +310,9 @@ endif (BLA_VENDOR STREQUAL "Generic" OR BLA_VENDOR STREQUAL "All")
 
 #BLAS in intel mkl 10 library? (em64t 64bit)
 if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
+ if (NOT WIN32)
+  set(LM "-lm")
+ endif ()
  if (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX)
   if(BLAS_FIND_QUIETLY OR NOT BLAS_FIND_REQUIRED)
     find_package(Threads)
@@ -340,7 +353,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
       sgemm
       ""
       "mkl_blas95;mkl_intel;mkl_intel_thread;mkl_core;guide"
-      "${CMAKE_THREAD_LIBS_INIT}"
+      "${CMAKE_THREAD_LIBS_INIT};${LM}"
       )
       endif(NOT BLAS95_LIBRARIES)
     else(BLA_F95)
@@ -352,6 +365,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
       ""
       "mkl_intel;mkl_intel_thread;mkl_core;guide"
       "${CMAKE_THREAD_LIBS_INIT}"
+      "${LM}"
       )
       endif(NOT BLAS_LIBRARIES)
     endif(BLA_F95)
@@ -365,7 +379,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
       sgemm
       ""
       "mkl_blas95;mkl_intel_lp64;mkl_intel_thread;mkl_core;guide"
-      "${CMAKE_THREAD_LIBS_INIT}"
+      "${CMAKE_THREAD_LIBS_INIT};${LM}"
       )
     endif(NOT BLAS95_LIBRARIES)
    else(BLA_F95)
@@ -376,7 +390,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
       sgemm
       ""
       "mkl_intel_lp64;mkl_intel_thread;mkl_core;guide"
-      "${CMAKE_THREAD_LIBS_INIT}"
+      "${CMAKE_THREAD_LIBS_INIT};${LM}"
       )
      endif(NOT BLAS_LIBRARIES)
    endif(BLA_F95)
@@ -391,7 +405,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
     sgemm
     ""
     "mkl;guide"
-    "${CMAKE_THREAD_LIBS_INIT}"
+    "${CMAKE_THREAD_LIBS_INIT};${LM}"
     )
   endif(NOT BLAS_LIBRARIES)
   #BLAS in intel mkl library? (static, 32bit)
@@ -402,7 +416,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
     sgemm
     ""
     "mkl_ia32;guide"
-    "${CMAKE_THREAD_LIBS_INIT}"
+    "${CMAKE_THREAD_LIBS_INIT};${LM}"
     )
   endif(NOT BLAS_LIBRARIES)
   #BLAS in intel mkl library? (static, em64t 64bit)
@@ -413,7 +427,7 @@ if (BLA_VENDOR MATCHES "Intel*" OR BLA_VENDOR STREQUAL "All")
     sgemm
     ""
     "mkl_em64t;guide"
-    "${CMAKE_THREAD_LIBS_INIT}"
+    "${CMAKE_THREAD_LIBS_INIT};${LM}"
     )
   endif(NOT BLAS_LIBRARIES)
  endif (_LANGUAGES_ MATCHES C OR _LANGUAGES_ MATCHES CXX)

Modules/FindLAPACK.cmake

@@ -37,17 +37,12 @@
 #  License text for the above reference.)
 
 get_property(_LANGUAGES_ GLOBAL PROPERTY ENABLED_LANGUAGES)
-if(NOT _LANGUAGES_ MATCHES Fortran)
+if (NOT _LANGUAGES_ MATCHES Fortran)
-  if(LAPACK_FIND_REQUIRED)
+include(CheckFunctionExists)
-    message(FATAL_ERROR
+else (NOT _LANGUAGES_ MATCHES Fortran)
-      "FindLAPACK is Fortran-only so Fortran must be enabled.")
-  else(LAPACK_FIND_REQUIRED)
-    message(STATUS "Looking for LAPACK... - NOT found (Fortran not enabled)")
-    return()
-  endif(LAPACK_FIND_REQUIRED)
-endif(NOT _LANGUAGES_ MATCHES Fortran)
-
 include(CheckFortranFunctionExists)
+endif (NOT _LANGUAGES_ MATCHES Fortran)
+
 set(LAPACK_FOUND FALSE)
 set(LAPACK95_FOUND FALSE)
 
@@ -112,7 +107,11 @@ if(_libraries_work)
     set(CMAKE_REQUIRED_LIBRARIES ${_flags} ${${LIBRARIES}} ${_blas} ${_threads})
   endif(UNIX AND BLA_STATIC)
 #  message("DEBUG: CMAKE_REQUIRED_LIBRARIES = ${CMAKE_REQUIRED_LIBRARIES}")
-  check_fortran_function_exists(${_name} ${_prefix}${_combined_name}_WORKS)
+  if (NOT _LANGUAGES_ MATCHES Fortran)
+    check_function_exists("${_name}_" ${_prefix}${_combined_name}_WORKS)
+  else (NOT _LANGUAGES_ MATCHES Fortran)
+    check_fortran_function_exists(${_name} ${_prefix}${_combined_name}_WORKS)
+  endif (NOT _LANGUAGES_ MATCHES Fortran)
   set(CMAKE_REQUIRED_LIBRARIES)
   mark_as_advanced(${_prefix}${_combined_name}_WORKS)
   set(_libraries_work ${${_prefix}${_combined_name}_WORKS})
@@ -157,7 +156,18 @@ if(BLAS_FOUND)
     LAPACK
     cheev
     ""
-    "acml"
+    "acml;acml_mv"
+    ""
+    ""
+    )
+  endif(NOT LAPACK_LIBRARIES)
+  if(NOT LAPACK_LIBRARIES)
+   check_lapack_libraries(
+    LAPACK_LIBRARIES
+    LAPACK
+    cheev
+    ""
+    "acml_mp;acml_mv"
     ""
     ""
     )

Modules/FindOpenGL.cmake

@@ -123,7 +123,6 @@ ELSE (WIN32)
   ENDIF(APPLE)
 ENDIF (WIN32)
 
-SET( OPENGL_FOUND "NO" )
 IF(OPENGL_gl_LIBRARY)
 
     IF(OPENGL_xmesa_INCLUDE_DIR)
@@ -140,10 +139,7 @@ IF(OPENGL_gl_LIBRARY)
       SET( OPENGL_GLU_FOUND "NO" )
     ENDIF(OPENGL_glu_LIBRARY)
 
-    SET( OPENGL_FOUND "YES" )
-
     # This deprecated setting is for backward compatibility with CMake1.4
-
     SET (OPENGL_LIBRARY ${OPENGL_LIBRARIES})
 
 ENDIF(OPENGL_gl_LIBRARY)
@@ -151,6 +147,11 @@ ENDIF(OPENGL_gl_LIBRARY)
 # This deprecated setting is for backward compatibility with CMake1.4
 SET(OPENGL_INCLUDE_PATH ${OPENGL_INCLUDE_DIR})
 
+# handle the QUIETLY and REQUIRED arguments and set OPENGL_FOUND to TRUE if
+# all listed variables are TRUE
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(OpenGL DEFAULT_MSG OPENGL_gl_LIBRARY)
+
 MARK_AS_ADVANCED(
   OPENGL_INCLUDE_DIR
   OPENGL_xmesa_INCLUDE_DIR

Modules/Platform/CYGWIN.cmake

@@ -1,4 +1,48 @@
-SET(WIN32 1)
+if("${CMAKE_MINIMUM_REQUIRED_VERSION}" VERSION_LESS "2.8.3.20101214")
+  set(__USE_CMAKE_LEGACY_CYGWIN_WIN32 1)
+endif()
+if(NOT DEFINED WIN32)
+  set(WIN32 0)
+  if(DEFINED __USE_CMAKE_LEGACY_CYGWIN_WIN32)
+    if(NOT DEFINED CMAKE_LEGACY_CYGWIN_WIN32
+        AND DEFINED ENV{CMAKE_LEGACY_CYGWIN_WIN32})
+      set(CMAKE_LEGACY_CYGWIN_WIN32 $ENV{CMAKE_LEGACY_CYGWIN_WIN32})
+    endif()
+    if(CMAKE_LEGACY_CYGWIN_WIN32)
+      message(STATUS "Defining WIN32 under Cygwin due to CMAKE_LEGACY_CYGWIN_WIN32")
+      set(WIN32 1)
+    elseif("x${CMAKE_LEGACY_CYGWIN_WIN32}" STREQUAL "x")
+      message(WARNING "CMake no longer defines WIN32 on Cygwin!"
+        "\n"
+        "(1) If you are just trying to build this project, ignore this warning "
+        "or quiet it by setting CMAKE_LEGACY_CYGWIN_WIN32=0 in your environment or "
+        "in the CMake cache.  "
+        "If later configuration or build errors occur then this project may "
+        "have been written under the assumption that Cygwin is WIN32.  "
+        "In that case, set CMAKE_LEGACY_CYGWIN_WIN32=1 instead."
+        "\n"
+        "(2) If you are developing this project, add the line\n"
+        "  set(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required\n"
+        "at the top of your top-level CMakeLists.txt file or set the minimum "
+        "required version of CMake to 2.8.4 or higher.  "
+        "Then teach your project to build on Cygwin without WIN32.")
+    endif()
+  elseif(DEFINED CMAKE_LEGACY_CYGWIN_WIN32)
+    message(AUTHOR_WARNING "CMAKE_LEGACY_CYGWIN_WIN32 ignored because\n"
+      "  cmake_minimum_required(VERSION ${CMAKE_MINIMUM_REQUIRED_VERSION})\n"
+      "is at least 2.8.4.")
+  endif()
+endif()
+if(DEFINED __USE_CMAKE_LEGACY_CYGWIN_WIN32)
+  # Pass WIN32 legacy setting to scripts.
+  if(WIN32)
+    set(ENV{CMAKE_LEGACY_CYGWIN_WIN32} 1)
+  else()
+    set(ENV{CMAKE_LEGACY_CYGWIN_WIN32} 0)
+  endif()
+  unset(__USE_CMAKE_LEGACY_CYGWIN_WIN32)
+endif()
+
 SET(CYGWIN 1)
 
 SET(CMAKE_SHARED_LIBRARY_PREFIX "cyg")

Modules/Platform/Darwin-GNU.cmake

@@ -20,8 +20,8 @@ set(__DARWIN_COMPILER_GNU 1)
 
 macro(__darwin_compiler_gnu lang)
   # GNU does not have -shared on OS X
-  set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-dynamiclib -headerpad_max_install_names")
+  set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names")
-  set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS "-bundle -headerpad_max_install_names")
+  set(CMAKE_SHARED_MODULE_CREATE_${lang}_FLAGS "-bundle -Wl,-headerpad_max_install_names")
 endmacro()
 
 macro(cmake_gnu_has_isysroot lang)

Modules/Platform/Darwin-icc.cmake

@@ -33,11 +33,11 @@ SET(CMAKE_SHARED_MODULE_PREFIX "lib")
 SET(CMAKE_SHARED_MODULE_SUFFIX ".so")
 SET(CMAKE_MODULE_EXISTS 1)
 SET(CMAKE_DL_LIBS "")
-SET(CMAKE_C_LINK_FLAGS "-headerpad_max_install_names")
+SET(CMAKE_C_LINK_FLAGS "-Wl,-headerpad_max_install_names")
-SET(CMAKE_CXX_LINK_FLAGS "-headerpad_max_install_names")
+SET(CMAKE_CXX_LINK_FLAGS "-Wl,-headerpad_max_install_names")
 SET(CMAKE_PLATFORM_HAS_INSTALLNAME 1)
-SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -headerpad_max_install_names")
+SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names")
-SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -headerpad_max_install_names")
+SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -Wl,-headerpad_max_install_names")
 SET(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")
 
 

Modules/Platform/Windows-Intel-C.cmake

@@ -0,0 +1,2 @@
+include(Platform/Windows-Intel)
+__windows_compiler_intel(C)

Modules/Platform/Windows-Intel-CXX.cmake

@@ -0,0 +1,4 @@
+include(Platform/Windows-Intel)
+set(_COMPILE_CXX " /TP")
+set(_FLAGS_CXX " /GX /GR")
+__windows_compiler_intel(CXX)

Modules/Platform/Windows-Intel-Fortran.cmake

@@ -0,0 +1,11 @@
+include(Platform/Windows-Intel)
+set(CMAKE_BUILD_TYPE_INIT Debug)
+set(_COMPILE_Fortran " /fpp")
+set(CMAKE_Fortran_MODDIR_FLAG "-module:")
+set(CMAKE_Fortran_STANDARD_LIBRARIES_INIT "user32.lib")
+__windows_compiler_intel(Fortran)
+SET (CMAKE_Fortran_FLAGS_INIT "/W1 /nologo /fpp /libs:dll /threads")
+SET (CMAKE_Fortran_FLAGS_DEBUG_INIT "/debug:full /dbglibs")
+SET (CMAKE_Fortran_FLAGS_MINSIZEREL_INIT "/O2 /D NDEBUG")
+SET (CMAKE_Fortran_FLAGS_RELEASE_INIT "/O1 /D NDEBUG")
+SET (CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT "/O1 /debug:full /D NDEBUG")

Modules/Platform/Windows-Intel.cmake

@@ -1,3 +1,62 @@
+
+#=============================================================================
+# Copyright 2002-2010 Kitware, Inc.
+#
+# 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.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# This module is shared by multiple languages; use include blocker.
+if(__WINDOWS_INTEL)
+  return()
+endif()
+set(__WINDOWS_INTEL 1)
+
+SET(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:")
+SET(CMAKE_LINK_LIBRARY_FLAG "")
+SET(WIN32 1)
+IF(CMAKE_VERBOSE_MAKEFILE)
+  SET(CMAKE_CL_NOLOGO)
+ELSE(CMAKE_VERBOSE_MAKEFILE)
+  SET(CMAKE_CL_NOLOGO "/nologo")
+ENDIF(CMAKE_VERBOSE_MAKEFILE)
+SET(CMAKE_COMPILE_RESOURCE "rc <FLAGS> /fo<OBJECT> <SOURCE>")
+SET(CMAKE_CREATE_WIN32_EXE /subsystem:windows)
+SET(CMAKE_CREATE_CONSOLE_EXE /subsystem:console)
+
+# default to Debug builds
+#SET(CMAKE_BUILD_TYPE_INIT Debug)
+SET(CMAKE_BUILD_TYPE_INIT Release)
+
+SET(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib")
+SET(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}")
+
+# executable linker flags
+SET (CMAKE_LINK_DEF_FILE_FLAG "/DEF:")
+IF(MSVC_C_ARCHITECTURE_ID)
+  SET(_MACHINE_ARCH_FLAG "/machine:${MSVC_C_ARCHITECTURE_ID}")
+ELSEIF(MSVC_CXX_ARCHITECTURE_ID)
+  SET(_MACHINE_ARCH_FLAG "/machine:${MSVC_CXX_ARCHITECTURE_ID}")
+ELSEIF(MSVC_Fortran_ARCHITECTURE_ID)
+  SET(_MACHINE_ARCH_FLAG "/machine:${MSVC_Fortran_ARCHITECTURE_ID}")
+ENDIF()
+SET (CMAKE_EXE_LINKER_FLAGS_INIT "/STACK:10000000 /INCREMENTAL:YES ${_MACHINE_ARCH_FLAG}")
+SET (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug")
+SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug")
+
+SET (CMAKE_SHARED_LINKER_FLAGS_INIT ${CMAKE_EXE_LINKER_FLAGS_INIT})
+SET (CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
+SET (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
+SET (CMAKE_MODULE_LINKER_FLAGS_INIT ${CMAKE_SHARED_LINKER_FLAGS_INIT})
+SET (CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT})
+SET (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT})
+
 INCLUDE("${CMAKE_PLATFORM_ROOT_BIN}/CMakeIntelInformation.cmake" OPTIONAL)
 
 IF(NOT _INTEL_XILINK_TEST_RUN)
@@ -15,3 +74,31 @@ SET(_INTEL_COMPILER_SUPPORTS_MANIFEST ${_INTEL_COMPILER_SUPPORTS_MANIFEST})
 ")
   ENDIF(NOT  EXISTS "${CMAKE_PLATFORM_ROOT_BIN}/CMakeIntelInformation.cmake")
 ENDIF(NOT _INTEL_XILINK_TEST_RUN)
+
+macro(__windows_compiler_intel lang)
+  set(CMAKE_${lang}_COMPILE_OBJECT
+    "<CMAKE_${lang}_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} /Fo<OBJECT> <DEFINES> <FLAGS> -c <SOURCE>${CMAKE_END_TEMP_FILE}")
+  set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE
+    "<CMAKE_${lang}_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO}${_COMPILE_${lang}} <DEFINES> <FLAGS> -E <SOURCE>${CMAKE_END_TEMP_FILE}")
+  set(CMAKE_${lang}_USE_RESPONSE_FILE_FOR_OBJECTS 1)
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY  "lib ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
+  set(CMAKE_${lang}_CREATE_SHARED_LIBRARY
+    "xilink ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE}  /out:<TARGET> /implib:<TARGET_IMPLIB> /pdb:<TARGET_PDB> /dll  <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES> ${CMAKE_END_TEMP_FILE}")
+  set(CMAKE_${lang}_CREATE_SHARED_MODULE "${CMAKE_${lang}_CREATE_SHARED_LIBRARY}")
+  set(CMAKE_${lang}_LINK_EXECUTABLE
+    "<CMAKE_${lang}_COMPILER> ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE} <FLAGS> <OBJECTS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
+  set(CMAKE_${lang}_FLAGS_INIT "/DWIN32 /D_WINDOWS /W3 /Zm1000${_FLAGS_${lang}}")
+  set(CMAKE_${lang}_FLAGS_DEBUG_INIT "/D_DEBUG /MDd /Zi /Od /GZ")
+  set(CMAKE_${lang}_FLAGS_MINSIZEREL_INIT "/DNDEBUG /MD /O1")
+  set(CMAKE_${lang}_FLAGS_RELEASE_INIT "/DNDEBUG /MD /O2")
+  set(CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT "/DNDEBUG /MD /Zi /O2")
+
+  if(_INTEL_COMPILER_SUPPORTS_MANIFEST)
+    SET(CMAKE_${lang}_LINK_EXECUTABLE
+      "<CMAKE_COMMAND> -E vs_link_exe ${CMAKE_${lang}_LINK_EXECUTABLE}")
+    SET(CMAKE_${lang}_CREATE_SHARED_LIBRARY
+      "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_${lang}_CREATE_SHARED_LIBRARY}")
+    SET(CMAKE_${lang}_CREATE_SHARED_MODULE
+      "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_${lang}_CREATE_SHARED_MODULE}")
+  endif()
+endmacro()

Modules/Platform/Windows-g++.cmake

@@ -1 +0,0 @@
-INCLUDE(${CMAKE_ROOT}/Modules/Platform/Windows-gcc.cmake)

Modules/Platform/Windows-icl.cmake

@@ -1,109 +0,0 @@
-SET(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:")
-SET(CMAKE_LINK_LIBRARY_FLAG "")
-SET(WIN32 1)
-IF(CMAKE_VERBOSE_MAKEFILE)
-  SET(CMAKE_CL_NOLOGO)
-ELSE(CMAKE_VERBOSE_MAKEFILE)
-  SET(CMAKE_CL_NOLOGO "/nologo")
-ENDIF(CMAKE_VERBOSE_MAKEFILE)
-
-SET(CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS 1)
-SET(CMAKE_CXX_USE_RESPONSE_FILE_FOR_OBJECTS 1)
-
-# create a shared C++ library
-SET(CMAKE_CXX_CREATE_SHARED_LIBRARY 
- "xilink ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE}  /out:<TARGET> /implib:<TARGET_IMPLIB> /pdb:<TARGET_PDB> /dll  <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES> ${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_CXX_CREATE_SHARED_MODULE ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
-
-# create a C shared library
-SET(CMAKE_C_CREATE_SHARED_LIBRARY ${CMAKE_CXX_CREATE_SHARED_LIBRARY})
-
-# create a C shared module just copy the shared library rule
-SET(CMAKE_C_CREATE_SHARED_MODULE ${CMAKE_C_CREATE_SHARED_LIBRARY})
-
-
-# create a C++ static library
-SET(CMAKE_CXX_CREATE_STATIC_LIBRARY  "lib ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
-
-# create a C static library
-SET(CMAKE_C_CREATE_STATIC_LIBRARY ${CMAKE_CXX_CREATE_STATIC_LIBRARY})
-
-# compile a C++ file into an object file
-SET(CMAKE_CXX_COMPILE_OBJECT
-    "<CMAKE_CXX_COMPILER>  ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} /TP -DWIN32 /Fo<OBJECT> <DEFINES> <FLAGS> -c <SOURCE>${CMAKE_END_TEMP_FILE}")
-
-# compile a C file into an object file
-SET(CMAKE_C_COMPILE_OBJECT
-    "<CMAKE_C_COMPILER> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} -DWIN32 /Fo<OBJECT> <DEFINES> <FLAGS> -c <SOURCE>${CMAKE_END_TEMP_FILE}")
-
-
-SET(CMAKE_C_LINK_EXECUTABLE
-    "<CMAKE_C_COMPILER> ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE} <FLAGS> <OBJECTS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> <CMAKE_C_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_C_CREATE_PREPROCESSED_SOURCE
-    "<CMAKE_C_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} <FLAGS> <DEFINES> -E <SOURCE>${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_CXX_CREATE_PREPROCESSED_SOURCE
-    "<CMAKE_CXX_COMPILER> > <PREPROCESSED_SOURCE> ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} <FLAGS> <DEFINES> /TP -E <SOURCE>${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_COMPILE_RESOURCE "rc <FLAGS> /fo<OBJECT> <SOURCE>")
-
-SET(CMAKE_CXX_LINK_EXECUTABLE
-  "<CMAKE_CXX_COMPILER> ${CMAKE_CL_NOLOGO} ${CMAKE_START_TEMP_FILE} <FLAGS> <OBJECTS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_CREATE_WIN32_EXE /subsystem:windows)
-SET(CMAKE_CREATE_CONSOLE_EXE /subsystem:console)
-
-# default to Debug builds
-#SET(CMAKE_BUILD_TYPE_INIT Debug)
-SET(CMAKE_BUILD_TYPE_INIT Release)
-SET (CMAKE_CXX_FLAGS_INIT "/W3 /Zm1000 /GX /GR")
-SET (CMAKE_CXX_FLAGS_DEBUG_INIT "/MDd /Zi /Od /GZ")
-SET (CMAKE_CXX_FLAGS_MINSIZEREL_INIT "/MD /O1")
-SET (CMAKE_CXX_FLAGS_RELEASE_INIT "/MD /O2")
-SET (CMAKE_CXX_FLAGS_RELWITHDEBINFO_INIT "/MD /Zi /O2")
-SET (CMAKE_C_FLAGS_INIT "/W3 /Zm1000")
-SET (CMAKE_C_FLAGS_DEBUG_INIT "/MDd /Zi /Od /GZ")
-SET (CMAKE_C_FLAGS_MINSIZEREL_INIT "/MD /O1")
-SET (CMAKE_C_FLAGS_RELEASE_INIT "/MD /O2")
-SET (CMAKE_C_FLAGS_RELWITHDEBINFO_INIT "/MD /Zi /O2")
-
-
-SET(CMAKE_C_STANDARD_LIBRARIES_INIT "kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib")
-SET(CMAKE_CXX_STANDARD_LIBRARIES_INIT "${CMAKE_C_STANDARD_LIBRARIES_INIT}")
-
-# executable linker flags
-SET (CMAKE_LINK_DEF_FILE_FLAG "/DEF:")
-SET(_MACHINE_ARCH_FLAG ${MSVC_C_ARCHITECTURE_ID})
-IF(NOT _MACHINE_ARCH_FLAG)
-  SET(_MACHINE_ARCH_FLAG ${MSVC_CXX_ARCHITECTURE_ID})
-ENDIF(NOT _MACHINE_ARCH_FLAG)
-SET (CMAKE_EXE_LINKER_FLAGS_INIT "/STACK:10000000 /INCREMENTAL:YES /machine:${_MACHINE_ARCH_FLAG}")
-SET (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug")
-SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug")
-
-SET (CMAKE_SHARED_LINKER_FLAGS_INIT ${CMAKE_EXE_LINKER_FLAGS_INIT})
-SET (CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
-SET (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
-SET (CMAKE_MODULE_LINKER_FLAGS_INIT ${CMAKE_SHARED_LINKER_FLAGS_INIT})
-SET (CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT})
-SET (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT})
-
-
-INCLUDE(Platform/Windows-Intel)
-
-IF(_INTEL_COMPILER_SUPPORTS_MANIFEST)
-  SET(CMAKE_C_LINK_EXECUTABLE
-    "<CMAKE_COMMAND> -E vs_link_exe ${CMAKE_C_LINK_EXECUTABLE}")
-  SET(CMAKE_C_CREATE_SHARED_LIBRARY
-    "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_C_CREATE_SHARED_LIBRARY}")
-  SET(CMAKE_C_CREATE_SHARED_MODULE
-    "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_C_CREATE_SHARED_MODULE}")
-  SET(CMAKE_CXX_LINK_EXECUTABLE
-    "<CMAKE_COMMAND> -E vs_link_exe ${CMAKE_CXX_LINK_EXECUTABLE}")
-  SET(CMAKE_CXX_CREATE_SHARED_LIBRARY
-    "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_CXX_CREATE_SHARED_LIBRARY}")
-  SET(CMAKE_CXX_CREATE_SHARED_MODULE
-    "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_CXX_CREATE_SHARED_MODULE}")
-ENDIF(_INTEL_COMPILER_SUPPORTS_MANIFEST)

Modules/Platform/Windows-ifort.cmake

@@ -1,80 +0,0 @@
-SET(CMAKE_LIBRARY_PATH_FLAG "-LIBPATH:")
-SET(CMAKE_LINK_LIBRARY_FLAG "")
-SET(WIN32 1)
-IF(CMAKE_VERBOSE_MAKEFILE)
-  SET(CMAKE_CL_NOLOGO)
-ELSE(CMAKE_VERBOSE_MAKEFILE)
-  SET(CMAKE_CL_NOLOGO "/nologo")
-ENDIF(CMAKE_VERBOSE_MAKEFILE)
-
-SET(CMAKE_Fortran_MODDIR_FLAG "-module:")
-
-SET(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS 1)
-
-SET(CMAKE_Fortran_CREATE_SHARED_LIBRARY 
- "link ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE}  /out:<TARGET> /implib:<TARGET_IMPLIB> /dll  <LINK_FLAGS> <LINK_LIBRARIES> ${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_Fortran_CREATE_SHARED_MODULE ${CMAKE_Fortran_CREATE_SHARED_LIBRARY})
-
-# create a C++ static library
-SET(CMAKE_Fortran_CREATE_STATIC_LIBRARY  "lib ${CMAKE_CL_NOLOGO} <LINK_FLAGS> /out:<TARGET> <OBJECTS> ")
-
-# compile a C++ file into an object file
-SET(CMAKE_Fortran_COMPILE_OBJECT
-    "<CMAKE_Fortran_COMPILER>  ${CMAKE_START_TEMP_FILE} ${CMAKE_CL_NOLOGO} /fpp /Fo<OBJECT> <DEFINES> <FLAGS> -c <SOURCE>${CMAKE_END_TEMP_FILE}")
-
-SET(CMAKE_COMPILE_RESOURCE "rc <FLAGS> /fo<OBJECT> <SOURCE>")
-
-SET(CMAKE_Fortran_LINK_EXECUTABLE
-  "<CMAKE_Fortran_COMPILER> ${CMAKE_CL_NOLOGO} <OBJECTS> ${CMAKE_START_TEMP_FILE} <FLAGS> /Fe<TARGET> -link /implib:<TARGET_IMPLIB> <CMAKE_Fortran_LINK_FLAGS> <LINK_FLAGS> <LINK_LIBRARIES>${CMAKE_END_TEMP_FILE}")
-
-INCLUDE(Platform/Windows-Intel)
-
-IF(_INTEL_COMPILER_SUPPORTS_MANIFEST)
-    SET(CMAKE_Fortran_LINK_EXECUTABLE
-      "<CMAKE_COMMAND> -E vs_link_exe ${CMAKE_Fortran_LINK_EXECUTABLE}")
-  SET(CMAKE_Fortran_CREATE_SHARED_LIBRARY
-    "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_Fortran_CREATE_SHARED_LIBRARY}")
-  SET(CMAKE_Fortran_CREATE_SHARED_MODULE
-    "<CMAKE_COMMAND> -E vs_link_dll ${CMAKE_Fortran_CREATE_SHARED_MODULE}")
-ENDIF(_INTEL_COMPILER_SUPPORTS_MANIFEST)
-
-SET(CMAKE_CREATE_WIN32_EXE /subsystem:windows)
-SET(CMAKE_CREATE_CONSOLE_EXE /subsystem:console)
-
-IF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
-   SET (CMAKE_NO_BUILD_TYPE 1)
-ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 6")
-IF(CMAKE_GENERATOR MATCHES "Visual Studio 7" OR CMAKE_GENERATOR MATCHES "Visual Studio 8")
-  SET (CMAKE_NO_BUILD_TYPE 1)
-  SET (CMAKE_CONFIGURATION_TYPES "Debug;Release;MinSizeRel;RelWithDebInfo" CACHE STRING 
-     "Semicolon separated list of supported configuration types, only supports Debug, Release, MinSizeRel, and RelWithDebInfo, anything else will be ignored.")
-ENDIF(CMAKE_GENERATOR MATCHES "Visual Studio 7" OR CMAKE_GENERATOR MATCHES "Visual Studio 8")
-# does the compiler support pdbtype and is it the newer compiler
-
-SET(CMAKE_BUILD_TYPE_INIT Debug)
-SET (CMAKE_Fortran_FLAGS_INIT "/W1 /nologo /fpp /libs:dll /threads")
-SET (CMAKE_Fortran_FLAGS_DEBUG_INIT "/debug:full /dbglibs")
-SET (CMAKE_Fortran_FLAGS_MINSIZEREL_INIT "/O2 /D NDEBUG")
-SET (CMAKE_Fortran_FLAGS_RELEASE_INIT "/O1 /D NDEBUG")
-SET (CMAKE_Fortran_FLAGS_RELWITHDEBINFO_INIT "/O1 /debug:full /D NDEBUG")
-
-SET (CMAKE_Fortran_STANDARD_LIBRARIES_INIT "user32.lib")
-
-# executable linker flags
-SET (CMAKE_LINK_DEF_FILE_FLAG "/DEF:")
-SET (CMAKE_EXE_LINKER_FLAGS_INIT " /INCREMENTAL:YES")
-IF (CMAKE_COMPILER_SUPPORTS_PDBTYPE)
-  SET (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug /pdbtype:sept")
-  SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug /pdbtype:sept")
-ELSE (CMAKE_COMPILER_SUPPORTS_PDBTYPE)
-  SET (CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT "/debug")
-  SET (CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT "/debug")
-ENDIF (CMAKE_COMPILER_SUPPORTS_PDBTYPE)
-
-SET (CMAKE_SHARED_LINKER_FLAGS_INIT ${CMAKE_EXE_LINKER_FLAGS_INIT})
-SET (CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
-SET (CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_DEBUG_INIT})
-SET (CMAKE_MODULE_LINKER_FLAGS_INIT ${CMAKE_SHARED_LINKER_FLAGS_INIT})
-SET (CMAKE_MODULE_LINKER_FLAGS_DEBUG_INIT ${CMAKE_SHARED_LINKER_FLAGS_DEBUG_INIT})
-SET (CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO_INIT ${CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO_INIT})

Modules/Qt4Macros.cmake

@@ -254,7 +254,15 @@ MACRO(QT4_GENERATE_DBUS_INTERFACE _header) # _customName OPTIONS -some -options
   GET_FILENAME_COMPONENT(_basename ${_header} NAME_WE)
 
   IF (_customName)
-    SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
+    if (IS_ABSOLUTE ${_customName})
+      get_filename_component(_containingDir ${_customName} PATH)
+      if (NOT EXISTS ${_containingDir})
+        file(MAKE_DIRECTORY "${_containingDir}")
+      endif()
+      SET(_target ${_customName})
+    else()
+      SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_customName})
+    endif()
   ELSE (_customName)
     SET(_target ${CMAKE_CURRENT_BINARY_DIR}/${_basename}.xml)
   ENDIF (_customName)

Modules/SystemInformation.cmake

@@ -1,6 +1,6 @@
 
 #=============================================================================
-# Copyright 2007-2009 Kitware, Inc.
+# Copyright 2007-2010 Kitware, Inc.
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -12,6 +12,7 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
+CMAKE_MINIMUM_REQUIRED(VERSION ${CMAKE_VERSION})
 PROJECT(DumpInformation)
 
 # first get the standard information for th platform

Source/CMakeLists.txt

@@ -131,6 +131,8 @@ SET(SRCS
   cmComputeTargetDepends.cxx
   cmCustomCommand.cxx
   cmCustomCommand.h
+  cmCustomCommandGenerator.cxx
+  cmCustomCommandGenerator.h
   cmDefinitions.cxx
   cmDefinitions.h
   cmDepends.cxx
@@ -156,6 +158,7 @@ SET(SRCS
   cmDocumentationFormatterText.cxx
   cmDocumentationFormatterUsage.cxx
   cmDocumentationSection.cxx
+  cmDocumentGeneratorExpressions.h
   cmDocumentVariables.cxx
   cmDynamicLoader.cxx
   cmDynamicLoader.h

Source/CPack/cmCPackNSISGenerator.cxx

@@ -337,6 +337,7 @@ int cmCPackNSISGenerator::InitializeInternal()
     << std::endl);
   std::vector<std::string> path;
   std::string nsisPath;
+  bool gotRegValue = true;
 
 #ifdef _WIN32
   if ( !cmsys::SystemTools::ReadRegistryValue(
@@ -346,24 +347,37 @@ int cmCPackNSISGenerator::InitializeInternal()
     if ( !cmsys::SystemTools::ReadRegistryValue(
         "HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS", nsisPath) )
       {
-      cmCPackLogger
+      gotRegValue = false;
-        (cmCPackLog::LOG_ERROR,
-         "Cannot find NSIS registry value. This is usually caused by NSIS "
-         "not being installed. Please install NSIS from "
-         "http://nsis.sourceforge.net"
-         << std::endl);
-      return 0;
       }
     }
-  path.push_back(nsisPath);
+
+  if (gotRegValue)
+    {
+    path.push_back(nsisPath);
+    }
 #endif
+
   nsisPath = cmSystemTools::FindProgram("makensis", path, false);
+
   if ( nsisPath.empty() )
     {
-    cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find NSIS compiler"
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+      "Cannot find NSIS compiler makensis: likely it is not installed, "
+      "or not in your PATH"
       << std::endl);
+
+    if (!gotRegValue)
+      {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+         "Could not read NSIS registry value. This is usually caused by "
+         "NSIS not being installed. Please install NSIS from "
+         "http://nsis.sourceforge.net"
+         << std::endl);
+      }
+
     return 0;
     }
+
   std::string nsisCmd = "\"" + nsisPath + "\" " NSIS_OPT "VERSION";
   cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Test NSIS version: "
     << nsisCmd.c_str() << std::endl);

Source/CTest/cmCTestGIT.cxx

@@ -503,28 +503,15 @@ private:
       this->ParsePerson(this->Line.c_str()+7, author);
       this->Rev.Author = author.Name;
       this->Rev.EMail = author.EMail;
-
+      this->Rev.Date = this->FormatDateTime(author);
-      // Convert the time to a human-readable format that is also easy
+      }
-      // to machine-parse: "CCYY-MM-DD hh:mm:ss".
+    else if(strncmp(this->Line.c_str(), "committer ", 10) == 0)
-      time_t seconds = static_cast<time_t>(author.Time);
+      {
-      struct tm* t = gmtime(&seconds);
+      Person committer;
-      char dt[1024];
+      this->ParsePerson(this->Line.c_str()+10, committer);
-      sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d",
+      this->Rev.Committer = committer.Name;
-              t->tm_year+1900, t->tm_mon+1, t->tm_mday,
+      this->Rev.CommitterEMail = committer.EMail;
-              t->tm_hour, t->tm_min, t->tm_sec);
+      this->Rev.CommitDate = this->FormatDateTime(committer);
-      this->Rev.Date = dt;
-
-      // Add the time-zone field "+zone" or "-zone".
-      char tz[32];
-      if(author.TimeZone >= 0)
-        {
-        sprintf(tz, " +%04ld", author.TimeZone);
-        }
-      else
-        {
-        sprintf(tz, " -%04ld", -author.TimeZone);
-        }
-      this->Rev.Date += tz;
       }
     }
 
@@ -537,6 +524,32 @@ private:
       }
     this->Rev.Log += "\n";
     }
+
+  std::string FormatDateTime(Person const& person)
+    {
+    // Convert the time to a human-readable format that is also easy
+    // to machine-parse: "CCYY-MM-DD hh:mm:ss".
+    time_t seconds = static_cast<time_t>(person.Time);
+    struct tm* t = gmtime(&seconds);
+    char dt[1024];
+    sprintf(dt, "%04d-%02d-%02d %02d:%02d:%02d",
+            t->tm_year+1900, t->tm_mon+1, t->tm_mday,
+            t->tm_hour, t->tm_min, t->tm_sec);
+    std::string out = dt;
+
+    // Add the time-zone field "+zone" or "-zone".
+    char tz[32];
+    if(person.TimeZone >= 0)
+      {
+      sprintf(tz, " +%04ld", person.TimeZone);
+      }
+    else
+      {
+      sprintf(tz, " -%04ld", -person.TimeZone);
+      }
+    out += tz;
+    return out;
+    }
 };
 
 char const cmCTestGIT::CommitParser::SectionSep[SectionCount] =

Source/CTest/cmCTestMultiProcessHandler.cxx

@@ -653,32 +653,37 @@ bool cmCTestMultiProcessHandler::CheckCycles()
       it != this->Tests.end(); ++it)
     {
     //DFS from each element to itself
+    int root = it->first;
+    std::set<int> visited;
     std::stack<int> s;
-    std::vector<int> visited;
+    s.push(root);
-
-    s.push(it->first);
-
     while(!s.empty())
       {
       int test = s.top();
       s.pop();
-
+      if(visited.insert(test).second)
-      for(TestSet::iterator d = this->Tests[test].begin();
-          d != this->Tests[test].end(); ++d)
         {
-        if(std::find(visited.begin(), visited.end(), *d) != visited.end())
+        for(TestSet::iterator d = this->Tests[test].begin();
+            d != this->Tests[test].end(); ++d)
           {
-          //cycle exists
+          if(*d == root)
-          cmCTestLog(this->CTest, ERROR_MESSAGE, "Error: a cycle exists in "
+            {
-            "the test dependency graph for the test \""
+            //cycle exists
-            << this->Properties[it->first]->Name << "\"." << std::endl
+            cmCTestLog(this->CTest, ERROR_MESSAGE,
-            << "Please fix the cycle and run ctest again." << std::endl);
+                       "Error: a cycle exists in the test dependency graph "
-          return false;
+                       "for the test \"" << this->Properties[root]->Name <<
+                       "\".\nPlease fix the cycle and run ctest again.\n");
+            return false;
+            }
+          else
+            {
+            s.push(*d);
+            }
           }
-        s.push(*d);
         }
-      visited.push_back(test);
       }
     }
+  cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+             "Checking test dependency graph end" << std::endl);
   return true;
 }

Source/CTest/cmCTestRunTest.cxx

@@ -455,7 +455,8 @@ bool cmCTestRunTest::StartTest(size_t total)
     {
     return false;
     }
-  return this->ForkProcess(timeout, &this->TestProperties->Environment);
+  return this->ForkProcess(timeout, this->TestProperties->ExplicitTimeout,
+                           &this->TestProperties->Environment);
 }
 
 //----------------------------------------------------------------------
@@ -598,7 +599,7 @@ double cmCTestRunTest::ResolveTimeout()
 }
 
 //----------------------------------------------------------------------
-bool cmCTestRunTest::ForkProcess(double testTimeOut,
+bool cmCTestRunTest::ForkProcess(double testTimeOut, bool explicitTimeout,
                      std::vector<std::string>* environment)
 {
   this->TestProcess = new cmProcess;
@@ -619,12 +620,16 @@ bool cmCTestRunTest::ForkProcess(double testTimeOut,
     {
     timeout = testTimeOut;
     }
-
   // always have at least 1 second if we got to here
   if (timeout <= 0)
     {
     timeout = 1;
     }
+  // handle timeout explicitly set to 0
+  if (testTimeOut == 0 && explicitTimeout)
+    {
+    timeout = 0;
+    }
   cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, this->Index << ": "
              << "Test timeout computed to be: " << timeout << "\n");
 

Source/CTest/cmCTestRunTest.h

@@ -63,8 +63,8 @@ private:
   void ExeNotFound(std::string exe);
   // Figures out a final timeout which is min(STOP_TIME, NOW+TIMEOUT)
   double ResolveTimeout();
-  bool ForkProcess(double testTimeOut,
+  bool ForkProcess(double testTimeOut, bool explicitTimeout,
-                     std::vector<std::string>* environment);
+                   std::vector<std::string>* environment);
   void WriteLogOutputTop(size_t completed, size_t total);
   //Run post processing of the process output for MemCheck
   void MemCheckPostProcess();

Source/CTest/cmCTestTestHandler.cxx

@@ -438,6 +438,8 @@ void cmCTestTestHandler::Initialize()
 
   this->TestsToRun.clear();
 
+  this->UseIncludeLabelRegExpFlag = false;
+  this->UseExcludeLabelRegExpFlag = false;
   this->UseIncludeRegExpFlag = false;
   this->UseExcludeRegExpFlag = false;
   this->UseExcludeRegExpFirst = false;
@@ -2120,6 +2122,7 @@ bool cmCTestTestHandler::SetTestsProperties(
           if ( key == "TIMEOUT" )
             {
             rtit->Timeout = atof(val.c_str());
+            rtit->ExplicitTimeout = true;
             }
           if ( key == "COST" )
             {
@@ -2190,7 +2193,6 @@ bool cmCTestTestHandler::SetTestsProperties(
               {
               rtit->Labels.push_back(*crit);
               }
-            
             }
           if ( key == "MEASUREMENT" )
             {
@@ -2219,6 +2221,10 @@ bool cmCTestTestHandler::SetTestsProperties(
                   std::string(crit->c_str())));
               }
             }
+          if ( key == "WORKING_DIRECTORY" )
+            {
+            rtit->Directory = val;
+            }
           }
         }
       }
@@ -2290,6 +2296,7 @@ bool cmCTestTestHandler::AddTest(const std::vector<std::string>& args)
   test.WillFail = false;
   test.RunSerial = false;
   test.Timeout = 0;
+  test.ExplicitTimeout = false;
   test.Cost = 0;
   test.Processors = 1;
   test.PreviousRuns = 0;

Source/CTest/cmCTestTestHandler.h

@@ -99,6 +99,7 @@ public:
     int PreviousRuns;
     bool RunSerial;
     double Timeout;
+    bool ExplicitTimeout;
     int Index;
     //Requested number of process slots
     int Processors;

Source/CTest/cmCTestVC.cxx

@@ -228,6 +228,11 @@ void cmCTestVC::WriteXMLEntry(std::ostream& xml,
       << "\t\t\t<CheckinDate>" << cmXMLSafe(rev.Date) << "</CheckinDate>\n"
       << "\t\t\t<Author>" << cmXMLSafe(rev.Author) << "</Author>\n"
       << "\t\t\t<Email>" << cmXMLSafe(rev.EMail) << "</Email>\n"
+      << "\t\t\t<Committer>" << cmXMLSafe(rev.Committer) << "</Committer>\n"
+      << "\t\t\t<CommitterEmail>" << cmXMLSafe(rev.CommitterEMail)
+      << "</CommitterEmail>\n"
+      << "\t\t\t<CommitDate>" << cmXMLSafe(rev.CommitDate)
+      << "</CommitDate>\n"
       << "\t\t\t<Log>" << cmXMLSafe(rev.Log) << "</Log>\n"
       << "\t\t\t<Revision>" << cmXMLSafe(rev.Rev) << "</Revision>\n"
       << "\t\t\t<PriorRevision>" << cmXMLSafe(prior) << "</PriorRevision>\n"

Source/CTest/cmCTestVC.h

@@ -74,6 +74,9 @@ protected:
     std::string Date;
     std::string Author;
     std::string EMail;
+    std::string Committer;
+    std::string CommitterEMail;
+    std::string CommitDate;
     std::string Log;
   };
 

Source/QtDialog/CMakeSetupDialog.cxx

@@ -55,7 +55,7 @@ void QCMakeThread::run()
 }
 
 CMakeSetupDialog::CMakeSetupDialog()
-  : ExitAfterGenerate(true), CacheModified(false), CurrentState(Interrupting)
+  : ExitAfterGenerate(true), CacheModified(false), ConfigureNeeded(true), CurrentState(Interrupting)
 {
   QString title = QString(tr("CMake %1"));
   title = title.arg(cmVersion::GetCMakeVersion());
@@ -167,6 +167,9 @@ CMakeSetupDialog::CMakeSetupDialog()
   this->CMakeThread->start();
 
   this->enterState(ReadyConfigure);
+
+  ProgressOffset = 0.0;
+  ProgressFactor = 1.0;
 }
 
 void CMakeSetupDialog::initialize()
@@ -179,12 +182,11 @@ void CMakeSetupDialog::initialize()
 
   QObject::connect(this->ConfigureButton, SIGNAL(clicked(bool)),
                    this, SLOT(doConfigure()));
-  QObject::connect(this->CMakeThread->cmakeInstance(),
+
-                   SIGNAL(configureDone(int)),
+  QObject::connect(this->CMakeThread->cmakeInstance(), SIGNAL(configureDone(int)),
-                   this, SLOT(finishConfigure(int)));
+                   this, SLOT(exitLoop(int)));
-  QObject::connect(this->CMakeThread->cmakeInstance(),
+  QObject::connect(this->CMakeThread->cmakeInstance(), SIGNAL(generateDone(int)),
-                   SIGNAL(generateDone(int)),
+                   this, SLOT(exitLoop(int)));
-                   this, SLOT(finishGenerate(int)));
 
   QObject::connect(this->GenerateButton, SIGNAL(clicked(bool)),
                    this, SLOT(doGenerate()));
@@ -270,15 +272,8 @@ CMakeSetupDialog::~CMakeSetupDialog()
   this->CMakeThread->wait(2000);
 }
 
-void CMakeSetupDialog::doConfigure()
+bool CMakeSetupDialog::prepareConfigure()
 {
-  if(this->CurrentState == Configuring)
-    {
-    // stop configure
-    doInterrupt();
-    return;
-    }
-
   // make sure build directory exists
   QString bindir = this->CMakeThread->cmakeInstance()->binaryDirectory();
   QDir dir(bindir);
@@ -295,7 +290,7 @@ void CMakeSetupDialog::doConfigure()
                                    QMessageBox::Yes | QMessageBox::No);
     if(btn == QMessageBox::No)
       {
-      return;
+      return false;
       }
     if(!dir.mkpath("."))
       {
@@ -303,7 +298,7 @@ void CMakeSetupDialog::doConfigure()
         QString(tr("Failed to create directory %1")).arg(dir.path()),
         QMessageBox::Ok);
 
-      return;
+      return false;
       }
     }
 
@@ -312,27 +307,45 @@ void CMakeSetupDialog::doConfigure()
     {
     if(!this->setupFirstConfigure())
       {
-      return;
+      return false;
       }
     }
 
   // remember path
   this->addBinaryPath(dir.absolutePath());
 
-  this->enterState(Configuring);
+  return true;
-
-  this->CacheValues->selectionModel()->clear();
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "setProperties", Qt::QueuedConnection,
-    Q_ARG(QCMakePropertyList,
-      this->CacheValues->cacheModel()->properties()));
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
-    "configure", Qt::QueuedConnection);
 }
 
-void CMakeSetupDialog::finishConfigure(int err)
+void CMakeSetupDialog::exitLoop(int err)
 {
-  if(0 == err && !this->CacheValues->cacheModel()->newPropertyCount())
+  this->LocalLoop.exit(err);
+}
+
+void CMakeSetupDialog::doConfigure()
+{
+  if(this->CurrentState == Configuring)
+    {
+    // stop configure
+    doInterrupt();
+    return;
+    }
+
+  if(!prepareConfigure())
+    {
+    return;
+    }
+
+  this->enterState(Configuring);
+
+  bool ret = doConfigureInternal();
+
+  if(ret)
+    {
+    this->ConfigureNeeded = false;
+    }
+
+  if(ret && !this->CacheValues->cacheModel()->newPropertyCount())
     {
     this->enterState(ReadyGenerate);
     }
@@ -341,6 +354,22 @@ void CMakeSetupDialog::finishConfigure(int err)
     this->enterState(ReadyConfigure);
     this->CacheValues->scrollToTop();
     }
+  this->ProgressBar->reset();
+}
+
+bool CMakeSetupDialog::doConfigureInternal()
+{
+  this->Output->clear();
+  this->CacheValues->selectionModel()->clear();
+
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+    "setProperties", Qt::QueuedConnection,
+    Q_ARG(QCMakePropertyList,
+      this->CacheValues->cacheModel()->properties()));
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+    "configure", Qt::QueuedConnection);
+
+  int err = this->LocalLoop.exec();
 
   if(err != 0)
     {
@@ -348,17 +377,8 @@ void CMakeSetupDialog::finishConfigure(int err)
       tr("Error in configuration process, project files may be invalid"),
       QMessageBox::Ok);
     }
-}
 
-void CMakeSetupDialog::finishGenerate(int err)
+  return 0 == err;
-{
-  this->enterState(ReadyConfigure);
-  if(err != 0)
-    {
-    QMessageBox::critical(this, tr("Error"),
-      tr("Error in generation process, project files may be invalid"),
-      QMessageBox::Ok);
-    }
 }
 
 void CMakeSetupDialog::doInstallForCommandLine()
@@ -367,6 +387,23 @@ void CMakeSetupDialog::doInstallForCommandLine()
   setupdialog.exec();
 }
 
+bool CMakeSetupDialog::doGenerateInternal()
+{
+  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+    "generate", Qt::QueuedConnection);
+
+  int err = this->LocalLoop.exec();
+
+  if(err != 0)
+    {
+    QMessageBox::critical(this, tr("Error"),
+      tr("Error in generation process, project files may be invalid"),
+      QMessageBox::Ok);
+    }
+
+  return 0 == err;
+}
+
 void CMakeSetupDialog::doGenerate()
 {
   if(this->CurrentState == Generating)
@@ -375,9 +412,43 @@ void CMakeSetupDialog::doGenerate()
     doInterrupt();
     return;
     }
+
+  // see if we need to configure
+  // we'll need to configure if:
+  //   the configure step hasn't been done yet
+  //   generate was the last step done
+  if(this->ConfigureNeeded)
+    {
+    if(!prepareConfigure())
+      {
+      return;
+      }
+    }
+
   this->enterState(Generating);
-  QMetaObject::invokeMethod(this->CMakeThread->cmakeInstance(),
+
-    "generate", Qt::QueuedConnection);
+  bool config_passed = true;
+  if(this->ConfigureNeeded)
+    {
+    this->CacheValues->cacheModel()->setShowNewProperties(false);
+    this->ProgressFactor = 0.5;
+    config_passed = doConfigureInternal();
+    this->ProgressOffset = 0.5;
+    }
+
+  if(config_passed)
+    {
+    doGenerateInternal();
+    }
+
+  this->ProgressOffset = 0.0;
+  this->ProgressFactor = 1.0;
+  this->CacheValues->cacheModel()->setShowNewProperties(true);
+
+  this->enterState(ReadyConfigure);
+  this->ProgressBar->reset();
+
+  this->ConfigureNeeded = true;
 }
 
 void CMakeSetupDialog::closeEvent(QCloseEvent* e)
@@ -542,6 +613,7 @@ void CMakeSetupDialog::setSourceDirectory(const QString& dir)
 
 void CMakeSetupDialog::showProgress(const QString& /*msg*/, float percent)
 {
+  percent = (percent * ProgressFactor) + ProgressOffset;
   this->ProgressBar->setValue(qRound(percent * 100));
 }
 
@@ -883,7 +955,6 @@ void CMakeSetupDialog::enterState(CMakeSetupDialog::State s)
     }
   else if(s == Configuring)
     {
-    this->Output->clear();
     this->setEnabledState(false);
     this->GenerateButton->setEnabled(false);
     this->GenerateAction->setEnabled(false);
@@ -899,17 +970,15 @@ void CMakeSetupDialog::enterState(CMakeSetupDialog::State s)
     }
   else if(s == ReadyConfigure)
     {
-    this->ProgressBar->reset();
     this->setEnabledState(true);
-    this->GenerateButton->setEnabled(false);
+    this->GenerateButton->setEnabled(true);
-    this->GenerateAction->setEnabled(false);
+    this->GenerateAction->setEnabled(true);
     this->ConfigureButton->setEnabled(true);
     this->ConfigureButton->setText(tr("&Configure"));
     this->GenerateButton->setText(tr("&Generate"));
     }
   else if(s == ReadyGenerate)
     {
-    this->ProgressBar->reset();
     this->setEnabledState(true);
     this->GenerateButton->setEnabled(true);
     this->GenerateAction->setEnabled(true);

Source/QtDialog/CMakeSetupDialog.h

@@ -16,6 +16,7 @@
 #include "QCMake.h"
 #include <QMainWindow>
 #include <QThread>
+#include <QEventLoop>
 #include "ui_CMakeSetupDialog.h"
 
 class QCMakeThread;
@@ -43,8 +44,6 @@ protected slots:
   void doHelp();
   void doAbout();
   void doInterrupt();
-  void finishConfigure(int error);
-  void finishGenerate(int error);
   void error(const QString& message);
   void message(const QString& message);
   
@@ -74,6 +73,10 @@ protected slots:
   void setGroupedView(bool);
   void showUserChanges();
   void setSearchFilter(const QString& str);
+  bool prepareConfigure();
+  bool doConfigureInternal();
+  bool doGenerateInternal();
+  void exitLoop(int);
 
 protected:
 
@@ -87,6 +90,7 @@ protected:
   QCMakeThread* CMakeThread;
   bool ExitAfterGenerate;
   bool CacheModified;
+  bool ConfigureNeeded;
   QAction* ReloadCacheAction;
   QAction* DeleteCacheAction;
   QAction* ExitAction;
@@ -99,6 +103,10 @@ protected:
   QTextCharFormat ErrorFormat;
   QTextCharFormat MessageFormat;
 
+  QEventLoop LocalLoop;
+
+  float ProgressOffset;
+  float ProgressFactor;
 };
 
 // QCMake instance on a thread

Source/QtDialog/QCMakeCacheView.cxx

@@ -200,6 +200,7 @@ QCMakeCacheModel::QCMakeCacheModel(QObject* p)
     NewPropertyCount(0),
     View(FlatView)
 {
+  this->ShowNewProperties = true;
   QStringList labels;
   labels << tr("Name") << tr("Value");
   this->setHorizontalHeaderLabels(labels);
@@ -214,6 +215,11 @@ static uint qHash(const QCMakeProperty& p)
   return qHash(p.Key);
 }
 
+void QCMakeCacheModel::setShowNewProperties(bool f)
+{
+  this->ShowNewProperties = f;
+}
+
 void QCMakeCacheModel::clear()
 {
   this->QStandardItemModel::clear();
@@ -226,13 +232,21 @@ void QCMakeCacheModel::clear()
 
 void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
 {
-  QSet<QCMakeProperty> newProps = props.toSet();
+  QSet<QCMakeProperty> newProps, newProps2;
-  QSet<QCMakeProperty> newProps2 = newProps;
+
-  QSet<QCMakeProperty> oldProps = this->properties().toSet();
+  if(this->ShowNewProperties)
-  
+    {
-  oldProps.intersect(newProps);
+    newProps = props.toSet();
-  newProps.subtract(oldProps);
+    newProps2 = newProps;
-  newProps2.subtract(newProps);
+    QSet<QCMakeProperty> oldProps = this->properties().toSet();
+    oldProps.intersect(newProps);
+    newProps.subtract(oldProps);
+    newProps2.subtract(newProps);
+    }
+  else
+    {
+    newProps2 = props.toSet();
+    }
 
   bool b = this->blockSignals(true);
 

Source/QtDialog/QCMakeCacheView.h

@@ -78,6 +78,9 @@ public slots:
   // become new properties and be marked red.
   void setProperties(const QCMakePropertyList& props);
 
+  // set whether to show new properties in red
+  void setShowNewProperties(bool);
+
   // clear everything from the model
   void clear();
 
@@ -115,6 +118,7 @@ public:
 protected:
   bool EditEnabled;
   int NewPropertyCount;
+  bool ShowNewProperties;
   ViewType View;
 
   // set the data in the model for this property

Source/cmAddCustomCommandCommand.h

@@ -13,6 +13,7 @@
 #define cmAddCustomCommandCommand_h
 
 #include "cmCommand.h"
+#include "cmDocumentGeneratorExpressions.h"
 
 /** \class cmAddCustomCommandCommand
  * \brief 
@@ -146,8 +147,15 @@ public:
       "target-level dependency will be added so that the executable target "
       "will be built before any target using this custom command.  However "
       "this does NOT add a file-level dependency that would cause the "
-      "custom command to re-run whenever the executable is recompiled.\n"
+      "custom command to re-run whenever the executable is recompiled."
-
+      "\n"
+      "Arguments to COMMAND may use \"generator expressions\" with the "
+      "syntax \"$<...>\".  "
+      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
+      "References to target names in generator expressions imply "
+      "target-level dependencies, but NOT file-level dependencies.  "
+      "List target names with the DEPENDS option to add file dependencies."
+      "\n"
       "The DEPENDS option specifies files on which the command depends.  "
       "If any dependency is an OUTPUT of another custom command in the "
       "same directory (CMakeLists.txt file) CMake automatically brings the "

Source/cmAddTestCommand.cxx

@@ -74,6 +74,7 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
 {
   std::string name;
   std::vector<std::string> configurations;
+  std::string working_directory;
   std::vector<std::string> command;
 
   // Read the arguments.
@@ -81,6 +82,7 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
     DoingName,
     DoingCommand,
     DoingConfigs,
+    DoingWorkingDirectory,
     DoingNone
   };
   Doing doing = DoingName;
@@ -104,6 +106,15 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
         }
       doing = DoingConfigs;
       }
+    else if(args[i] == "WORKING_DIRECTORY")
+      {
+      if(!working_directory.empty())
+        {
+        this->SetError(" may be given at most one WORKING_DIRECTORY.");
+        return false;
+        }
+      doing = DoingWorkingDirectory;
+      }
     else if(doing == DoingName)
       {
       name = args[i];
@@ -117,6 +128,11 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
       {
       configurations.push_back(args[i]);
       }
+    else if(doing == DoingWorkingDirectory)
+      {
+      working_directory = args[i];
+      doing = DoingNone;
+      }
     else
       {
       cmOStringStream e;
@@ -154,6 +170,7 @@ bool cmAddTestCommand::HandleNameMode(std::vector<std::string> const& args)
   cmTest* test = this->Makefile->CreateTest(name.c_str());
   test->SetOldStyle(false);
   test->SetCommand(command);
+  test->SetProperty("WORKING_DIRECTORY", working_directory.c_str());
   this->Makefile->AddTestGenerator(new cmTestGenerator(test, configurations));
 
   return true;

Source/cmAddTestCommand.h

@@ -13,6 +13,7 @@
 #define cmAddTestCommand_h
 
 #include "cmCommand.h"
+#include "cmDocumentGeneratorExpressions.h"
 
 /** \class cmAddTestCommand
  * \brief Add a test to the lists of tests to run.
@@ -68,28 +69,19 @@ public:
       "in the binary tree.\n"
       "\n"
       "  add_test(NAME <name> [CONFIGURATIONS [Debug|Release|...]]\n"
+      "           [WORKING_DIRECTORY dir]\n"
       "           COMMAND <command> [arg1 [arg2 ...]])\n"
       "If COMMAND specifies an executable target (created by "
       "add_executable) it will automatically be replaced by the location "
       "of the executable created at build time.  "
       "If a CONFIGURATIONS option is given then the test will be executed "
-      "only when testing under one of the named configurations."
+      "only when testing under one of the named configurations.  "
+      "If a WORKING_DIRECTORY option is given then the test will be executed "
+      "in the given directory."
       "\n"
       "Arguments after COMMAND may use \"generator expressions\" with the "
       "syntax \"$<...>\".  "
-      "These expressions are evaluted during build system generation and "
+      CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS
-      "produce information specific to each generated build configuration.  "
-      "Valid expressions are:\n"
-      "  $<CONFIGURATION>          = configuration name\n"
-      "  $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)\n"
-      "  $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)\n"
-      "  $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)\n"
-      "where \"tgt\" is the name of a target.  "
-      "Target file expressions produce a full path, but _DIR and _NAME "
-      "versions can produce the directory and file name components:\n"
-      "  $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>\n"
-      "  $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>\n"
-      "  $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>\n"
       "Example usage:\n"
       "  add_test(NAME mytest\n"
       "           COMMAND testDriver --config $<CONFIGURATION>\n"

Source/cmCustomCommand.cxx

@@ -11,6 +11,8 @@
 ============================================================================*/
 #include "cmCustomCommand.h"
 
+#include "cmMakefile.h"
+
 //----------------------------------------------------------------------------
 cmCustomCommand::cmCustomCommand()
 {
@@ -28,12 +30,14 @@ cmCustomCommand::cmCustomCommand(const cmCustomCommand& r):
   Comment(r.Comment),
   WorkingDirectory(r.WorkingDirectory),
   EscapeAllowMakeVars(r.EscapeAllowMakeVars),
-  EscapeOldStyle(r.EscapeOldStyle)
+  EscapeOldStyle(r.EscapeOldStyle),
+  Backtrace(new cmListFileBacktrace(*r.Backtrace))
 {
 }
 
 //----------------------------------------------------------------------------
-cmCustomCommand::cmCustomCommand(const std::vector<std::string>& outputs,
+cmCustomCommand::cmCustomCommand(cmMakefile* mf,
+                                 const std::vector<std::string>& outputs,
                                  const std::vector<std::string>& depends,
                                  const cmCustomCommandLines& commandLines,
                                  const char* comment,
@@ -45,10 +49,21 @@ cmCustomCommand::cmCustomCommand(const std::vector<std::string>& outputs,
   Comment(comment?comment:""),
   WorkingDirectory(workingDirectory?workingDirectory:""),
   EscapeAllowMakeVars(false),
-  EscapeOldStyle(true)
+  EscapeOldStyle(true),
+  Backtrace(new cmListFileBacktrace)
 {
   this->EscapeOldStyle = true;
   this->EscapeAllowMakeVars = false;
+  if(mf)
+    {
+    mf->GetBacktrace(*this->Backtrace);
+    }
+}
+
+//----------------------------------------------------------------------------
+cmCustomCommand::~cmCustomCommand()
+{
+  delete this->Backtrace;
 }
 
 //----------------------------------------------------------------------------
@@ -130,6 +145,12 @@ void cmCustomCommand::SetEscapeAllowMakeVars(bool b)
   this->EscapeAllowMakeVars = b;
 }
 
+//----------------------------------------------------------------------------
+cmListFileBacktrace const& cmCustomCommand::GetBacktrace() const
+{
+  return *this->Backtrace;
+}
+
 //----------------------------------------------------------------------------
 cmCustomCommand::ImplicitDependsList const&
 cmCustomCommand::GetImplicitDepends() const

Source/cmCustomCommand.h

@@ -13,6 +13,8 @@
 #define cmCustomCommand_h
 
 #include "cmStandardIncludes.h"
+class cmMakefile;
+class cmListFileBacktrace;
 
 /** \class cmCustomCommand
  * \brief A class to encapsulate a custom command
@@ -27,12 +29,15 @@ public:
   cmCustomCommand(const cmCustomCommand& r);
 
   /** Main constructor specifies all information for the command.  */
-  cmCustomCommand(const std::vector<std::string>& outputs,
+  cmCustomCommand(cmMakefile* mf,
+                  const std::vector<std::string>& outputs,
                   const std::vector<std::string>& depends,
                   const cmCustomCommandLines& commandLines,
                   const char* comment,
                   const char* workingDirectory);
 
+  ~cmCustomCommand();
+
   /** Get the output file produced by the command.  */
   const std::vector<std::string>& GetOutputs() const;
 
@@ -63,6 +68,9 @@ public:
   bool GetEscapeAllowMakeVars() const;
   void SetEscapeAllowMakeVars(bool b);
 
+  /** Backtrace of the command that created this custom command.  */
+  cmListFileBacktrace const& GetBacktrace() const;
+
   typedef std::pair<cmStdString, cmStdString> ImplicitDependsPair;
   class ImplicitDependsList: public std::vector<ImplicitDependsPair> {};
   void SetImplicitDepends(ImplicitDependsList const&);
@@ -78,6 +86,7 @@ private:
   std::string WorkingDirectory;
   bool EscapeAllowMakeVars;
   bool EscapeOldStyle;
+  cmListFileBacktrace* Backtrace;
   ImplicitDependsList ImplicitDepends;
 };
 

Source/cmCustomCommandGenerator.cxx

@@ -0,0 +1,72 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2010 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.
+============================================================================*/
+#include "cmCustomCommandGenerator.h"
+
+#include "cmMakefile.h"
+#include "cmCustomCommand.h"
+#include "cmLocalGenerator.h"
+#include "cmGeneratorExpression.h"
+
+//----------------------------------------------------------------------------
+cmCustomCommandGenerator::cmCustomCommandGenerator(
+  cmCustomCommand const& cc, const char* config, cmMakefile* mf):
+  CC(cc), Config(config), Makefile(mf), LG(mf->GetLocalGenerator()),
+  OldStyle(cc.GetEscapeOldStyle()), MakeVars(cc.GetEscapeAllowMakeVars()),
+  GE(new cmGeneratorExpression(mf, config, cc.GetBacktrace()))
+{
+}
+
+//----------------------------------------------------------------------------
+cmCustomCommandGenerator::~cmCustomCommandGenerator()
+{
+  delete this->GE;
+}
+
+//----------------------------------------------------------------------------
+unsigned int cmCustomCommandGenerator::GetNumberOfCommands() const
+{
+  return static_cast<unsigned int>(this->CC.GetCommandLines().size());
+}
+
+//----------------------------------------------------------------------------
+std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const
+{
+  std::string const& argv0 = this->CC.GetCommandLines()[c][0];
+  cmTarget* target = this->Makefile->FindTargetToUse(argv0.c_str());
+  if(target && target->GetType() == cmTarget::EXECUTABLE &&
+     (target->IsImported() || !this->Makefile->IsOn("CMAKE_CROSSCOMPILING")))
+    {
+    return target->GetLocation(this->Config);
+    }
+  return this->GE->Process(argv0);
+}
+
+//----------------------------------------------------------------------------
+void
+cmCustomCommandGenerator
+::AppendArguments(unsigned int c, std::string& cmd) const
+{
+  cmCustomCommandLine const& commandLine = this->CC.GetCommandLines()[c];
+  for(unsigned int j=1;j < commandLine.size(); ++j)
+    {
+    std::string arg = this->GE->Process(commandLine[j]);
+    cmd += " ";
+    if(this->OldStyle)
+      {
+      cmd += this->LG->EscapeForShellOldStyle(arg.c_str());
+      }
+    else
+      {
+      cmd += this->LG->EscapeForShell(arg.c_str(), this->MakeVars);
+      }
+    }
+}

Source/cmCustomCommandGenerator.h

@@ -0,0 +1,40 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2010 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.
+============================================================================*/
+#ifndef cmCustomCommandGenerator_h
+#define cmCustomCommandGenerator_h
+
+#include "cmStandardIncludes.h"
+
+class cmCustomCommand;
+class cmMakefile;
+class cmLocalGenerator;
+class cmGeneratorExpression;
+
+class cmCustomCommandGenerator
+{
+  cmCustomCommand const& CC;
+  const char* Config;
+  cmMakefile* Makefile;
+  cmLocalGenerator* LG;
+  bool OldStyle;
+  bool MakeVars;
+  cmGeneratorExpression* GE;
+public:
+  cmCustomCommandGenerator(cmCustomCommand const& cc, const char* config,
+                           cmMakefile* mf);
+  ~cmCustomCommandGenerator();
+  unsigned int GetNumberOfCommands() const;
+  std::string GetCommand(unsigned int c) const;
+  void AppendArguments(unsigned int c, std::string& cmd) const;
+};
+
+#endif

Source/cmDepends.cxx

@@ -25,7 +25,7 @@ cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir):
   Verbose(false),
   FileComparison(0),
   TargetDirectory(targetDir),
-  MaxPath(cmSystemTools::GetMaximumFilePathLength()),
+  MaxPath(16384),
   Dependee(new char[MaxPath]),
   Depender(new char[MaxPath])
 {

Source/cmDocumentGeneratorExpressions.h

@@ -0,0 +1,30 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2010 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.
+============================================================================*/
+#ifndef cmDocumentGeneratorExpressions_h
+#define cmDocumentGeneratorExpressions_h
+
+#define CM_DOCUMENT_COMMAND_GENERATOR_EXPRESSIONS                       \
+  "Generator expressions are evaluted during build system generation "  \
+  "to produce information specific to each build configuration.  "      \
+  "Valid expressions are:\n"                                            \
+  "  $<CONFIGURATION>          = configuration name\n"                  \
+  "  $<TARGET_FILE:tgt>        = main file (.exe, .so.1.2, .a)\n"       \
+  "  $<TARGET_LINKER_FILE:tgt> = file used to link (.a, .lib, .so)\n"   \
+  "  $<TARGET_SONAME_FILE:tgt> = file with soname (.so.3)\n"            \
+  "where \"tgt\" is the name of a target.  "                            \
+  "Target file expressions produce a full path, but _DIR and _NAME "    \
+  "versions can produce the directory and file name components:\n"      \
+  "  $<TARGET_FILE_DIR:tgt>/$<TARGET_FILE_NAME:tgt>\n"                  \
+  "  $<TARGET_LINKER_FILE_DIR:tgt>/$<TARGET_LINKER_FILE_NAME:tgt>\n"    \
+  "  $<TARGET_SONAME_FILE_DIR:tgt>/$<TARGET_SONAME_FILE_NAME:tgt>\n"
+
+#endif

Source/cmExtraEclipseCDT4Generator.cxx

@@ -201,7 +201,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     "<projectDescription>\n"
     "\t<name>" <<
     this->GenerateProjectName(mf->GetProjectName(),
-                              mf->GetDefinition("CMAKE_BUILD_TYPE"),
+                              mf->GetSafeDefinition("CMAKE_BUILD_TYPE"),
                               this->GetPathBasename(this->HomeOutputDirectory))
     << "</name>\n"
     "\t<comment></comment>\n"

Source/cmFileCommand.h

@@ -116,7 +116,12 @@ public:
       "expressions and store it into the variable. Globbing expressions "
       "are similar to regular expressions, but much simpler. If RELATIVE "
       "flag is specified for an expression, the results will be returned "
-      "as a relative path to the given path.\n"
+      "as a relative path to the given path.  "
+      "(We do not recommend using GLOB to collect a list of source files "
+      "from your source tree.  If no CMakeLists.txt file changes when a "
+      "source is added or removed then the generated build system cannot "
+      "know when to ask CMake to regenerate.)"
+      "\n"
       "Examples of globbing expressions include:\n"
       "   *.cxx      - match all files with extension cxx\n"
       "   *.vt?      - match all files with extension vta,...,vtz\n"

Source/cmGeneratorExpression.cxx

@@ -17,8 +17,8 @@
 //----------------------------------------------------------------------------
 cmGeneratorExpression::cmGeneratorExpression(
   cmMakefile* mf, const char* config,
-  cmListFileBacktrace const& backtrace):
+  cmListFileBacktrace const& backtrace, bool quiet):
-  Makefile(mf), Config(config), Backtrace(backtrace)
+  Makefile(mf), Config(config), Backtrace(backtrace), Quiet(quiet)
 {
   this->TargetInfo.compile("^\\$<TARGET"
                            "(|_SONAME|_LINKER)"  // File with what purpose?
@@ -87,7 +87,7 @@ bool cmGeneratorExpression::Evaluate()
     this->Data.insert(this->Data.end(), result.begin(), result.end());
     return true;
     }
-  else
+  else if(!this->Quiet)
     {
     // Failure.  Report the error message.
     cmOStringStream e;
@@ -99,6 +99,7 @@ bool cmGeneratorExpression::Evaluate()
                      this->Backtrace);
     return false;
     }
+  return true;
 }
 
 //----------------------------------------------------------------------------
@@ -140,6 +141,7 @@ bool cmGeneratorExpression::EvaluateTargetInfo(std::string& result)
     result = "Target \"" + name + "\" is not an executable or library.";
     return false;
     }
+  this->Targets.insert(target);
 
   // Lookup the target file with the given purpose.
   std::string purpose = this->TargetInfo.match(1);

Source/cmGeneratorExpression.h

@@ -15,6 +15,7 @@
 
 #include <cmsys/RegularExpression.hxx>
 
+class cmTarget;
 class cmMakefile;
 class cmListFileBacktrace;
 
@@ -32,18 +33,25 @@ class cmGeneratorExpression
 public:
   /** Construct with an evaluation context and configuration.  */
   cmGeneratorExpression(cmMakefile* mf, const char* config,
-                        cmListFileBacktrace const& backtrace);
+                        cmListFileBacktrace const& backtrace,
+                        bool quiet = false);
 
   /** Evaluate generator expressions in a string.  */
   const char* Process(std::string const& input);
   const char* Process(const char* input);
+
+  /** Get set of targets found during evaluations.  */
+  std::set<cmTarget*> const& GetTargets() const
+    { return this->Targets; }
 private:
   cmMakefile* Makefile;
   const char* Config;
   cmListFileBacktrace const& Backtrace;
+  bool Quiet;
   std::vector<char> Data;
   std::stack<size_t> Barriers;
   cmsys::RegularExpression TargetInfo;
+  std::set<cmTarget*> Targets;
   bool Evaluate();
   bool Evaluate(const char* expr, std::string& result);
   bool EvaluateTargetInfo(std::string& result);

Source/cmGlobalGenerator.cxx

@@ -1879,7 +1879,7 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(
   std::vector<std::string> no_outputs;
   std::vector<std::string> no_depends;
   // Store the custom command in the target.
-  cmCustomCommand cc(no_outputs, no_depends, *commandLines, 0,
+  cmCustomCommand cc(0, no_outputs, no_depends, *commandLines, 0,
                      workingDirectory);
   target.GetPostBuildCommands().push_back(cc);
   target.SetProperty("EchoString", message);

Source/cmGlobalVisualStudio71Generator.cxx

@@ -110,7 +110,7 @@ void cmGlobalVisualStudio71Generator
   this->GetTargetSets(projectTargets, originalTargets, root, generators);
   OrderedTargetDependSet orderedProjectTargets(projectTargets);
 
-  this->WriteTargetsToSolution(fout, orderedProjectTargets);
+  this->WriteTargetsToSolution(fout, root, orderedProjectTargets);
 
   bool useFolderProperty = this->UseFolderProperty();
   if (useFolderProperty)
@@ -182,8 +182,8 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
   std::string guid = this->GetGUID(dspname);
   fout << project
        << dspname << "\", \""
-       << this->ConvertToSolutionPath(dir)
+       << this->ConvertToSolutionPath(dir) << (dir[0]? "\\":"")
-       << "\\" << dspname << ext << "\", \"{" << guid << "}\"\n";
+       << dspname << ext << "\", \"{" << guid << "}\"\n";
   fout << "\tProjectSection(ProjectDependencies) = postProject\n";
   this->WriteProjectDepends(fout, dspname, dir, t);
   fout << "\tEndProjectSection\n";
@@ -196,8 +196,8 @@ cmGlobalVisualStudio71Generator::WriteProject(std::ostream& fout,
     const char* uname = ui->second.c_str();
     fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \""
          << uname << "\", \""
-         << this->ConvertToSolutionPath(dir)
+         << this->ConvertToSolutionPath(dir) << (dir[0]? "\\":"")
-         << "\\" << uname << ".vcproj" << "\", \"{"
+         << uname << ".vcproj" << "\", \"{"
          << this->GetGUID(uname) << "}\"\n"
          << "\tProjectSection(ProjectDependencies) = postProject\n"
          << "\t\t{" << guid << "} = {" << guid << "}\n"

Source/cmGlobalVisualStudio7Generator.cxx

@@ -270,6 +270,7 @@ void cmGlobalVisualStudio7Generator::WriteTargetConfigurations(
 
 void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
     std::ostream& fout,
+    cmLocalGenerator* root,
     OrderedTargetDependSet const& projectTargets)
 {
   for(OrderedTargetDependSet::const_iterator tt =
@@ -296,6 +297,12 @@ void cmGlobalVisualStudio7Generator::WriteTargetsToSolution(
         {
         cmMakefile* tmf = target->GetMakefile();
         std::string dir = tmf->GetStartOutputDirectory();
+        dir = root->Convert(dir.c_str(),
+                            cmLocalGenerator::START_OUTPUT);
+        if(dir == ".")
+          {
+          dir = ""; // msbuild cannot handle ".\" prefix
+          }
         this->WriteProject(fout, vcprojName, dir.c_str(),
                            *target);
         written = true;
@@ -385,7 +392,7 @@ void cmGlobalVisualStudio7Generator
   this->GetTargetSets(projectTargets, originalTargets, root, generators);
   OrderedTargetDependSet orderedProjectTargets(projectTargets);
 
-  this->WriteTargetsToSolution(fout, orderedProjectTargets);
+  this->WriteTargetsToSolution(fout, root, orderedProjectTargets);
 
   bool useFolderProperty = this->UseFolderProperty();
   if (useFolderProperty)
@@ -511,8 +518,8 @@ void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout,
 
   fout << project
        << dspname << "\", \""
-       << this->ConvertToSolutionPath(dir)
+       << this->ConvertToSolutionPath(dir) << (dir[0]? "\\":"")
-       << "\\" << dspname << ext << "\", \"{"
+       << dspname << ext << "\", \"{"
        << this->GetGUID(dspname) << "}\"\nEndProject\n";
 
   UtilityDependsMap::iterator ui = this->UtilityDepends.find(&target);
@@ -521,8 +528,8 @@ void cmGlobalVisualStudio7Generator::WriteProject(std::ostream& fout,
     const char* uname = ui->second.c_str();
     fout << "Project(\"{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}\") = \""
          << uname << "\", \""
-         << this->ConvertToSolutionPath(dir)
+         << this->ConvertToSolutionPath(dir) << (dir[0]? "\\":"")
-         << "\\" << uname << ".vcproj" << "\", \"{"
+         << uname << ".vcproj" << "\", \"{"
          << this->GetGUID(uname) << "}\"\n"
          << "EndProject\n";
     }

Source/cmGlobalVisualStudio7Generator.h

@@ -118,6 +118,7 @@ protected:
 
   virtual void WriteTargetsToSolution(
     std::ostream& fout,
+    cmLocalGenerator* root,
     OrderedTargetDependSet const& projectTargets);
   virtual void WriteTargetDepends(
     std::ostream& fout,

Source/cmGlobalXCodeGenerator.cxx

@@ -18,6 +18,7 @@
 #include "cmGeneratedFileStream.h"
 #include "cmComputeLinkInformation.h"
 #include "cmSourceFile.h"
+#include "cmCustomCommandGenerator.h"
 
 #include <cmsys/auto_ptr.hxx>
 
@@ -1314,8 +1315,7 @@ void  cmGlobalXCodeGenerator
     cmCustomCommand const& cc = *i;
     if(!cc.GetCommandLines().empty())
       {
-      bool escapeOldStyle = cc.GetEscapeOldStyle();
+      cmCustomCommandGenerator ccg(cc, configName, this->CurrentMakefile);
-      bool escapeAllowMakeVars = cc.GetEscapeAllowMakeVars();
       makefileStream << "\n";
       const std::vector<std::string>& outputs = cc.GetOutputs();
       if(!outputs.empty())
@@ -1348,20 +1348,15 @@ void  cmGlobalXCodeGenerator
         {
         std::string echo_cmd = "echo ";
         echo_cmd += (this->CurrentLocalGenerator->
-                     EscapeForShell(comment, escapeAllowMakeVars));
+                     EscapeForShell(comment, cc.GetEscapeAllowMakeVars()));
         makefileStream << "\t" << echo_cmd.c_str() << "\n";
         }
 
       // Add each command line to the set of commands.
-      for(cmCustomCommandLines::const_iterator cl =
+      for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-          cc.GetCommandLines().begin();
-          cl != cc.GetCommandLines().end(); ++cl)
         {
         // Build the command line in a single string.
-        const cmCustomCommandLine& commandLine = *cl;
+        std::string cmd2 = ccg.GetCommand(c);
-        std::string cmd2 = this->CurrentLocalGenerator
-                         ->GetRealLocation(commandLine[0].c_str(), configName);
-
         cmSystemTools::ReplaceString(cmd2, "/./", "/");
         cmd2 = this->ConvertToRelativeForMake(cmd2.c_str());
         std::string cmd;
@@ -1372,21 +1367,7 @@ void  cmGlobalXCodeGenerator
           cmd += " && ";
           }
         cmd += cmd2;
-        for(unsigned int j=1; j < commandLine.size(); ++j)
+        ccg.AppendArguments(c, cmd);
-          {
-          cmd += " ";
-          if(escapeOldStyle)
-            {
-            cmd += (this->CurrentLocalGenerator
-                ->EscapeForShellOldStyle(commandLine[j].c_str()));
-            }
-          else
-            {
-            cmd += (this->CurrentLocalGenerator->
-                EscapeForShell(commandLine[j].c_str(),
-                               escapeAllowMakeVars));
-            }
-          }
         makefileStream << "\t" << cmd.c_str() << "\n";
         }
       }
@@ -2636,7 +2617,10 @@ void cmGlobalXCodeGenerator
     group->AddAttribute("BuildIndependentTargetsInParallel",
                         this->CreateString("YES"));
     this->RootObject->AddAttribute("attributes", group);
-    if (this->XcodeVersion >= 31)
+    if (this->XcodeVersion >= 32)
+      this->RootObject->AddAttribute("compatibilityVersion",
+                                     this->CreateString("Xcode 3.2"));
+    else if (this->XcodeVersion >= 31)
       this->RootObject->AddAttribute("compatibilityVersion",
                                      this->CreateString("Xcode 3.1"));
     else
@@ -3042,7 +3026,9 @@ cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
   cmXCodeObject::Indent(1, fout);
   if(this->XcodeVersion >= 21)
     {
-    if (this->XcodeVersion >= 31)
+    if (this->XcodeVersion >= 32)
+      fout << "objectVersion = 46;\n";
+    else if (this->XcodeVersion >= 31)
       fout << "objectVersion = 45;\n";
     else if (this->XcodeVersion >= 30)
       fout << "objectVersion = 44;\n";

Source/cmLocalGenerator.cxx

@@ -1912,24 +1912,6 @@ bool cmLocalGenerator::GetRealDependency(const char* inName,
   return true;
 }
 
-//----------------------------------------------------------------------------
-std::string cmLocalGenerator::GetRealLocation(const char* inName,
-                                              const char* config)
-{
-  std::string outName=inName;
-  // Look for a CMake target with the given name, which is an executable 
-  // and which can be run
-  cmTarget* target = this->Makefile->FindTargetToUse(inName);
-  if ((target != 0)
-       && (target->GetType() == cmTarget::EXECUTABLE)
-       && ((this->Makefile->IsOn("CMAKE_CROSSCOMPILING") == false) 
-            || (target->IsImported() == true)))
-    {
-    outName = target->GetLocation( config );
-    }
-  return outName;
-}
-
 //----------------------------------------------------------------------------
 void cmLocalGenerator::AddSharedFlags(std::string& flags,
                                       const char* lang,

Source/cmLocalGenerator.h

@@ -168,11 +168,6 @@ public:
   bool GetRealDependency(const char* name, const char* config,
                          std::string& dep);
 
-  /** Translate a command as given in CMake code to the location of the 
-      executable if the command is the name of a CMake executable target.
-      If that's not the case, just return the original name. */
-  std::string GetRealLocation(const char* inName, const char* config);
-
   ///! for existing files convert to output path and short path if spaces
   std::string ConvertToOutputForExisting(const char* remote,
                                          RelativeRoot local = START_OUTPUT);

Source/cmLocalUnixMakefileGenerator3.cxx

@@ -19,6 +19,7 @@
 #include "cmake.h"
 #include "cmVersion.h"
 #include "cmFileTimeComparison.h"
+#include "cmCustomCommandGenerator.h"
 
 // Include dependency scanners for supported languages.  Only the
 // C/C++ scanner is needed for bootstrapping CMake.
@@ -961,18 +962,15 @@ cmLocalUnixMakefileGenerator3
     {
     *content << dir;
     }
-  bool escapeOldStyle = cc.GetEscapeOldStyle();
+  cmCustomCommandGenerator ccg(cc, this->ConfigurationName.c_str(),
-  bool escapeAllowMakeVars = cc.GetEscapeAllowMakeVars();
+                               this->Makefile);
 
   // Add each command line to the set of commands.
   std::vector<std::string> commands1;
-  for(cmCustomCommandLines::const_iterator cl = cc.GetCommandLines().begin();
+  for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-      cl != cc.GetCommandLines().end(); ++cl)
     {
     // Build the command line in a single string.
-    const cmCustomCommandLine& commandLine = *cl;
+    std::string cmd = ccg.GetCommand(c);
-    std::string cmd = GetRealLocation(commandLine[0].c_str(),
-                                      this->ConfigurationName.c_str());
     if (cmd.size())
       {
       // Use "call " before any invocations of .bat or .cmd files
@@ -1025,19 +1023,8 @@ cmLocalUnixMakefileGenerator3
       std::string launcher =
         this->MakeLauncher(cc, target, workingDir? NONE : START_OUTPUT);
       cmd = launcher + this->Convert(cmd.c_str(),NONE,SHELL);
-      for(unsigned int j=1; j < commandLine.size(); ++j)
+
-        {
+      ccg.AppendArguments(c, cmd);
-        cmd += " ";
-        if(escapeOldStyle)
-          {
-          cmd += this->EscapeForShellOldStyle(commandLine[j].c_str());
-          }
-        else
-          {
-          cmd += this->EscapeForShell(commandLine[j].c_str(),
-                                      escapeAllowMakeVars);
-          }
-        }
       if(content)
         {
         // Rule content does not include the launcher.

Source/cmLocalVisualStudio10Generator.cxx

@@ -117,3 +117,9 @@ void cmLocalVisualStudio10Generator
                   "Stored GUID",
                   cmCacheManager::INTERNAL);
 }
+
+//----------------------------------------------------------------------------
+std::string cmLocalVisualStudio10Generator::CheckForErrorLine()
+{
+  return "if errorlevel 1 goto :VCEnd";
+}

Source/cmLocalVisualStudio10Generator.h

@@ -36,6 +36,10 @@ public:
   virtual void Generate();
   virtual void ReadAndStoreExternalGUID(const char* name,
                                         const char* path);
+
+protected:
+  virtual std::string CheckForErrorLine();
+
 private:
 };
 #endif

Source/cmLocalVisualStudio6Generator.cxx

@@ -65,13 +65,7 @@ public:
       {
       this->Code += "\\\n\t";
       }
-    this->Code +=
+    this->Code += this->LG->ConstructScript(cc, this->Config, "\\\n\t");
-      this->LG->ConstructScript(cc.GetCommandLines(),
-                                cc.GetWorkingDirectory(),
-                                this->Config,
-                                cc.GetEscapeOldStyle(),
-                                cc.GetEscapeAllowMakeVars(),
-                                "\\\n\t");
     }
 private:
   cmLocalVisualStudio6Generator* LG;
@@ -659,12 +653,7 @@ cmLocalVisualStudio6Generator
     {
     std::string config = this->GetConfigName(*i);
     std::string script =
-      this->ConstructScript(command.GetCommandLines(), 
+      this->ConstructScript(command, config.c_str(), "\\\n\t");
-                            command.GetWorkingDirectory(),
-                            config.c_str(),
-                            command.GetEscapeOldStyle(),
-                            command.GetEscapeAllowMakeVars(),
-                            "\\\n\t");
       
     if (i == this->Configurations.begin())
       {
@@ -849,7 +838,7 @@ cmLocalVisualStudio6Generator::MaybeCreateOutputDir(cmTarget& target,
   std::vector<std::string> no_depends;
   cmCustomCommandLines commands;
   commands.push_back(command);
-  pcc.reset(new cmCustomCommand(no_output, no_depends, commands, 0, 0));
+  pcc.reset(new cmCustomCommand(0, no_output, no_depends, commands, 0, 0));
   pcc->SetEscapeOldStyle(false);
   pcc->SetEscapeAllowMakeVars(true);
   return pcc;

Source/cmLocalVisualStudio7Generator.cxx

@@ -546,12 +546,7 @@ public:
       {
       this->Stream << this->LG->EscapeForXML("\n");
       }
-    std::string script =
+    std::string script = this->LG->ConstructScript(cc, this->Config);
-      this->LG->ConstructScript(cc.GetCommandLines(),
-                                cc.GetWorkingDirectory(),
-                                this->Config,
-                                cc.GetEscapeOldStyle(),
-                                cc.GetEscapeAllowMakeVars());
     this->Stream << this->LG->EscapeForXML(script.c_str());
     }
 private:
@@ -1591,12 +1586,7 @@ WriteCustomRule(std::ostream& fout,
            << this->EscapeForXML(fc.CompileFlags.c_str()) << "\"/>\n";
       }
 
-    std::string script = 
+    std::string script = this->ConstructScript(command, i->c_str());
-      this->ConstructScript(command.GetCommandLines(),
-                            command.GetWorkingDirectory(),
-                            i->c_str(),
-                            command.GetEscapeOldStyle(),
-                            command.GetEscapeAllowMakeVars());
     fout << "\t\t\t\t\t<Tool\n"
          << "\t\t\t\t\tName=\"" << customTool << "\"\n"
          << "\t\t\t\t\tDescription=\"" 

Source/cmLocalVisualStudioGenerator.cxx

@@ -14,6 +14,7 @@
 #include "cmMakefile.h"
 #include "cmSourceFile.h"
 #include "cmSystemTools.h"
+#include "cmCustomCommandGenerator.h"
 #include "windows.h"
 
 //----------------------------------------------------------------------------
@@ -52,7 +53,7 @@ cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target,
   std::vector<std::string> no_depends;
   cmCustomCommandLines commands;
   commands.push_back(command);
-  pcc.reset(new cmCustomCommand(no_output, no_depends, commands, 0, 0));
+  pcc.reset(new cmCustomCommand(0, no_output, no_depends, commands, 0, 0));
   pcc->SetEscapeOldStyle(false);
   pcc->SetEscapeAllowMakeVars(true);
   return pcc;
@@ -148,16 +149,30 @@ void cmLocalVisualStudioGenerator::ComputeObjectNameRequirements
   this->InsertNeedObjectNames(sourceGroups, objectNameCounts);
 }
 
+//----------------------------------------------------------------------------
+std::string cmLocalVisualStudioGenerator::CheckForErrorLine()
+{
+  return "if errorlevel 1 goto :VCReportError";
+}
+
+//----------------------------------------------------------------------------
+std::string cmLocalVisualStudioGenerator::GetCheckForErrorLine()
+{
+  return this->CheckForErrorLine();
+}
+
 //----------------------------------------------------------------------------
 std::string
 cmLocalVisualStudioGenerator
-::ConstructScript(const cmCustomCommandLines& commandLines,
+::ConstructScript(cmCustomCommand const& cc,
-                  const char* workingDirectory,
                   const char* configName,
-                  bool escapeOldStyle,
-                  bool escapeAllowMakeVars,
                   const char* newline_text)
 {
+  const cmCustomCommandLines& commandLines = cc.GetCommandLines();
+  const char* workingDirectory = cc.GetWorkingDirectory();
+  cmCustomCommandGenerator ccg(cc, configName, this->Makefile);
+  RelativeRoot relativeRoot = workingDirectory? NONE : START_OUTPUT;
+
   // Avoid leading or trailing newlines.
   const char* newline = "";
 
@@ -196,40 +211,16 @@ cmLocalVisualStudioGenerator
       }
     }
   // Write each command on a single line.
-  for(cmCustomCommandLines::const_iterator cl = commandLines.begin();
+  for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
-      cl != commandLines.end(); ++cl)
     {
     // Start a new line.
     script += newline;
     newline = newline_text;
 
-    // Start with the command name.
+    // Add this command line.
-    const cmCustomCommandLine& commandLine = *cl;
+    std::string cmd = ccg.GetCommand(c);
-    std::string commandName = this->GetRealLocation(commandLine[0].c_str(), 
+    script += this->Convert(cmd.c_str(), relativeRoot, SHELL);
-                                                    configName);
+    ccg.AppendArguments(c, script);
-    if(!workingDirectory)
-      {
-      script += this->Convert(commandName.c_str(),START_OUTPUT,SHELL);
-      }
-    else
-      {
-      script += this->Convert(commandName.c_str(),NONE,SHELL);
-      }
-
-    // Add the arguments.
-    for(unsigned int j=1;j < commandLine.size(); ++j)
-      {
-      script += " ";
-      if(escapeOldStyle)
-        {
-        script += this->EscapeForShellOldStyle(commandLine[j].c_str());
-        }
-      else
-        {
-        script += this->EscapeForShell(commandLine[j].c_str(),
-                                       escapeAllowMakeVars);
-        }
-      }
 
     // After each custom command, check for an error result.
     // If there was an error, jump to the VCReportError label,
@@ -237,7 +228,7 @@ cmLocalVisualStudioGenerator
     // sequence.
     //
     script += newline_text;
-    script += "if errorlevel 1 goto VCReportError";
+    script += this->GetCheckForErrorLine();
     }
 
   return script;

Source/cmLocalVisualStudioGenerator.h

@@ -18,6 +18,7 @@
 
 class cmSourceFile;
 class cmSourceGroup;
+class cmCustomCommand;
 
 /** \class cmLocalVisualStudioGenerator
  * \brief Base class for Visual Studio generators.
@@ -30,15 +31,19 @@ class cmLocalVisualStudioGenerator : public cmLocalGenerator
 public:
   cmLocalVisualStudioGenerator();
   virtual ~cmLocalVisualStudioGenerator();
+
   /** Construct a script from the given list of command lines.  */
-  std::string ConstructScript(const cmCustomCommandLines& commandLines,
+  std::string ConstructScript(cmCustomCommand const& cc,
-                              const char* workingDirectory,
                               const char* configName,
-                              bool escapeOldStyle,
-                              bool escapeAllowMakeVars,
                               const char* newline = "\n");
 
+  /** Line of batch file text that skips to the end after
+    * a failed step in a sequence of custom commands.
+    */
+  std::string GetCheckForErrorLine();
+
 protected:
+  virtual std::string CheckForErrorLine();
 
   /** Construct a custom command to make exe import lib dir.  */
   cmsys::auto_ptr<cmCustomCommand>

Source/cmMakefile.cxx

@@ -827,7 +827,8 @@ cmMakefile::AddCustomCommandToTarget(const char* target,
     {
     // Add the command to the appropriate build step for the target.
     std::vector<std::string> no_output;
-    cmCustomCommand cc(no_output, depends, commandLines, comment, workingDir);
+    cmCustomCommand cc(this, no_output, depends,
+                       commandLines, comment, workingDir);
     cc.SetEscapeOldStyle(escapeOldStyle);
     cc.SetEscapeAllowMakeVars(true);
     switch(type)
@@ -947,7 +948,7 @@ cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
   if(file)
     {
     cmCustomCommand* cc =
-      new cmCustomCommand(outputs, depends2, commandLines,
+      new cmCustomCommand(this, outputs, depends2, commandLines,
                           comment, workingDir);
     cc->SetEscapeOldStyle(escapeOldStyle);
     cc->SetEscapeAllowMakeVars(true);
@@ -2340,17 +2341,19 @@ void cmMakefile::AddDefaultDefinitions()
   working, these variables are still also set here in this place, but they
   will be reset in CMakeSystemSpecificInformation.cmake before the platform
   files are executed. */
-#if defined(_WIN32) || defined(__CYGWIN__)
+#if defined(_WIN32)
   this->AddDefinition("WIN32", "1");
   this->AddDefinition("CMAKE_HOST_WIN32", "1");
 #else
   this->AddDefinition("UNIX", "1");
   this->AddDefinition("CMAKE_HOST_UNIX", "1");
 #endif
-  // Cygwin is more like unix so enable the unix commands
 #if defined(__CYGWIN__)
-  this->AddDefinition("UNIX", "1");
+  if(cmSystemTools::IsOn(cmSystemTools::GetEnv("CMAKE_LEGACY_CYGWIN_WIN32")))
-  this->AddDefinition("CMAKE_HOST_UNIX", "1");
+    {
+    this->AddDefinition("WIN32", "1");
+    this->AddDefinition("CMAKE_HOST_WIN32", "1");
+    }
 #endif
 #if defined(__APPLE__)
   this->AddDefinition("APPLE", "1");

Source/cmSourceFile.cxx

@@ -472,7 +472,9 @@ void cmSourceFile::DefineProperties(cmake *cm)
      "What programming language is the file.",
      "A property that can be set to indicate what programming language "
      "the source file is. If it is not set the language is determined "
-     "based on the file extension. Typical values are CXX C etc.");
+     "based on the file extension. Typical values are CXX C etc. Setting "
+     "this property for a file means this file will be compiled. "
+     "Do not set this for header or files that should not be compiled.");
 
   cm->DefineProperty
     ("LOCATION", cmProperty::SOURCE_FILE, 

Source/cmTarget.cxx

@@ -17,6 +17,7 @@
 #include "cmGlobalGenerator.h"
 #include "cmComputeLinkInformation.h"
 #include "cmListFileCache.h"
+#include "cmGeneratorExpression.h"
 #include <cmsys/RegularExpression.hxx>
 #include <map>
 #include <set>
@@ -1402,6 +1403,7 @@ cmTargetTraceDependencies
 {
   // Transform command names that reference targets built in this
   // project to corresponding target-level dependencies.
+  cmGeneratorExpression ge(this->Makefile, 0, cc.GetBacktrace(), true);
   for(cmCustomCommandLines::const_iterator cit = cc.GetCommandLines().begin();
       cit != cc.GetCommandLines().end(); ++cit)
     {
@@ -1418,6 +1420,21 @@ cmTargetTraceDependencies
         this->Target->AddUtility(command.c_str());
         }
       }
+
+    // Check for target references in generator expressions.
+    for(cmCustomCommandLine::const_iterator cli = cit->begin();
+        cli != cit->end(); ++cli)
+      {
+      ge.Process(*cli);
+      }
+    }
+
+  // Add target-level dependencies referenced by generator expressions.
+  std::set<cmTarget*> targets = ge.GetTargets();
+  for(std::set<cmTarget*>::iterator ti = targets.begin();
+      ti != targets.end(); ++ti)
+    {
+    this->Target->AddUtility((*ti)->GetName());
     }
 
   // Queue the custom command dependencies.

Source/cmTest.cxx

@@ -196,4 +196,10 @@ void cmTest::DefineProperties(cmake *cm)
      "If set to true, this will invert the pass/fail flag of the test.",
      "This property can be used for tests that are expected to fail and "
      "return a non zero return code.");
+
+  cm->DefineProperty
+    ("WORKING_DIRECTORY", cmProperty::TEST,
+     "The directory from which the test executable will be called.",
+     "If this is not set it is called from the directory the test executable "
+     "is located in.");
 }

Source/cmVisualStudio10TargetGenerator.cxx

@@ -376,13 +376,7 @@ cmVisualStudio10TargetGenerator::WriteCustomRule(cmSourceFile* source,
       i != configs->end(); ++i)
     {
     std::string script =
-      cmVS10EscapeXML(
+      cmVS10EscapeXML(lg->ConstructScript(command, i->c_str()));
-        lg->ConstructScript(command.GetCommandLines(),
-                            command.GetWorkingDirectory(),
-                            i->c_str(),
-                            command.GetEscapeOldStyle(),
-                            command.GetEscapeAllowMakeVars())
-        );
     this->WritePlatformConfigTag("Message",i->c_str(), 3);
     (*this->BuildFileStream ) << cmVS10EscapeXML(comment) << "</Message>\n";
     this->WritePlatformConfigTag("Command", i->c_str(), 3);
@@ -700,7 +694,7 @@ void cmVisualStudio10TargetGenerator::WriteCLSources()
         }
       (*this->BuildFileStream ) << sourceFile << "\"";
       // ouput any flags specific to this source file
-      if(cl && this->OutputSourceSpecificFlags(*source))
+      if(!header && cl && this->OutputSourceSpecificFlags(*source))
         {
         // if the source file has specific flags the tag
         // is ended on a new line
@@ -1472,13 +1466,7 @@ void cmVisualStudio10TargetGenerator::WriteEvent(
     script += pre;
     pre = "\n";
     script +=
-      cmVS10EscapeXML(
+      cmVS10EscapeXML(lg->ConstructScript(command, configName.c_str()));
-        lg->ConstructScript(command.GetCommandLines(),
-                            command.GetWorkingDirectory(),
-                            configName.c_str(),
-                            command.GetEscapeOldStyle(),
-                            command.GetEscapeAllowMakeVars())
-        );
     }
   comment = cmVS10EscapeComment(comment);
   this->WriteString("<Message>",3);

Source/cmVisualStudioGeneratorOptions.cxx

@@ -85,17 +85,15 @@ void cmVisualStudioGeneratorOptions::SetVerboseMakefile(bool verbose)
   // was not given explicitly in the flags we want to add an attribute
   // to the generated project to disable logo suppression.  Otherwise
   // the GUI default is to enable suppression.
+  //
+  // Avoid this on Visual Studio 10 (and later!) because it results in:
+  //   "cl ... warning D9035: option 'nologo-' has been deprecated"
+  //
   if(verbose &&
+     this->Version != 10 &&
      this->FlagMap.find("SuppressStartupBanner") == this->FlagMap.end())
     {
-    if(this->Version == 10)
+    this->FlagMap["SuppressStartupBanner"] = "FALSE";
-      {
-      this->FlagMap["SuppressStartupBanner"] = "false";
-      }
-    else
-      {
-      this->FlagMap["SuppressStartupBanner"] = "FALSE";
-      }
     }
 }
 

Source/kwsys/Registry.cxx

@@ -401,8 +401,9 @@ bool RegistryHelper::Open(const char *toplevel, const char *subkey,
       }
     else
       {
+      char lpClass[] = "";
       res = ( RegCreateKeyEx(scope, str.str().c_str(),
-          0, "", REG_OPTION_NON_VOLATILE, KEY_READ|KEY_WRITE,
+          0, lpClass, REG_OPTION_NON_VOLATILE, KEY_READ|KEY_WRITE,
           NULL, &this->HKey, &dwDummy) == ERROR_SUCCESS );
       }
     if ( res != 0 )

Source/kwsys/SystemTools.cxx

@@ -734,10 +734,11 @@ bool SystemTools::WriteRegistryValue(const char *key, const char *value,
   
   HKEY hKey;
   DWORD dwDummy;
+  char lpClass[] = "";
   if(RegCreateKeyEx(primaryKey, 
                     second.c_str(), 
                     0, 
-                    "",
+                    lpClass,
                     REG_OPTION_NON_VOLATILE,
                     SystemToolsMakeRegistryMode(KEY_WRITE, view),
                     NULL,

Source/kwsys/kwsysDateStamp.cmake

@@ -12,10 +12,10 @@
 #=============================================================================
 
 # KWSys version date year component.  Format is CCYY.
-SET(KWSYS_DATE_STAMP_YEAR  2010)
+SET(KWSYS_DATE_STAMP_YEAR  2011)
 
 # KWSys version date month component.  Format is MM.
-SET(KWSYS_DATE_STAMP_MONTH 12)
+SET(KWSYS_DATE_STAMP_MONTH 01)
 
 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   21)
+SET(KWSYS_DATE_STAMP_DAY   03)

Tests/CMakeLists.txt

@@ -45,18 +45,18 @@ IF(BUILD_TESTING)
   SET(TEST_BUILD_DIRS)
 
   # Should the long tests be run?
-  OPTION(CMAKE_RUN_LONG_TESTS 
+  OPTION(CMAKE_RUN_LONG_TESTS
     "Should the long tests be run (such as Bootstrap)." ON)
   MARK_AS_ADVANCED(CMAKE_RUN_LONG_TESTS)
 
   IF (CMAKE_RUN_LONG_TESTS)
-    OPTION(CTEST_TEST_CTEST 
+    OPTION(CTEST_TEST_CTEST
-      "Should the tests that run a full sub ctest process be run?" 
+      "Should the tests that run a full sub ctest process be run?"
       OFF)
     MARK_AS_ADVANCED(CTEST_TEST_CTEST)
 
     OPTION(TEST_KDE4_STABLE_BRANCH
-      "Should the KDE4 stable branch test be run?" 
+      "Should the KDE4 stable branch test be run?"
       OFF)
     MARK_AS_ADVANCED(TEST_KDE4_STABLE_BRANCH)
   ENDIF (CMAKE_RUN_LONG_TESTS)
@@ -217,7 +217,7 @@ IF(BUILD_TESTING)
 
   # If we are running right now with a UnixMakefiles based generator,
   # build the "Simple" test with the ExtraGenerators, if available
-  # This doesn't test whether the generated project files work (unfortunately), 
+  # This doesn't test whether the generated project files work (unfortunately),
   # mainly it tests that cmake doesn't crash when generating these project files.
   IF(${CMAKE_TEST_GENERATOR} MATCHES "Unix Makefiles"  OR  ${CMAKE_TEST_GENERATOR} MATCHES "KDevelop")
     # check which generators we have
@@ -288,10 +288,10 @@ IF(BUILD_TESTING)
     ADD_TEST(SubProject-Stage2  ${CMAKE_CTEST_COMMAND}
       --build-and-test
       "${CMake_SOURCE_DIR}/Tests/SubProject/foo"
-      "${CMake_BINARY_DIR}/Tests/SubProject/foo" 
+      "${CMake_BINARY_DIR}/Tests/SubProject/foo"
       --build-generator ${CMAKE_TEST_GENERATOR}
       --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
-      --build-nocmake 
+      --build-nocmake
       --build-project foo
       --build-target foo
       --test-command foo
@@ -349,7 +349,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --build-project TargetName
-    --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files 
+    --test-command ${CMAKE_CMAKE_COMMAND} -E compare_files
     ${CMake_SOURCE_DIR}/Tests/TargetName/scripts/hello_world
     ${CMake_BINARY_DIR}/Tests/TargetName/scripts/hello_world)
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TargetName")
@@ -361,7 +361,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     --build-two-config
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
-    --build-project LibName 
+    --build-project LibName
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/LibName/lib"
     --test-command foobar
     )
@@ -374,7 +374,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     --build-two-config
     --build-generator ${CMAKE_TEST_GENERATOR}
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
-    --build-project CustComDepend 
+    --build-project CustComDepend
     --build-exe-dir "${CMake_BINARY_DIR}/Tests/CustComDepend/bin"
     --test-command foo bar.c
     )
@@ -453,7 +453,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BuildDepends")
-  
+
   SET(SimpleInstallInstallDir
     "${CMake_BINARY_DIR}/Tests/SimpleInstall/InstallDirectory")
   ADD_TEST(SimpleInstall ${CMAKE_CTEST_COMMAND}
@@ -488,6 +488,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
   #
   set(CTEST_RUN_CPackComponents ${CTEST_TEST_CPACK})
   set(CTEST_package_X11_TEST ${CTEST_TEST_CPACK})
+  set(CTEST_RUN_CPackComponentsForAll ${CTEST_TEST_CPACK})
 
   find_program(NSIS_MAKENSIS_EXECUTABLE NAMES makensis
     PATHS [HKEY_LOCAL_MACHINE\\SOFTWARE\\NSIS]
@@ -536,6 +537,34 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponents")
   ENDIF(CTEST_RUN_CPackComponents)
 
+  IF(CTEST_RUN_CPackComponentsForAll)
+    set(CPackComponentsForAll_EXTRA_OPTIONS)
+
+    set(CPackRun_CPackGen  "-DCPackGen=ZIP")
+    set(CPackRun_CPackCommand "-DCPackCommand=${CMAKE_CPACK_COMMAND}")
+    set(CPackRun_CPackComponentWay "-DCPackComponentWay=default")
+
+    ADD_TEST(CPackComponentsForAll-ZIP-default ${CMAKE_CTEST_COMMAND}
+      --build-and-test
+      "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
+      "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/buildZIP-NoComponent"
+      --build-generator ${CMAKE_TEST_GENERATOR}
+      --build-project CPackComponentsForAll
+      --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
+      --build-options
+        -DCPACK_BINARY_ZIP:BOOL=ON
+        ${CPackComponentsForAll_EXTRA_OPTIONS}
+        --graphviz=CPackComponentsForAll.dot
+      --test-command ${CMAKE_CMAKE_COMMAND}
+        "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/buildZIP-NoComponent"
+        "${CPackRun_CPackCommand}"
+        "${CPackRun_CPackGen}"
+        "${CPackRun_CPackComponentWay}"
+        -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
+
+    LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll")
+  ENDIF(CTEST_RUN_CPackComponentsForAll)
+
   # By default, turn this test off (because it takes a long time...)
   #
   if(NOT DEFINED CTEST_RUN_CPackTestAllGenerators)
@@ -781,6 +810,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
     --test-command ${CMAKE_CTEST_COMMAND} -C \${CTEST_CONFIGURATION_TYPE}
     )
+  SET_TESTS_PROPERTIES(testing PROPERTIES PASS_REGULAR_EXPRESSION "Passed")
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/Testing")
 
   ADD_TEST(wrapping  ${CMAKE_CTEST_COMMAND}
@@ -856,7 +886,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
 # RPATH isn't supported under Syllable, so the tests don't
 # find their libraries. In order to fix that LIBRARY_OUTPUT_DIR
 # in the tests would have to be adjusted to ${EXECUTABLE_OUTPUT_DIR}/lib .
-# For now we just require on Syllable that the user adjusts the DLL_PATH 
+# For now we just require on Syllable that the user adjusts the DLL_PATH
 # environment variable, so except the two tests below all other tests will succeed.
 
     SET(_DLL_PATH "$ENV{DLL_PATH}")
@@ -965,14 +995,14 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
 
   # only add this test on platforms that support it
   # some old versions of make simply cannot handle spaces in paths
-  IF (MAKE_IS_GNU OR 
+  IF (MAKE_IS_GNU OR
       "${CMAKE_TEST_MAKEPROGRAM}" MATCHES "nmake|gmake|wmake" OR
       "${CMAKE_TEST_GENERATOR}" MATCHES "Visual Studio|XCode|Borland")
     ADD_TEST(SubDirSpaces ${CMAKE_CTEST_COMMAND}
       --build-and-test
       "${CMake_SOURCE_DIR}/Tests/SubDirSpaces"
       "${CMake_BINARY_DIR}/Tests/SubDirSpaces"
-      --build-exe-dir 
+      --build-exe-dir
       "${CMake_BINARY_DIR}/Tests/SubDirSpaces/Executable Sources"
       --build-generator ${CMAKE_TEST_GENERATOR}
       --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
@@ -1078,7 +1108,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
       "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest"
       --build-two-config
       --build-generator ${CMAKE_TEST_GENERATOR}
-      --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM} 
+      --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
       --build-project BundleGeneratorTest
       --build-target package
       --build-options "-DCMAKE_INSTALL_PREFIX:PATH=${CMake_BINARY_DIR}/Tests/BundleGeneratorTest/InstallDirectory"
@@ -1086,6 +1116,19 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleGeneratorTest")
   ENDIF(APPLE AND CTEST_TEST_CPACK)
 
+  ADD_TEST(TestsWorkingDirectory ${CMAKE_CTEST_COMMAND}
+    --build-and-test
+    "${CMake_SOURCE_DIR}/Tests/TestsWorkingDirectory"
+    "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
+    --build-generator ${CMAKE_TEST_GENERATOR}
+    --build-project TestsWorkingDirectoryProj
+    --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
+    --build-exe-dir "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory"
+    --force-new-ctest-process
+    --test-command ${CMAKE_CTEST_COMMAND} -V
+    )
+  LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/TestsWorkingDirectory")
+
   # Make sure CTest can handle a test with no newline in output.
   ADD_TEST(CTest.NoNewline
     ${CMAKE_CMAKE_COMMAND} -E echo_append "This line has no newline!")
@@ -1300,7 +1343,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     SET_TESTS_PROPERTIES(CTestTestCrash PROPERTIES
       PASS_REGULAR_EXPRESSION "SegFault")
   ENDIF(CMAKE_TEST_GENERATOR MATCHES "Watcom WMake")
-    
+
   CONFIGURE_FILE(
     "${CMake_SOURCE_DIR}/Tests/CTestTestBadExe/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTestBadExe/test.cmake"
@@ -1378,7 +1421,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
   #make sure all 3 subdirs were added
   SET_TESTS_PROPERTIES(CTestTestSubdir PROPERTIES
     PASS_REGULAR_EXPRESSION "0 tests failed out of 3")
-    
+
   CONFIGURE_FILE(
     "${CMake_SOURCE_DIR}/Tests/CTestTestTimeout/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTestTimeout/test.cmake"
@@ -1391,6 +1434,17 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
   SET_TESTS_PROPERTIES(CTestTestTimeout PROPERTIES
     PASS_REGULAR_EXPRESSION "TestTimeout *\\.+ *\\*\\*\\*Timeout.*CheckChild *\\.+ *Passed")
 
+  CONFIGURE_FILE(
+    "${CMake_SOURCE_DIR}/Tests/CTestTestZeroTimeout/test.cmake.in"
+    "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake"
+    @ONLY ESCAPE_QUOTES)
+  ADD_TEST(CTestTestZeroTimeout ${CMAKE_CTEST_COMMAND}
+    -S "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/test.cmake" -V
+    --output-log
+    "${CMake_BINARY_DIR}/Tests/CTestTestZeroTimeout/testOutput.log")
+  SET_TESTS_PROPERTIES(CTestTestZeroTimeout PROPERTIES
+    FAIL_REGULAR_EXPRESSION "\\*\\*\\*Timeout")
+
   CONFIGURE_FILE(
     "${CMake_SOURCE_DIR}/Tests/CTestTestDepends/test.cmake.in"
     "${CMake_BINARY_DIR}/Tests/CTestTestDepends/test.cmake"
@@ -1573,7 +1627,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
 
     ENDIF(UNIX)
   ENDIF (CMAKE_RUN_LONG_TESTS AND TEST_KDE4_STABLE_BRANCH)
-  
+
   IF("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
     SET(CMAKE_SKIP_BOOTSTRAP_TEST 1)
   ENDIF("${CMAKE_TEST_GENERATOR}" MATCHES Xcode)
@@ -1600,7 +1654,7 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
       --build-noclean
       --build-makeprogram ${bootstrap}
       --build-generator "${CMAKE_TEST_GENERATOR}"
-      --test-command 
+      --test-command
       ${CMake_BINARY_DIR}/Tests/BootstrapTest/Bootstrap.cmk/cmake)
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BootstrapTest")
     # Make this test run early during parallel execution

Tests/CPackComponentsForAll/CMakeLists.txt

@@ -0,0 +1,120 @@
+# CPack Example: User-selectable Installation Components
+#
+# In this example, we have a simple library (mylib) with an example
+# application (mylibapp). We create a binary installer (a CPack Generator)
+# which supports CPack components.
+#
+# Depending on the CPack generator and on some CPACK_xxx var values
+# the generator may produce a single (NSIS, PackageMaker)
+# or several package files (Archive Generators, RPM, DEB)
+cmake_minimum_required(VERSION 2.8.3.20101130 FATAL_ERROR)
+project(CPackComponentsForAll)
+
+# Create the mylib library
+add_library(mylib mylib.cpp)
+
+# Create the mylibapp application
+add_executable(mylibapp mylibapp.cpp)
+target_link_libraries(mylibapp mylib)
+
+# Duplicate of mylibapp application
+# which won't be put in any component (?mistake?)
+add_executable(mylibapp2 mylibapp.cpp)
+target_link_libraries(mylibapp2 mylib)
+
+# Create installation targets. Note that we put each kind of file
+# into a different component via COMPONENT. These components will
+# be used to create the installation components.
+install(TARGETS mylib
+  ARCHIVE
+  DESTINATION lib
+  COMPONENT libraries)
+install(TARGETS mylibapp
+  RUNTIME
+  DESTINATION bin
+  COMPONENT applications)
+
+# This application does not belong to any component
+# thus (as of cmake 2.8.2) it will be left "uninstalled"
+# by a component-aware installer unless a
+# CPACK_MONOLITHIC_INSTALL=1 is set (at cmake time).
+install(TARGETS mylibapp2
+  RUNTIME
+  DESTINATION bin)
+
+install(FILES mylib.h
+  DESTINATION include
+  COMPONENT headers)
+
+# CPack boilerplate for this project
+set(CPACK_PACKAGE_NAME "MyLib")
+set(CPACK_PACKAGE_CONTACT "None")
+set(CPACK_PACKAGE_VENDOR "CMake.org")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "MyLib - CPack Component Installation Example")
+set(CPACK_PACKAGE_VERSION "1.0.2")
+set(CPACK_PACKAGE_VERSION_MAJOR "1")
+set(CPACK_PACKAGE_VERSION_MINOR "0")
+set(CPACK_PACKAGE_VERSION_PATCH "2")
+set(CPACK_PACKAGE_INSTALL_DIRECTORY "CPack Component Example")
+
+# Tell CPack all of the components to install. The "ALL"
+# refers to the fact that this is the set of components that
+# will be included when CPack is instructed to put everything
+# into the binary installer (the default behavior).
+set(CPACK_COMPONENTS_ALL applications libraries headers Unspecified)
+
+# Set the displayed names for each of the components to install.
+# These will be displayed in the list of components inside the installer.
+set(CPACK_COMPONENT_APPLICATIONS_DISPLAY_NAME "MyLib Application")
+set(CPACK_COMPONENT_LIBRARIES_DISPLAY_NAME "Libraries")
+set(CPACK_COMPONENT_HEADERS_DISPLAY_NAME "C++ Headers")
+
+# Provide descriptions for each of the components to install.
+# When the user hovers the mouse over the name of a component,
+# the description will be shown in the "Description" box in the
+# installer. If no descriptions are provided, the "Description"
+# box will be removed.
+set(CPACK_COMPONENT_APPLICATIONS_DESCRIPTION
+  "An extremely useful application that makes use of MyLib")
+set(CPACK_COMPONENT_LIBRARIES_DESCRIPTION
+  "Static libraries used to build programs with MyLib")
+set(CPACK_COMPONENT_HEADERS_DESCRIPTION
+  "C/C++ header files for use with MyLib")
+
+# Put the components into two different groups: "Runtime" and "Development"
+set(CPACK_COMPONENT_APPLICATIONS_GROUP "Runtime")
+set(CPACK_COMPONENT_LIBRARIES_GROUP "Development")
+set(CPACK_COMPONENT_HEADERS_GROUP "Development")
+
+# Expand the "Development" group by default, since we have so few components.
+# Also, provide this group with a description.
+set(CPACK_COMPONENT_GROUP_DEVELOPMENT_EXPANDED ON)
+set(CPACK_COMPONENT_GROUP_DEVELOPMENT_DESCRIPTION
+  "All of the tools you'll ever need to develop software")
+
+# It doesn't make sense to install the headers without the libraries
+# (because you could never use the headers!), so make the headers component
+# depend on the libraries component.
+set(CPACK_COMPONENT_HEADERS_DEPENDS libraries)
+
+# Create two installation types with pre-selected components.
+# The "Developer" installation has just the library and headers,
+# while the "Full" installation has everything.
+set(CPACK_ALL_INSTALL_TYPES Full Developer)
+set(CPACK_INSTALL_TYPE_FULL_DISPLAY_NAME "Everything")
+set(CPACK_COMPONENT_LIBRARIES_INSTALL_TYPES Developer Full)
+set(CPACK_COMPONENT_HEADERS_INSTALL_TYPES Developer Full)
+set(CPACK_COMPONENT_APPLICATIONS_INSTALL_TYPES Full)
+
+# We may use the CPack specific config file in order
+# to tailor CPack behavio on a CPack generator specific way
+# (Behavior would be different for RPM or TGZ or DEB ...)
+if (USE_CPACK_PROJECT_CONFIG)
+  # Setup project specific CPack-time CPack Config file.
+  configure_file(${MyLib_SOURCE_DIR}/MyLibCPackConfig.cmake.in
+    ${MyLib_BINARY_DIR}/MyLibCPackConfig.cmake
+    @ONLY)
+  set(CPACK_PROJECT_CONFIG_FILE ${MyLib_BINARY_DIR}/MyLibCPackConfig.cmake)
+endif (USE_CPACK_PROJECT_CONFIG)
+# Include CPack to introduce the appropriate targets
+include(CPack)

Tests/CPackComponentsForAll/MyLibCPackConfig.cmake.in

@@ -0,0 +1,7 @@
+if(CPACK_GENERATOR MATCHES "ZIP")
+#  set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE 1)
+endif(CPACK_GENERATOR MATCHES "ZIP")
+
+if(CPACK_GENERATOR MATCHES "TGZ")
+  set(CPACK_MONOLITHIC_INSTALL 1)
+endif(CPACK_GENERATOR MATCHES "TGZ")

Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake

@@ -0,0 +1,73 @@
+message(STATUS "=============================================================================")
+message(STATUS "CTEST_FULL_OUTPUT (Avoid ctest truncation of output)")
+message(STATUS "")
+
+if(NOT CPackComponentsForAll_BINARY_DIR)
+  message(FATAL_ERROR "CPackComponentsForAll_BINARY_DIR not set")
+endif(NOT CPackComponentsForAll_BINARY_DIR)
+
+if(NOT CPackGen)
+  message(FATAL_ERROR "CPackGen not set")
+endif(NOT CPackGen)
+get_filename_component(CPACK_LOCATION ${CMAKE_COMMAND} PATH)
+set(CPackCommand "${CPACK_LOCATION}/cpack")
+message("cpack = ${CPackCommand}")
+if(NOT CPackCommand)
+  message(FATAL_ERROR "CPackCommand not set")
+endif(NOT CPackCommand)
+
+if(NOT CPackComponentWay)
+  message(FATAL_ERROR "CPackComponentWay not set")
+endif(NOT CPackComponentWay)
+
+set(expected_file_mask "")
+# The usual default behavior is to expect a single file
+# Then some specific generators (Archive, RPM, ...)
+# May produce several numbers of files depending on
+# CPACK_COMPONENT_xxx values
+set(expected_count 1)
+set(config_type $ENV{CMAKE_CONFIG_TYPE})
+set(config_args )
+if(config_type)
+  set(config_args -C ${config_type})
+endif()
+message(" ${config_args}")
+execute_process(COMMAND ${CPackCommand} -G ${CPackGen} ${config_args}
+    RESULT_VARIABLE CPack_result
+    OUTPUT_VARIABLE CPack_output
+    ERROR_VARIABLE CPack_error
+    WORKING_DIRECTORY ${CPackComponentsForAll_BINARY_DIR})
+
+if (CPack_result)
+  message(FATAL_ERROR "error: CPack execution went wrong!, CPack_output=${CPack_output}, CPack_error=${CPack_error}")
+else (CPack_result)
+  message(STATUS "CPack_output=${CPack_output}")
+endif(CPack_result)
+
+if(CPackGen MATCHES "ZIP")
+    set(expected_file_mask "${CPackComponentsForAll_BINARY_DIR}/MyLib-*.zip")
+    if (${CPackComponentWay} STREQUAL "default")
+        set(expected_count 1)
+    endif(${CPackComponentWay} STREQUAL "default")
+endif(CPackGen MATCHES "ZIP")
+
+# Now verify if the number of expected file is OK
+# - using expected_file_mask and
+# - expected_count
+if(expected_file_mask)
+  file(GLOB expected_file "${expected_file_mask}")
+
+  message(STATUS "expected_count='${expected_count}'")
+  message(STATUS "expected_file='${expected_file}'")
+  message(STATUS "expected_file_mask='${expected_file_mask}'")
+
+  if(NOT expected_file)
+    message(FATAL_ERROR "error: expected_file=${expected_file} does not exist: CPackComponentsForAll test fails. (CPack_output=${CPack_output}, CPack_error=${CPack_error}")
+  endif(NOT expected_file)
+
+  list(LENGTH expected_file actual_count)
+  message(STATUS "actual_count='${actual_count}'")
+  if(NOT actual_count EQUAL expected_count)
+    message(FATAL_ERROR "error: expected_count=${expected_count} does not match actual_count=${actual_count}: CPackComponents test fails. (CPack_output=${CPack_output}, CPack_error=${CPack_error})")
+  endif(NOT actual_count EQUAL expected_count)
+endif(expected_file_mask)

Tests/CPackComponentsForAll/mylib.cpp

@@ -0,0 +1,7 @@
+#include "mylib.h"
+#include "stdio.h"
+
+void mylib_function()
+{
+  printf("This is mylib");
+}

Tests/CPackComponentsForAll/mylib.h

@@ -0,0 +1 @@
+void mylib_function();

Tests/CPackComponentsForAll/mylibapp.cpp

@@ -0,0 +1,6 @@
+#include "mylib.h"
+
+int main()
+{
+  mylib_function();
+}

Tests/CTestTestZeroTimeout/CMakeLists.txt

@@ -0,0 +1,8 @@
+CMAKE_MINIMUM_REQUIRED (VERSION 2.6)
+PROJECT (CTestTestZeroTimeout)
+INCLUDE (CTest)
+
+ADD_EXECUTABLE (Sleep sleep.c)
+
+ADD_TEST (TestExplicitZeroTimeout Sleep)
+SET_TESTS_PROPERTIES(TestExplicitZeroTimeout PROPERTIES TIMEOUT 0)

Tests/CTestTestZeroTimeout/CTestConfig.cmake

@@ -0,0 +1,7 @@
+set(CTEST_PROJECT_NAME "CTestTestZeroTimeout")
+set(CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
+set(CTEST_DART_SERVER_VERSION "2")
+set(CTEST_DROP_METHOD "http")
+set(CTEST_DROP_SITE "www.cdash.org")
+set(CTEST_DROP_LOCATION "/CDash/submit.php?project=PublicDashboard")
+set(CTEST_DROP_SITE_CDASH TRUE)

Tests/CTestTestZeroTimeout/sleep.c

@@ -0,0 +1,16 @@
+#if defined(_WIN32)
+# include <windows.h>
+#else
+# include <unistd.h>
+#endif
+
+/* sleeps for 5 seconds */
+int main(int argc, char** argv)
+{
+#if defined(_WIN32)
+  Sleep(5000);
+#else
+  sleep(5);
+#endif
+  return 0;
+}

Tests/CTestTestZeroTimeout/test.cmake.in

@@ -0,0 +1,23 @@
+CMAKE_MINIMUM_REQUIRED(VERSION 2.1)
+
+# Settings:
+SET(CTEST_DASHBOARD_ROOT                "@CMake_BINARY_DIR@/Tests/CTestTest")
+SET(CTEST_SITE                          "@SITE@")
+SET(CTEST_BUILD_NAME                    "CTestTest-@BUILDNAME@-ZeroTimeout")
+
+SET(CTEST_SOURCE_DIRECTORY              "@CMake_SOURCE_DIR@/Tests/CTestTestZeroTimeout")
+SET(CTEST_BINARY_DIRECTORY              "@CMake_BINARY_DIR@/Tests/CTestTestZeroTimeout")
+SET(CTEST_CVS_COMMAND                   "@CVSCOMMAND@")
+SET(CTEST_CMAKE_GENERATOR               "@CMAKE_TEST_GENERATOR@")
+SET(CTEST_BUILD_CONFIGURATION           "$ENV{CMAKE_CONFIG_TYPE}")
+SET(CTEST_MEMORYCHECK_COMMAND           "@MEMORYCHECK_COMMAND@")
+SET(CTEST_MEMORYCHECK_SUPPRESSIONS_FILE "@MEMORYCHECK_SUPPRESSIONS_FILE@")
+SET(CTEST_MEMORYCHECK_COMMAND_OPTIONS   "@MEMORYCHECK_COMMAND_OPTIONS@")
+SET(CTEST_COVERAGE_COMMAND              "@COVERAGE_COMMAND@")
+SET(CTEST_NOTES_FILES                   "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")
+SET(CTEST_TEST_TIMEOUT                  2)
+
+CTEST_START(Experimental)
+CTEST_CONFIGURE(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
+CTEST_BUILD(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)
+CTEST_TEST(BUILD "${CTEST_BINARY_DIRECTORY}" RETURN_VALUE res)

Tests/Complex/Executable/CMakeLists.txt

@@ -49,10 +49,17 @@ LINK_LIBRARIES(${COMPLEX_LIBS})
 SET_SOURCE_FILES_PROPERTIES(complex_nobuild.cxx PROPERTIES
   HEADER_FILE_ONLY 1)
 
+# Test forcing a .c file to not build.
+# This makes sure a mixed language library is created
+# with header file only sources
+SET_SOURCE_FILES_PROPERTIES(complex_nobuild.c PROPERTIES
+  HEADER_FILE_ONLY 1)
+
 ADD_EXECUTABLE(A A.cxx A.hh A.h A.txt)
 ADD_EXECUTABLE(complex complex testcflags.c )
 #  Sub1/NameConflictTest.c Sub2/NameConflictTest.c)
-ADD_EXECUTABLE(complex.file complex.file.cxx complex_nobuild.cxx)
+ADD_EXECUTABLE(complex.file complex.file.cxx complex_nobuild.cxx
+  complex_nobuild.c)
 IF(COMPLEX_TEST_CMAKELIB)
   TARGET_LINK_LIBRARIES(complex CMakeLib cmsys cmexpat cmzlib cmlibarchive cmbzip2 cmcurl)
 ENDIF(COMPLEX_TEST_CMAKELIB)

Tests/Complex/Executable/complex_nobuild.c

@@ -0,0 +1 @@
+#error "This file should not be compiled."

Tests/CustomCommand/CMakeLists.txt

@@ -423,3 +423,16 @@ ADD_CUSTOM_TARGET(DifferentName ALL
   )
 #
 # </SameNameTest>
+
+# Per-config target name and generator expressions.
+ADD_SUBDIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../PerConfig PerConfig)
+ADD_CUSTOM_COMMAND(
+  OUTPUT perconfig.out
+  COMMAND ${PerConfig_COMMAND}
+  DEPENDS ${PerConfig_DEPENDS}
+  VERBATIM
+  )
+SET_PROPERTY(SOURCE perconfig.out PROPERTY SYMBOLIC 1)
+ADD_CUSTOM_TARGET(perconfig_target ALL
+  COMMAND ${CMAKE_COMMAND} -E echo "perconfig=$<TARGET_FILE:perconfig>" "config=$<CONFIGURATION>"
+  DEPENDS perconfig.out)

Tests/Jump/Library/Shared/CMakeLists.txt

@@ -1,8 +1,8 @@
 ADD_LIBRARY(jumpShared SHARED jumpShared.cxx)
 
-IF(WIN32)
+IF(WIN32 OR CYGWIN)
   SET(SHARED_MUST_BE_IN_EXE_DIR 1)
-ENDIF(WIN32)
+ENDIF()
 
 IF(APPLE)
   SET(SHARED_MUST_BE_IN_EXE_DIR 1)

Tests/PerConfig/CMakeLists.txt

@@ -0,0 +1,34 @@
+project(PerConfig C)
+
+# Targets with per-configuration names.
+ADD_LIBRARY(pcStatic STATIC pcStatic.c)
+SET_PROPERTY(TARGET pcStatic PROPERTY RELEASE_POSTFIX -opt)
+SET_PROPERTY(TARGET pcStatic PROPERTY DEBUG_POSTFIX -dbg)
+ADD_LIBRARY(pcShared SHARED pcShared.c)
+SET_PROPERTY(TARGET pcShared PROPERTY RELEASE_POSTFIX -opt)
+SET_PROPERTY(TARGET pcShared PROPERTY DEBUG_POSTFIX -dbg)
+SET_PROPERTY(TARGET pcShared PROPERTY VERSION 1.2)
+SET_PROPERTY(TARGET pcShared PROPERTY SOVERSION 3)
+IF(UNIX AND NOT CYGWIN)
+  SET(soname_file -DpcShared_soname_file=$<TARGET_SONAME_FILE:pcShared>)
+ENDIF()
+ADD_EXECUTABLE(perconfig perconfig.c)
+TARGET_LINK_LIBRARIES(perconfig pcStatic pcShared)
+SET_PROPERTY(TARGET perconfig PROPERTY RELEASE_POSTFIX -opt)
+SET_PROPERTY(TARGET perconfig PROPERTY DEBUG_POSTFIX -dbg)
+
+SET(PerConfig_COMMAND
+  ${CMAKE_COMMAND}
+    -Dconfiguration=$<CONFIGURATION>
+    -Dperconfig_file_dir=$<TARGET_FILE_DIR:perconfig>
+    -Dperconfig_file_name=$<TARGET_FILE_NAME:perconfig>
+    -Dperconfig_file=$<TARGET_FILE:perconfig>
+    -DpcStatic_file=$<TARGET_FILE:pcStatic>
+    -DpcStatic_linker_file=$<TARGET_LINKER_FILE:pcStatic>
+    -DpcShared_file=$<TARGET_FILE:pcShared>
+    -DpcShared_linker_file=$<TARGET_LINKER_FILE:pcShared>
+    ${soname_file}
+    -P ${PerConfig_SOURCE_DIR}/perconfig.cmake
+    )
+SET(PerConfig_COMMAND "${PerConfig_COMMAND}" PARENT_SCOPE)
+SET(PerConfig_DEPENDS ${PerConfig_SOURCE_DIR}/perconfig.cmake perconfig pcStatic pcShared)

Tests/PerConfig/perconfig.cmake

@@ -10,7 +10,7 @@ foreach(v
     pcShared_linker_file
     pcShared_soname_file
     )
-  message("${v}=${${v}}")
+  message(STATUS "${v}=${${v}}")
 endforeach()
 
 # Verify that file names match as expected.

Tests/Testing/CMakeLists.txt

@@ -53,35 +53,7 @@ ADD_TEST(testing.1 ${Testing_BINARY_DIR}/bin/testing)
 #
 ADD_SUBDIRECTORY(Sub/Sub2)
 
-# Per-config target name test.
+# Per-config target name and generator expressions.
-ADD_LIBRARY(pcStatic STATIC pcStatic.c)
+ADD_SUBDIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../PerConfig PerConfig)
-SET_PROPERTY(TARGET pcStatic PROPERTY RELEASE_POSTFIX -opt)
-SET_PROPERTY(TARGET pcStatic PROPERTY DEBUG_POSTFIX -dbg)
-ADD_LIBRARY(pcShared SHARED pcShared.c)
-SET_PROPERTY(TARGET pcShared PROPERTY RELEASE_POSTFIX -opt)
-SET_PROPERTY(TARGET pcShared PROPERTY DEBUG_POSTFIX -dbg)
-SET_PROPERTY(TARGET pcShared PROPERTY VERSION 1.2)
-SET_PROPERTY(TARGET pcShared PROPERTY SOVERSION 3)
-IF(NOT WIN32)
-  SET(soname_file -DpcShared_soname_file=$<TARGET_SONAME_FILE:pcShared>)
-ENDIF()
-ADD_EXECUTABLE(perconfig perconfig.c)
-TARGET_LINK_LIBRARIES(perconfig pcStatic pcShared)
-SET_PROPERTY(TARGET perconfig PROPERTY RELEASE_POSTFIX -opt)
-SET_PROPERTY(TARGET perconfig PROPERTY DEBUG_POSTFIX -dbg)
 ADD_TEST(NAME testing.perconfig COMMAND perconfig)
-
+ADD_TEST(NAME testing.driver COMMAND ${PerConfig_COMMAND})
-# Test using a driver script with generator expressions.
-ADD_TEST(NAME testing.driver
-  COMMAND ${CMAKE_COMMAND}
-    -Dconfiguration=$<CONFIGURATION>
-    -Dperconfig_file_dir=$<TARGET_FILE_DIR:perconfig>
-    -Dperconfig_file_name=$<TARGET_FILE_NAME:perconfig>
-    -Dperconfig_file=$<TARGET_FILE:perconfig>
-    -DpcStatic_file=$<TARGET_FILE:pcStatic>
-    -DpcStatic_linker_file=$<TARGET_LINKER_FILE:pcStatic>
-    -DpcShared_file=$<TARGET_FILE:pcShared>
-    -DpcShared_linker_file=$<TARGET_LINKER_FILE:pcShared>
-    ${soname_file}
-    -P ${Testing_SOURCE_DIR}/driver.cmake
-  )

Tests/Testing/Sub/Sub2/CMakeLists.txt

@@ -3,3 +3,15 @@
 #
 ADD_EXECUTABLE(testing2 testing2.cxx)
 ADD_TEST(testing.2 ${Testing_BINARY_DIR}/bin/testing2)
+
+add_test(NotCycle.a ${CMAKE_COMMAND} -E echo a)
+add_test(NotCycle.test1 ${CMAKE_COMMAND} -E echo test1)
+set_property(TEST NotCycle.test1 PROPERTY DEPENDS NotCycle.a)
+
+add_test(NotCycle.b ${CMAKE_COMMAND} -E echo b)
+add_test(NotCycle.test2 ${CMAKE_COMMAND} -E echo test2)
+set_property(TEST NotCycle.test2 PROPERTY DEPENDS NotCycle.b NotCycle.test1)
+
+add_test(NotCycle.c ${CMAKE_COMMAND} -E echo c)
+add_test(NotCycle.test3 ${CMAKE_COMMAND} -E echo test3)
+set_property(TEST NotCycle.test3 PROPERTY DEPENDS NotCycle.c NotCycle.test1 NotCycle.test2)

Tests/TestsWorkingDirectory/CMakeLists.txt

@@ -0,0 +1,52 @@
+cmake_minimum_required(VERSION 2.6)
+project(TestsWorkingDirectoryProj)
+
+add_executable(WorkingDirectory main.c)
+
+enable_testing()
+
+set(EXECUTABLE_OUTPUT_PATH "${CMAKE_BINARY_DIR}/bin")
+
+add_test(NAME WorkingDirectory1 COMMAND WorkingDirectory)
+set_tests_properties(WorkingDirectory1 PROPERTIES
+  WORKING_DIRECTORY "${CMAKE_BINARY_DIR}"
+  PASS_REGULAR_EXPRESSION "Working directory: -->${CMAKE_BINARY_DIR}<--"
+)
+
+string(REGEX REPLACE "/[^/]*$" "" _parent_dir "${CMAKE_BINARY_DIR}")
+
+add_test(NAME WorkingDirectory2 COMMAND WorkingDirectory)
+set_tests_properties(WorkingDirectory2 PROPERTIES
+  WORKING_DIRECTORY "${CMAKE_BINARY_DIR}/.."
+  PASS_REGULAR_EXPRESSION "Working directory: -->${_parent_dir}<--"
+)
+
+get_filename_component(_default_cwd "${EXECUTABLE_OUTPUT_PATH}" PATH)
+
+# FIXME: How to deal with /debug, /release, etc. with VS or XCode?
+if(${CMAKE_GENERATOR} MATCHES "Makefiles")
+add_test(WorkingDirectory3 ${EXECUTABLE_OUTPUT_PATH}/WorkingDirectory)
+set_tests_properties(WorkingDirectory3 PROPERTIES
+  PASS_REGULAR_EXPRESSION "Working directory: -->${_default_cwd}<--"
+)
+endif()
+
+add_test(NAME WorkingDirectory4 WORKING_DIRECTORY ${CMAKE_BINARY_DIR} COMMAND WorkingDirectory)
+set_tests_properties(WorkingDirectory4 PROPERTIES
+  PASS_REGULAR_EXPRESSION "Working directory: -->${CMAKE_BINARY_DIR}<--"
+)
+
+string(REGEX REPLACE "/[^/]*$" "" _parent_dir "${CMAKE_BINARY_DIR}")
+
+add_test(NAME WorkingDirectory5 WORKING_DIRECTORY ${CMAKE_BINARY_DIR}/.. COMMAND WorkingDirectory)
+set_tests_properties(WorkingDirectory5 PROPERTIES
+  PASS_REGULAR_EXPRESSION "Working directory: -->${_parent_dir}<--"
+)
+
+# FIXME: How to deal with /debug, /release, etc. with VS or XCode?
+if(${CMAKE_GENERATOR} MATCHES "Makefiles")
+add_test(WorkingDirectory6 ${EXECUTABLE_OUTPUT_PATH}/WorkingDirectory WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/..)
+set_tests_properties(WorkingDirectory6 PROPERTIES
+  PASS_REGULAR_EXPRESSION "Working directory: -->${_default_cwd}<--"
+)
+endif()

Tests/TestsWorkingDirectory/main.c

@@ -0,0 +1,66 @@
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(_WIN32) && (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__) || defined(__MINGW32__))
+
+#include <io.h>
+#include <direct.h>
+
+#if defined(__WATCOMC__)
+#include <direct.h>
+#define _getcwd getcwd
+#endif
+
+static const char* Getcwd(char* buf, unsigned int len)
+{
+  const char* ret = _getcwd(buf, len);
+  char* p = NULL;
+  if(!ret)
+    {
+    fprintf(stderr, "No current working directory.\n");
+    abort();
+    }
+  // make sure the drive letter is capital
+  if(strlen(buf) > 1 && buf[1] == ':')
+    {
+    buf[0] = toupper(buf[0]);
+    }
+  for(p = buf; *p; ++p)
+    {
+    if(*p == '\\')
+      {
+      *p = '/';
+      }
+    }
+  return ret;
+}
+
+#else
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+static const char* Getcwd(char* buf, unsigned int len)
+{
+  const char* ret = getcwd(buf, len);
+  if(!ret)
+    {
+    fprintf(stderr, "No current working directory\n");
+    abort();
+    }
+  return ret;
+}
+
+#endif
+
+int main(int argc, char *argv[])
+{
+  char buf[2048];
+  const char *cwd = Getcwd(buf, sizeof(buf));
+
+  fprintf(stdout, "Working directory: -->%s<--", cwd);
+
+  return 0;
+}

Tests/TryCompile/CMakeLists.txt

@@ -226,3 +226,9 @@ UNSET(CXX_BOGUS_FLAG CACHE)
 INCLUDE(CheckCXXCompilerFlag)
 CHECK_CXX_COMPILER_FLAG(${CXX_DD}-_this_is_not_a_flag_ CXX_BOGUS_FLAG)
 TEST_FAIL(CXX_BOGUS_FLAG "CHECK_CXX_COMPILER_FLAG() succeeded, but should have failed")
+
+IF("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU")
+  UNSET(C_STRICT_PROTOTYPES CACHE)
+  CHECK_C_COMPILER_FLAG("-Werror;-Wstrict-prototypes" C_STRICT_PROTOTYPES)
+  TEST_ASSERT(C_STRICT_PROTOTYPES "CHECK_C_COMPILER_FLAG failed -Werror -Wstrict-prototypes")
+ENDIF()

Utilities/cmcurl/CMake/OtherTests.cmake

@@ -193,14 +193,6 @@ SET(EXTRA_DEFINES "${EXTRA_DEFINES}\n${headers_hack}\n#define __unused5")
 CURL_CHECK_C_SOURCE_COMPILES("struct timeval ts;\nts.tv_sec  = 0;\nts.tv_usec = 0" HAVE_STRUCT_TIMEVAL)
 
 
-INCLUDE(CurlCheckCSourceRuns)
-SET(EXTRA_DEFINES)
-SET(HEADER_INCLUDES)
-IF(HAVE_SYS_POLL_H)
-  SET(HEADER_INCLUDES "sys/poll.h")
-ENDIF(HAVE_SYS_POLL_H)
-CURL_CHECK_C_SOURCE_RUNS("return poll((void *)0, 0, 10 /*ms*/)" HAVE_POLL_FINE)
-
 SET(HAVE_SIG_ATOMIC_T 1)
 SET(EXTRA_DEFINES)
 SET(HEADER_INCLUDES)

Utilities/cmcurl/CMakeLists.txt

@@ -521,42 +521,6 @@ MACRO(CURL_INTERNAL_TEST CURL_TEST)
   ENDIF("${CURL_TEST}" MATCHES "^${CURL_TEST}$")
 ENDMACRO(CURL_INTERNAL_TEST) 
 
-MACRO(CURL_INTERNAL_TEST_RUN CURL_TEST)
-  IF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
-    SET(MACRO_CHECK_FUNCTION_DEFINITIONS 
-      "-D${CURL_TEST} ${CMAKE_REQUIRED_FLAGS}")
-    IF(CMAKE_REQUIRED_LIBRARIES)
-      SET(CURL_TEST_ADD_LIBRARIES
-        "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    ENDIF(CMAKE_REQUIRED_LIBRARIES)
-
-    MESSAGE(STATUS "Performing Curl Test ${CURL_TEST}")
-    TRY_RUN(${CURL_TEST} ${CURL_TEST}_COMPILE
-      ${CMAKE_BINARY_DIR}
-      ${LIBCURL_SOURCE_DIR}/CMake/CurlTests.c
-      CMAKE_FLAGS -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_FUNCTION_DEFINITIONS}
-      "${CURL_TEST_ADD_LIBRARIES}"
-      OUTPUT_VARIABLE OUTPUT)
-    IF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
-      SET(${CURL_TEST} 1 CACHE INTERNAL "Curl test ${FUNCTION}")
-      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Success")
-    ELSE(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
-      MESSAGE(STATUS "Performing Curl Test ${CURL_TEST} - Failed")
-      SET(${CURL_TEST} "" CACHE INTERNAL "Curl test ${FUNCTION}")
-      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
-        "Performing Curl Test ${CURL_TEST} failed with the following output:\n"
-        "${OUTPUT}")
-      IF(${CURL_TEST}_COMPILE)
-        FILE(APPEND 
-          "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
-          "There was a running problem of this test\n")
-      ENDIF(${CURL_TEST}_COMPILE)
-      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log" 
-        "\n\n")
-    ENDIF(${CURL_TEST}_COMPILE AND NOT ${CURL_TEST})
-  ENDIF("${CURL_TEST}_COMPILE" MATCHES "^${CURL_TEST}_COMPILE$")
-ENDMACRO(CURL_INTERNAL_TEST_RUN) 
-
 # Do curl specific tests
 #OPTION(CURL_HAVE_DISABLED_NONBLOCKING "Disable non-blocking socket detection" OFF)
 SET(CURL_NONBLOCKING_TESTS)
@@ -599,13 +563,6 @@ IF(HAVE_FILE_OFFSET_BITS)
   SET(_FILE_OFFSET_BITS 64)
 ENDIF(HAVE_FILE_OFFSET_BITS)
 
-FOREACH(CURL_TEST 
-    HAVE_GLIBC_STRERROR_R
-    HAVE_POSIX_STRERROR_R
-    )
-  CURL_INTERNAL_TEST_RUN(${CURL_TEST})
-ENDFOREACH(CURL_TEST)
-
 # Check for reentrant
 FOREACH(CURL_TEST
     HAVE_GETHOSTBYADDR_R_5

Utilities/cmcurl/config.h.in

@@ -171,9 +171,6 @@
 /* Define to 1 if you have the `gettimeofday' function. */
 #cmakedefine HAVE_GETTIMEOFDAY ${HAVE_GETTIMEOFDAY}
 
-/* we have a glibc-style strerror_r() */
-#cmakedefine HAVE_GLIBC_STRERROR_R ${HAVE_GLIBC_STRERROR_R}
-
 /* Define to 1 if you have the `gmtime_r' function. */
 #cmakedefine HAVE_GMTIME_R ${HAVE_GMTIME_R}
 
@@ -348,12 +345,6 @@
 /* Define to 1 if you have the `poll' function. */
 #cmakedefine HAVE_POLL ${HAVE_POLL}
 
-/* If you have a fine poll */
-#cmakedefine HAVE_POLL_FINE ${HAVE_POLL_FINE}
-
-/* we have a POSIX-style strerror_r() */
-#cmakedefine HAVE_POSIX_STRERROR_R ${HAVE_POSIX_STRERROR_R}
-
 /* Define to 1 if you have the <process.h> header file. */
 #cmakedefine HAVE_PROCESS_H ${HAVE_PROCESS_H}
 
@@ -444,9 +435,6 @@
 /* Define to 1 if you have the `strdup' function. */
 #cmakedefine HAVE_STRDUP ${HAVE_STRDUP}
 
-/* Define to 1 if you have the `strerror_r' function. */
-#cmakedefine HAVE_STRERROR_R ${HAVE_STRERROR_R}
-
 /* Define to 1 if you have the `stricmp' function. */
 #cmakedefine HAVE_STRICMP ${HAVE_STRICMP}
 

Utilities/cmcurl/select.c

@@ -78,7 +78,7 @@
  */
 int Curl_select(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms)
 {
-#if defined(HAVE_POLL_FINE) || defined(CURL_HAVE_WSAPOLL)
+#if (defined(HAVE_POLL) && !defined(_POLL_EMUL_H_)) || defined(CURL_HAVE_WSAPOLL)
   struct pollfd pfd[2];
   int num;
   int r;
@@ -96,7 +96,7 @@ int Curl_select(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms)
     num++;
   }
 
-#ifdef HAVE_POLL_FINE
+#if defined(HAVE_POLL) && !defined(_POLL_EMUL_H_)
   do {
     r = poll(pfd, num, timeout_ms);
   } while((r == -1) && (errno == EINTR));
@@ -220,7 +220,7 @@ int Curl_select(curl_socket_t readfd, curl_socket_t writefd, int timeout_ms)
 int Curl_poll(struct pollfd ufds[], unsigned int nfds, int timeout_ms)
 {
   int r;
-#ifdef HAVE_POLL_FINE
+#if defined(HAVE_POLL) && !defined(_POLL_EMUL_H_)
   do {
     r = poll(ufds, nfds, timeout_ms);
   } while((r == -1) && (errno == EINTR));