Merge branch 'aix-xl-platform-info' into ReworkedAsmSupport

CMakeLists.txt

@@ -1,6 +1,6 @@
 #=============================================================================
 # CMake - Cross Platform Makefile Generator
-# Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -9,12 +9,9 @@
 # implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 # See the License for more information.
 #=============================================================================
-CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5 FATAL_ERROR)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3 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)
-ENDIF(COMMAND CMAKE_POLICY)
 
 IF(CMAKE_BOOTSTRAP)
   # Running from bootstrap script.  Set local variable and remove from cache.
@@ -24,18 +21,8 @@ ENDIF()
 
 MARK_AS_ADVANCED(CMAKE_BACKWARDS_COMPATIBILITY)
 
-# Allow empty endif() and such with CMake 2.4.
-SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS 1)
-
 SET(CMake_BIN_DIR ${CMake_BINARY_DIR}/bin)
 
-IF(NOT ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.4)
-  # Since the built CMake will install itself instead of the
-  # generating CMake, tell it that the install rules were generated
-  # by CMake 2.4.
-  INSTALL(CODE "SET(CMAKE_INSTALL_SELF_2_4 1)")
-ENDIF()
-
 IF("${CMake_SOURCE_DIR}" STREQUAL "${CMAKE_SOURCE_DIR}")
   # Disallow architecture-specific try_run.  It may not run on the host.
   MACRO(TRY_RUN)
@@ -430,7 +417,7 @@ ENDIF()
 # The CMake version number.
 SET(CMake_VERSION_MAJOR 2)
 SET(CMake_VERSION_MINOR 8)
-SET(CMake_VERSION_PATCH 3)
+SET(CMake_VERSION_PATCH 4)
 #SET(CMake_VERSION_TWEAK 0)
 #SET(CMake_VERSION_RC 1)
 

ChangeLog.manual

@@ -1,3 +1,416 @@
+Changes in CMake 2.8.4 (since 2.8.4-rc2)
+----------------------------------------
+Alex Neundorf (1):
+      Fix crash in GraphVizWriter when GRAPHVIZ_TARGET_IGNORE_REGEX is used
+
+Andreas Schneider (1):
+      FindPerlLibs: Add notice of copyright
+
+Brad King (3):
+      libarchive: Define major/minor/makedev only where needed (#11648)
+      libarchive: Use OpenSSL only if CMAKE_USE_OPENSSL (#11815)
+      Fix documentation of MSVC_VERSION (#11833)
+
+David Cole (1):
+      Silence the may be used uninitialized warnings: initialize stuff.
+
+Eric NOULARD (2):
+      CPack   Tests the different ways of packaging components
+      Avoid foreach IN LISTS syntax which is not supported by CMake 2.6
+
+Changes in CMake 2.8.4-rc2 (since 2.8.4-rc1)
+--------------------------------------------
+Alex Neundorf (3):
+      Make cmake build again with cmake < 2.6.3
+      Strip trailing whitespace.
+      Fix parsing of compiler name with a version number
+
+Ben Boeckel (86):
+      ... 86 commit messages summarized as:
+      Fix ADD_TEST regression when WORKING_DIRECTORY not given
+      Add new "strict-mode" CMake variable checking
+      Activate / avoid using new command line arguments:
+        --warn-uninitialized
+        --warn-unused-vars
+        --no-warn-unused-cli
+        --check-system-vars
+
+Bill Hoffman (3):
+      For macros make sure the FilePath points to a valid pointer in the args.
+      Add a warning when variables are used uninitialized.
+      Make --strict-mode option, and integrate with cmake-gui
+
+Brad King (34):
+      bootstrap: Granular system library selection (#11431)
+      bootstrap: Clarify --init flag documentation (#11431)
+      bootstrap: --verbose implies verbose Makefiles (#11708)
+      Combine duplicate COMPILE_DEFINITIONS disclaimer
+      Document COMPILE_DEFINITIONS known limitations (#11660, #11712)
+      Document try_compile behavior more clearly (#11688)
+      Document Check(C|CXX)SourceCompiles behavior more clearly (#11688)
+      Fix get_(cmake|test)_property documentation (#11703)
+      Reference get_property() from old get_*_property() commands
+      Replace misleading example in the if() documentation (#10773)
+      Clarify auto-dereference cases in if() command (#11701)
+      Document CheckFunctionExists more clearly (#10044)
+      Document CheckSymbolExists more clearly (#11685)
+      Update CheckSymbolExists copyright year
+      Report directory with missing source file (#11677)
+      Test that missing source mentions directory (#11677)
+      Teach Simple_Mingw_Linux2Win test to use windres
+      Disable SubDirSpaces parens with GNU Make 3.82 (#11654)
+      libarchive: Fix major() check for LSB 4.0 (#11648)
+      Xcode: Make generation depend on all input directories
+      Recognize SCO UnixWare C/C++ compilers (#11700)
+      Factor SCO compiler info out of platform file (#11700)
+      Honor CMAKE_TRY_COMPILE_CONFIGURATION in Makefile generators (#10809)
+      Document CMAKE_TRY_COMPILE_CONFIGURATION variable
+      Honor VS_SCC_* properties in Fortran targets (#10237)
+      Normalize slashes in scanned #include lines (#10281)
+      Improve try_compile and try_run error messages
+      Use shortest extension to verify try_compile language (#11731)
+      Modules: Include builtin FindPackageHandleStandardArgs directly
+      Fix relative CMAKE_USER_MAKE_RULES_OVERRIDE (#11725)
+      Clarify CMAKE_USER_MAKE_RULES_OVERRIDE documentation (#11724)
+      Always place try_compile executables predictably (#11724)
+      try_compile: Allow only languages loaded in caller (#11469)
+      Fix ArgumentExpansion test expected results
+
+Clinton Stimpson (1):
+      Replace exec_program with execute_process for qmake queries.
+
+David Cole (16):
+      Update script with new machine name
+      VS10: Fix problems with InstallRequiredSystemLibraries.
+      Add CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_NO_WARNINGS variable
+      Add CPACK_NSIS_INSTALL_ROOT for CMake's own installer (#9148)
+      Xcode: Disable implicit make rules in custom rules makefiles.
+      Add freeglut as library name (#10031)
+      Add new names for PNG and ZLIB libraries
+      Avoid exceptions when ccmake terminal window is too small (#11668)
+      VS10: Load projects with obj "source" files (#11147)
+      VS10: Enable using devenv as CMAKE_MAKE_PROGRAM (#11459)
+      Xcode: Fix crash: avoid strlen call on NULL char *
+      CTestTest2: Avoid running purify unless requested
+      VS10: Escape double quote chars in defines for rc files (#11695)
+      Fix line too long KWStyle issue (#11695)
+      Avoid space in rc /D values for VS6 and Cygwin (#11695)
+      VSResource: Avoid windres /D with quoted spaces (#11695)
+
+Marcus D. Hanwell (1):
+      Bug #11715 - generate header in the build tree.
+
+Nicolas Despres (1):
+      bootstrap: Add --enable-ccache option (#11707)
+
+Changes in CMake 2.8.4-rc1 (since 2.8.3)
+----------------------------------------
+Alex Neundorf (32):
+      Add support for nasm assembler, patch by Peter Collingbourne (see #10069)
+      Improve misleading comments.
+      Add missing copyright headers
+      We already have 2010, fix copyright year.
+      Make FindBISON work properly with non-C locales (#11326)
+      Add support for yasm, a nasm compatible assembler
+      Use CMAKE_ASM_NASM_FLAGS for nasm instead of FLAGS
+      Remove trailing whitespace and minor formatting changes for the dot-code
+      Move the code for collecting targets and libraries into separate functions
+      Properly insert all targets, also those which don't link to anything.
+      Generate separate dot files for each target, and a big one with everything.
+      Move the code for generating dot-files into separate class cmGraphVizWriter
+      Fix #11421: FindQt3.cmake doesn't honor the REQUIRED keyword
+      Remove trailing whitespace
+      Don't enforce VERBOSE makefiles for the CodeBlocks generator
+      Remove the "early alpha stage" comments about Eclipse and C::B
+      Don't disable colors in the CodeBlocks generator and minor cleanup.
+      Some more fixes for nasm support, from Etienne (#10069)
+      Enable/disable generating graphs depending on the target type
+      Use std::cout instead of fprintf
+      Collect targets and libs on demand instead of in the ctor
+      Exclude targets from the graphviz file based on a regex
+      Include CMakeDetermineCompilerId in CMakeDetermineASMCompiler.cmake (#11467)
+      Fix typos in the doc
+      Add cache var CMAKE_ECLIPSE_MAKE_ARGUMENTS when using the Eclipse generator
+      Add ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT as a ADVANCED cache variable (#9631)
+      Fix crash in Eclipse generator with empty project (#11616)
+      Fix indentation in cmPolicies::ApplyPolicyVersion()
+      Remove trailing whitespace
+      Prefer files from CMAKE_ROOT when including from CMAKE_ROOT
+      Improve documentation and messages for the new CMP0017
+      Remove usage of CMAKE_CURRENT_LIST_DIR now that we have CMP0017
+
+Alexey Ozeritsky (5):
+      FindBLAS works in C/C++ projects without Fortran
+      ACML find fixes (issue 0011219)
+      find ACML fixes
+      fix for Fortran-only projects
+      FindLAPACK works with C/C++ only projects (issue 0009976)
+
+Andrius Štikonas (1):
+      Modules: Fix spelling 'becase' -> 'because'.
+
+Ben Boeckel (25):
+      Fix parsing of cache variables without a type
+      Use cmCacheManager to load entries from the cache
+      Support manual cache entries
+      Condense parsing of cache entries
+      Use FPHSA in FindOpenGL
+      Ignore strerror_r since CMake isn't threaded
+      Use _POLL_EMUL_H_ instead of HAVE_POLL_FINE
+      Rename WorkingDirectory test
+      Add WORKING_DIRECTORY argument to add_test
+      Add tests for WORKING_DIRECTORY arg to add_test
+      Rename the project to match the test
+      Fix header includes for C++ and Visual Studio
+      Add ctype.h include for toupper()
+      Flip slashes around on Windows
+      Use --><-- markers to denote the path
+      Simplify the _default_cwd derivation
+      Only test the default cwd with Makefiles
+      Group adding tests with its properties
+      Fully specify the path to old-signature add_test
+      Use iostream to make Borland happy
+      Check for poll when looking for _POLL_EMUL_H_
+      Toss out strerror_r macros
+      Fix missed _POLL_EMUL_H_ and HAVE_POLL combo
+      Make TestsWorkingDirectory test a C file
+      Pass the expected value as the first argument
+
+Bill Hoffman (17):
+      Fixes for the OSF operating system build.
+      Add a fix for the inline keyword on the osf os.
+      Add a "Contract" test for VTK.  The test downloads and builds VTK.
+      Fix contract test so it is not hard coded to the vtk542 test.
+      Fix incremental linking for VS2010 with nmake or make.
+      Change cpack run and verify script to work with multi-config generators.
+      Fix vs2010 project generation error when HEADER_FILE_ONLY is set.
+      Add more documentation for LANGUAGE property.
+      Add flags to resource builds on vs 2010 with a test.
+      Disable incremental testing for this test, it crashes vs9 linker.
+      Only run resource test for MSVC compilers.
+      Add support for windows resources with mingw/msys.
+      Add support for windres to cygwin.
+      Add testing for windows resources for mingw/msys/cygwin and remove for watcom.
+      Enable resource building with the intel compiler on windows.
+      Add support for source files in custom targets for VS 10 (Bug#11330).
+      Change the nightly tests to build from the nightly branch and not next.
+
+Brad King (90):
+      Store direct dependencies in solutions for VS >= 8
+      BUG: Fix compiler flag test for non-English MSVC (#11336)
+      Document custom command behavior without DEPENDS (#11407)
+      Consolidate duplicate link rule make dependency code
+      Define LINK_DEPENDS target property (#11406)
+      KWSys: Teach SystemInformation about WinXP Pro and Win7
+      Fix Intel .vfproj SubSystem attribute values
+      Set Intel .vfproj RuntimeLibrary attribute
+      Create Fortran info variables for .mod behavior
+      Teach CMake about Cray C, C++, and Fortran compilers
+      Speedup find_* commands (#11412)
+      Prefer non-empty prefixes when matching lib names (#11468)
+      Record edge type in global dependency graph
+      Use modern global dependency graph for VS < 8 deps
+      Allow add_dependencies() on imported targets (#10395)
+      Pass Mac linker flag through PGI compiler using "-Wl,"
+      Modernize FindITK module (#11494)
+      Fix find_* argument parsing crash (#11513)
+      Skip VS <= 7.1 dependency analysis for VS >= 8
+      Enable 64-bit tools with VS 2010 Express (#9981, #10722)
+      KWSys: Associate installed library with an EXPORT
+      Fix try_compile RemoveFile anti-virus loop (#11503)
+      Fix Fortran .mod timestamps with Cray compiler
+      Make Fortran $obj.provides.build targets not .PHONY
+      Honor custom command dependencies on imported targets (#10395)
+      Improve signature of cmLocalGenerator::GetRealDependency
+      Skip file-level dependencies on custom targets (#11332)
+      Simplify VS generator ConstructScript interface
+      Factor out common custom command generator
+      Remove cmLocalGenerator::GetRealLocation
+      KWSys: Remove realpath from SystemTools::GetPath (#10335)
+      Fix parallel "make install" of CMake itself
+      CTest: Fix ctest_sleep documentation (#11554)
+      Fix soname in cross-compiled targets with Mac host (#11547)
+      Detect object files in implicit link information
+      Allow Fortran platform files to set empty values
+      Recognize the NAG Fortran compiler
+      Add NAG Fortran compiler information files
+      FortranCInterface: Recognize NAG Fortran module symbols
+      Remove unused variable "rootdir" in VS generators
+      Avoid msbuild idiosyncrasy that builds multiple configs (#11594)
+      Remove unused parameter "root" in some VS generator methods
+      Fix dependency tracing of INSTALL and PACKAGE (#11598)
+      Remove unused GLOBAL_TARGET generation code
+      KWSys: Use EXPORT name only if installing library
+      Write full version into try_compile CMakeLists
+      KWSys: Do not mangle UNC paths in ConvertToUnixOutputPath (#10206)
+      Normalize add_custom_command OUTPUT names (#10485)
+      Make link rule depend on ".def" file (#11014)
+      Document target_link_libraries target scope (#11058)
+      Record backtrace in cmCustomCommand
+      Factor generator expression docs out of add_test
+      Factor per-config sample targets out of 'Testing' test
+      Optionally suppress errors in cmGeneratorExpression
+      Record set of targets used in cmGeneratorExpression
+      Introduce "generator expression" syntax to custom commands (#11209)
+      CTest: Fix test DEPEND cycle detection
+      Make Intel defines consistent with MSVC on Windows (#9904)
+      CTest: Fix line-too-long style in DEPEND cycle error
+      Detect Fortran target architecture on Windows
+      Modernize Intel compiler info on Windows
+      Remove unused old-style g++ info file
+      CheckCCompilerFlag: Strict signature of 'main' (#11615)
+      Warn in find(GLOB) docs about bad use case (#11617)
+      Remove call to SystemTools::GetMaximumFilePathLength
+      Xcode: Generate native 3.2 projects
+      Declare min CMake version in --system-information project
+      Cygwin: Fix tests to check CYGWIN instead of WIN32
+      Cygwin: Do not define 'WIN32' (#10122)
+      Revert "Remove unused parameter "root" in some VS generator methods"
+      Revert "Avoid msbuild idiosyncrasy that builds multiple configs" (#11633)
+      Avoid msbuild ".\" idiosyncrasy that builds multiple configs (#11594)
+      Mark CustomCommand test perconfig.out as SYMBOLIC
+      CTest: Factor out duplicate Git author/committer code
+      KWSys: Avoid buffer overflow in SystemInformation (#11018)
+      Fix sentence break in add_test documentation
+      Pass Mac linker flag through all compilers with -Wl,
+      KWSys: Avoid passing string literal as char*
+      Avoid passing string literal to char* type
+      Fix constness in compiler id detection
+      Build enable_language command during bootstrap
+      Map multiple /FI flags for VS < 10 (#11649)
+      KWSys: Remove useless include <sys/procfs.h> (#11648)
+      Allow users to specify defaults for unset policies
+      ccmake: Use LSB 4.0 curses API conditionally
+      CTest: Do not truncate UTF-8 test output too early (#10656)
+      ccmake: Use LSB 4.0 getmaxyx conditionally
+      Allow platform files to set large archive rules (#11674)
+      Document reading LOCATION early as undefined (#11671)
+      Document reading LOCATION_<CONFIG> early as undefined (#11671)
+
+Brian Bassett (1):
+      VS: Fix linking of Fortran-only DLL projects (#10803)
+
+Campbell Barton (1):
+      Honor RULE_MESSAGES property for build target messages
+
+Chuck Atkins (1):
+      CTest: Teach launcher to ignore empty/no-op make commands
+
+Clinton Stimpson (11):
+      Fix regex for moc includes when looking for frameworks.
+      cmake-gui: use BundleUtilities in place of custom script.
+      Fix regression in 2dae2f1 which added find of Qt imports dir.
+      Force cmake to run again when qrc dependency scanning needs to happen.
+      Fix regression to allow specifying a CMakeCache.txt file on the command line.
+      BundleUtilities: only do rpath strip on copied prerequisites.
+      Fix build issues cross compiling with static Qt.
+      CTest: multiple ctest_test calls w/LABEL regexs (#11487)
+      cmake-gui: always enable generate button.
+      allow absolute paths for dbus interface.
+      Add support for using static/dynamic Qt plugins.
+
+Craig Scott (1):
+      ccmake: Port for LSB 4.0 (#11648)
+
+Dave Abrahams (1):
+      FindPerlLibs: Fix for Mac locally applied patches
+
+David Cole (31):
+      Add a contract test for building the CSE.
+      Enable overriding contract test timeout values.
+      Update tag in the Contracts/cse-snapshot test.
+      Make HTML test fail when --nonet arg is not available.
+      Begin post-2.8.3 development
+      No CMake.HTML test if xmllint has no --nonet.
+      Suppress "loop was vectorized" "warnings."
+      Add contract test for Trilinos 10.6.1 snapshot.
+      Honor FOLDER on include_external_msproject targets (#11436)
+      Correct misspelling in error message text.
+      BundleUtilities: error if fixup_bundle_item called on non-embedded item
+      VS10: stop build on custom command error (#11533)
+      CPack: look for makensis in the PATH (#8210)
+      VS10: avoid warning, no nologo when verbose (#10587)
+      Use m prefix in shorttag value to indicate "md5 of tarball"
+      Establish pass criteria for the Trilinos contract test.
+      Suppress erroneous warnings from Intel compiler
+      Avoid running CMake.Install test simultaneously with other tests
+      VS10: Finish Midl support (#11461)
+      Prohibit space in HOME value for VSMidl test.
+      KWSys: Fix CPU speed calculations (#9963)
+      KWSys: Retrieve QNX specific memory and processor info (#11329)
+      Improve build error detection.
+      VSMidl Test: Use correct include_directories with VS6 (#11461)
+      Add PATH_SUFFIXES for finding git.
+      ExternalProject: Avoid bleed-through output when logging.
+      Fix WOW64 registry mode on Windows 2000 (#10759)
+      ExternalProject: Replace location tags in CMAKE_CACHE_ARGS
+      CPack: Detect more URLs in CPACK_NSIS_MENU_LINKS (#10644)
+      KWSys: Fix WOW64 registry mode on Windows 2000 (#10759)
+      CPack: Add CPACK_NSIS_INSTALL_ROOT variable (#9148)
+
+Eric NOULARD (13):
+      CPackRPM  add basic component support to CPackRPM
+      CPack  fix kwstyle breakage and make CPackRPM backward compatible
+      CPack backward compatibility fix 2.8.3-2.8.2 (bug 11452)
+      CPack Fix KWStyle error
+      CPack Honor CPACK_MONOLITHIC_INSTALL at CPack time too
+      CPack  use IsOn when it's better than IsSet
+      CPackRPM fix bug 0011595 : Can't generate RPMs (on FC11...)
+      CPack new tests for component install
+      CPack  Default component test for ZIP should be OK
+      CPackTest spit out more output in case of failure
+      Arrange output in a better way
+      Precise the project config type when invoking cpack
+      CPackSTGZ  quote here-doc, fix bug10518
+
+Kai Wasserbäch (1):
+      FindTCL: Fix TCL and TK version variable references (#11528)
+
+Marcus D. Hanwell (5):
+      BUG 11451 - pass CMAKE_EXTRA_GENERATOR down.
+      Added CMAKE_CACHE_ARGS to ExternalProject.
+      Escape file write expansion, and build up lists.
+      Fixed bug where last entry would be lost.
+      Python additional version support, bug #10279.
+
+Matthias Kretz (1):
+      Inline help in vim with vertical split.
+
+Mike McQuaid (6):
+      Fix incorrect variable documentation (#11127)
+      Add variable for InstallRequiredSystemLibraries dir (#11140)
+      InstallRequiredSystemLibraries debug-only (#11141)
+      Allow NSIS package or uninstall icon (#11143)
+      Add CPACK_NSIS_EXECUTABLES_DIRECTORY (#7828)
+      Add CPack NSIS MUI_FINISHPAGE_RUN support (#11144)
+
+Philip Lowman (8):
+      11363: FindBoost.cmake fails to find debug libraries in tagged layout install
+      11429: FindGTK2 does not find libraries built for Visual Studio 2010
+      11430: FindBullet doesn't find header files installed by Bullet >= 2.77
+      11384: FindCxxTest now includes test code in VS project
+      [patch] Add Boost 1.45 to search, simplify a check removing VERSION_LESS
+      Add Boost 1.46
+      Fix spelling BOOST_LIBRARYDIR message. Add error for common misspellings.
+      Lowercase all function names and improve consistency
+
+Rolf Eike Beer (2):
+      allow STRING(SUBSTRING) work with length -1 as "rest of the string"
+      Add the WORKING_DIRECTORY property to tests
+
+Wojciech Migda (1):
+      Recognize the Texas Instruments DSP compiler (#11645)
+
+Yaakov Selkowitz (2):
+      Cygwin: Use 'cyg' prefix for module DLLs (#10122)
+      Cygwin: Fix release script libncurses search patterns (#10766)
+
+Zach Mullen (4):
+      Remove debugging message from parallel ctest
+      CTest git update should pass the committer as well as the author
+      Support explicitly set test costs in non-parallel testing.
+      Test TIMEOUT property explicitly set to zero should be honored
+
 No changes in CMake 2.8.3 since 2.8.3-rc4.
 
 Changes in CMake 2.8.3-rc4 (since 2.8.3-rc3)

Modules/CMakeCommonLanguageInclude.cmake

@@ -16,7 +16,7 @@
 # cache values that can be initialized in the platform-compiler.cmake file
 # it may be included by more than one language.
 
-SET (CMAKE_EXE_LINKER_FLAGS ${CMAKE_EXE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}
+SET (CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
      CACHE STRING "Flags used by the linker.")
 
 
@@ -70,11 +70,11 @@ IF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
 
 ENDIF(NOT CMAKE_NOT_USING_CONFIG_FLAGS)
 # shared linker flags
-SET (CMAKE_SHARED_LINKER_FLAGS ${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}
+SET (CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
      CACHE STRING "Flags used by the linker during the creation of dll's.")
 
 # module linker flags
-SET (CMAKE_MODULE_LINKER_FLAGS ${CMAKE_MODULE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}
+SET (CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS_INIT} $ENV{LDFLAGS}"
      CACHE STRING "Flags used by the linker during the creation of modules.")
 
 SET(CMAKE_BUILD_TOOL ${CMAKE_MAKE_PROGRAM} CACHE INTERNAL 

Modules/CMakeFortranInformation.cmake

@@ -178,9 +178,10 @@ IF(NOT DEFINED CMAKE_Fortran_ARCHIVE_FINISH)
 ENDIF()
 
 # compile a Fortran file into an object file
+# (put -o after -c to workaround bug in at least one mpif77 wrapper)
 IF(NOT CMAKE_Fortran_COMPILE_OBJECT)
   SET(CMAKE_Fortran_COMPILE_OBJECT
-    "<CMAKE_Fortran_COMPILER> -o <OBJECT> <DEFINES> <FLAGS> -c <SOURCE>")
+    "<CMAKE_Fortran_COMPILER> <DEFINES> <FLAGS> -c <SOURCE> -o <OBJECT>")
 ENDIF(NOT CMAKE_Fortran_COMPILE_OBJECT)
 
 # link a fortran program

Modules/CPackDeb.cmake

@@ -60,7 +60,7 @@
 # CPACK_DEBIAN_PACKAGE_DEBUG
 #     Mandatory : NO
 #     Default   : -
-#     May be set when invoking cpack in order to trace debug informations
+#     May be set when invoking cpack in order to trace debug information
 #     during CPackDeb run.
 # CPACK_DEBIAN_PACKAGE_PREDEPENDS
 #     Mandatory : NO

Modules/CTest.cmake

@@ -63,7 +63,8 @@ OPTION(BUILD_TESTING "Build the testing tree." ON)
 # function to turn generator name into a version string
 # like vs7 vs71 vs8 vs9 
 FUNCTION(GET_VS_VERSION_STRING generator var)
-  STRING(REGEX REPLACE "Visual Studio ([0-9][0-9]?)($|.*)" "\\1" NUMBER "${generator}") 
+  STRING(REGEX REPLACE "Visual Studio ([0-9][0-9]?)($|.*)" "\\1"
+    NUMBER "${generator}")
   IF("${generator}" MATCHES "Visual Studio 7 .NET 2003")
     SET(ver_string "vs71")
   ELSE("${generator}" MATCHES "Visual Studio 7 .NET 2003")
@@ -253,15 +254,16 @@ IF(BUILD_TESTING)
   ENDIF(CTEST_USE_LAUNCHERS)
 
   MARK_AS_ADVANCED(
-    COVERAGE_COMMAND
-    CVSCOMMAND
-    SVNCOMMAND
     BZRCOMMAND
-    HGCOMMAND
-    GITCOMMAND
-    CVS_UPDATE_OPTIONS
-    SVN_UPDATE_OPTIONS
     BZR_UPDATE_OPTIONS
+    COVERAGE_COMMAND
+    CTEST_SUBMIT_RETRY_DELAY
+    CTEST_SUBMIT_RETRY_COUNT
+    CVSCOMMAND
+    CVS_UPDATE_OPTIONS
+    DART_TESTING_TIMEOUT
+    GITCOMMAND
+    HGCOMMAND
     MAKECOMMAND 
     MEMORYCHECK_COMMAND
     MEMORYCHECK_SUPPRESSIONS_FILE
@@ -270,10 +272,9 @@ IF(BUILD_TESTING)
     SLURM_SBATCH_COMMAND
     SLURM_SRUN_COMMAND
     SITE
-    CTEST_SUBMIT_RETRY_DELAY
+    SVNCOMMAND
-    CTEST_SUBMIT_RETRY_COUNT
+    SVN_UPDATE_OPTIONS
     )
-  #  BUILDNAME 
   IF(NOT RUN_FROM_DART)
     SET(RUN_FROM_CTEST_OR_DART 1)
     INCLUDE(CTestTargets)

Modules/CTestTargets.cmake

@@ -84,4 +84,12 @@ IF(NOT _CTEST_TARGETS_ADDED)
       ENDFOREACH(testtype)
     ENDFOREACH(mode)
   ENDIF("${CMAKE_GENERATOR}" MATCHES Make)
+
+  # If requested, add an alias that is the equivalent of the built-in "test"
+  # or "RUN_TESTS" target:
+  IF(CTEST_TEST_TARGET_ALIAS)
+    ADD_CUSTOM_TARGET(${CTEST_TEST_TARGET_ALIAS}
+      ${CMAKE_CTEST_COMMAND} ${__conf_types}
+      )
+  ENDIF()
 ENDIF(NOT _CTEST_TARGETS_ADDED)

Modules/FindPerlLibs.cmake

@@ -25,6 +25,7 @@
 
 #=============================================================================
 # Copyright 2004-2009 Kitware, Inc.
+# Copyright 2008      Andreas Schneider <asn@cryptomilk.org>
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.

Modules/FindPostgreSQL.cmake

@@ -1,6 +1,4 @@
-# Find the PostgreSQL installation.
+# - Find the PostgreSQL installation.
-#
-# ----------------------------------------------------------------------------
 # Usage:
 # In your CMakeLists.txt file do something like this:
 # ...

Modules/FindQt4.cmake

@@ -9,7 +9,7 @@
 # QT_LIBRARIES variable.
 #
 # Typical usage could be something like:
-#   find_package(Qt4 4.4.3 COMPONENTS QtCore QtGui QtXml REQUIRED )
+#   find_package(Qt4 4.4.3 REQUIRED QtCore QtGui QtXml)
 #   include(${QT_USE_FILE})
 #   add_executable(myexe main.cpp)
 #   target_link_libraries(myexe ${QT_LIBRARIES})
@@ -354,6 +354,7 @@ ENDIF(QT_QT_LIBRARY)
 
 INCLUDE(CheckSymbolExists)
 INCLUDE(MacroAddFileDependencies)
+INCLUDE(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake)
 
 SET(QT_USE_FILE ${CMAKE_ROOT}/Modules/UseQt4.cmake)
 
@@ -472,6 +473,7 @@ FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake qmake4 qmake-qt4 qmake-mac PATHS
   DOC "The qmake executable for the Qt installation to use"
 )
 
+# double check that it was a Qt4 qmake, if not, re-find with different names
 IF (QT_QMAKE_EXECUTABLE)
 
   IF(QT_QMAKE_EXECUTABLE_LAST)
@@ -480,8 +482,6 @@ IF (QT_QMAKE_EXECUTABLE)
 
   SET(QT_QMAKE_EXECUTABLE_LAST "${QT_QMAKE_EXECUTABLE}" CACHE INTERNAL "" FORCE)
 
-  SET(QT4_QMAKE_FOUND FALSE)
-  
   _qt4_query_qmake(QT_VERSION QTVERSION)
 
   # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
@@ -498,74 +498,9 @@ IF (QT_QMAKE_EXECUTABLE)
     ENDIF(QT_QMAKE_EXECUTABLE)
   ENDIF(NOT QTVERSION)
 
-  # check that we found the Qt4 qmake, Qt3 qmake output won't match here
-  STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" qt_version_tmp "${QTVERSION}")
-  IF (qt_version_tmp)
-
-    # we need at least version 4.0.0
-    IF (NOT QT_MIN_VERSION)
-      SET(QT_MIN_VERSION "4.0.0")
-    ENDIF (NOT QT_MIN_VERSION)
-
-    #now parse the parts of the user given version string into variables
-    STRING(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" req_qt_major_vers "${QT_MIN_VERSION}")
-    IF (NOT req_qt_major_vers)
-      MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", expected e.g. \"4.0.1\"")
-    ENDIF (NOT req_qt_major_vers)
-
-    # now parse the parts of the user given version string into variables
-    STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+" "\\1" req_qt_major_vers "${QT_MIN_VERSION}")
-    STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+" "\\1" req_qt_minor_vers "${QT_MIN_VERSION}")
-    STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+)" "\\1" req_qt_patch_vers "${QT_MIN_VERSION}")
-
-    # Suppport finding at least a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 )
-    # This implementation is a hack to avoid duplicating code and make sure we stay
-    # source-compatible with CMake 2.6.x
-    IF( Qt4_FIND_VERSION )
-      SET( QT_MIN_VERSION ${Qt4_FIND_VERSION} )
-      SET( req_qt_major_vers ${Qt4_FIND_VERSION_MAJOR} )
-      SET( req_qt_minor_vers ${Qt4_FIND_VERSION_MINOR} )
-      SET( req_qt_patch_vers ${Qt4_FIND_VERSION_PATCH} )
-    ENDIF( Qt4_FIND_VERSION )
-
-    IF (NOT req_qt_major_vers EQUAL 4)
-      MESSAGE( FATAL_ERROR "Invalid Qt version string given: \"${QT_MIN_VERSION}\", major version 4 is required, e.g. \"4.0.1\"")
-    ENDIF (NOT req_qt_major_vers EQUAL 4)
-
-    # and now the version string given by qmake
-    STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}")
-    STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}")
-    STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}")
-
-    # compute an overall version number which can be compared at once
-    MATH(EXPR req_vers "${req_qt_major_vers}*10000 + ${req_qt_minor_vers}*100 + ${req_qt_patch_vers}")
-    MATH(EXPR found_vers "${QT_VERSION_MAJOR}*10000 + ${QT_VERSION_MINOR}*100 + ${QT_VERSION_PATCH}")
-
-    # Support finding *exactly* a particular version, for instance FIND_PACKAGE( Qt4 4.4.3 EXACT )
-    IF( Qt4_FIND_VERSION_EXACT )
-      IF(found_vers EQUAL req_vers)
-        SET( QT4_QMAKE_FOUND TRUE )
-      ELSE(found_vers EQUAL req_vers)
-        SET( QT4_QMAKE_FOUND FALSE )
-        IF (found_vers LESS req_vers)
-          SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
-        ELSE (found_vers LESS req_vers)
-          SET(QT4_INSTALLED_VERSION_TOO_NEW TRUE)
-        ENDIF (found_vers LESS req_vers)
-      ENDIF(found_vers EQUAL req_vers)
-    ELSE( Qt4_FIND_VERSION_EXACT )
-      IF (found_vers LESS req_vers)
-        SET(QT4_QMAKE_FOUND FALSE)
-        SET(QT4_INSTALLED_VERSION_TOO_OLD TRUE)
-      ELSE (found_vers LESS req_vers)
-        SET(QT4_QMAKE_FOUND TRUE)
-      ENDIF (found_vers LESS req_vers)
-    ENDIF( Qt4_FIND_VERSION_EXACT )
-  ENDIF (qt_version_tmp)
-
 ENDIF (QT_QMAKE_EXECUTABLE)
 
-IF (QT4_QMAKE_FOUND)
+IF (QT_QMAKE_EXECUTABLE AND QTVERSION)
 
   # ask qmake for the mkspecs directory
   # we do this first because QT_LIBINFIX might be set
@@ -607,14 +542,25 @@ IF (QT4_QMAKE_FOUND)
     FIND_LIBRARY(QT_QTCORE_LIBRARY_RELEASE
                  NAMES QtCore${QT_LIBINFIX} QtCore${QT_LIBINFIX}4
                  HINTS ${QT_LIBRARY_DIR_TMP}
-                 NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_SYSTEM_ENVIRONMENT_PATH
+                 NO_DEFAULT_PATH
         )
     FIND_LIBRARY(QT_QTCORE_LIBRARY_DEBUG
                  NAMES QtCore${QT_LIBINFIX}_debug QtCore${QT_LIBINFIX}d QtCore${QT_LIBINFIX}d4
                  HINTS ${QT_LIBRARY_DIR_TMP}
-                 NO_CMAKE_PATH NO_CMAKE_ENVIRONMENT_PATH NO_SYSTEM_ENVIRONMENT_PATH
+                 NO_DEFAULT_PATH
         )
 
+    IF(NOT QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCORE_LIBRARY_DEBUG)
+      FIND_LIBRARY(QT_QTCORE_LIBRARY_RELEASE
+                   NAMES QtCore${QT_LIBINFIX} QtCore${QT_LIBINFIX}4
+                   HINTS ${QT_LIBRARY_DIR_TMP}
+          )
+      FIND_LIBRARY(QT_QTCORE_LIBRARY_DEBUG
+                   NAMES QtCore${QT_LIBINFIX}_debug QtCore${QT_LIBINFIX}d QtCore${QT_LIBINFIX}d4
+                   HINTS ${QT_LIBRARY_DIR_TMP}
+          )
+    ENDIF(NOT QT_QTCORE_LIBRARY_RELEASE AND NOT QT_QTCORE_LIBRARY_DEBUG)
+
     # try dropping a hint if trying to use Visual Studio with Qt built by mingw
     IF(NOT QT_QTCORE_LIBRARY_RELEASE AND MSVC)
       IF(EXISTS ${QT_LIBRARY_DIR_TMP}/libqtmain.a)
@@ -644,10 +590,13 @@ IF (QT4_QMAKE_FOUND)
   ENDIF()
 
   IF (APPLE)
+    SET(CMAKE_FIND_FRAMEWORK_OLD ${CMAKE_FIND_FRAMEWORK})
     IF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
       SET(QT_USE_FRAMEWORKS ON CACHE INTERNAL "" FORCE)
+      SET(CMAKE_FIND_FRAMEWORK FIRST)
     ELSE (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
       SET(QT_USE_FRAMEWORKS OFF CACHE INTERNAL "" FORCE)
+      SET(CMAKE_FIND_FRAMEWORK LAST)
     ENDIF (EXISTS ${QT_LIBRARY_DIR}/QtCore.framework)
     MARK_AS_ADVANCED(QT_USE_FRAMEWORKS)
   ENDIF (APPLE)
@@ -663,8 +612,7 @@ IF (QT4_QMAKE_FOUND)
       _qt4_query_qmake(QT_INSTALL_HEADERS qt_headers)
       SET(QT_QTCORE_INCLUDE_DIR NOTFOUND)
       FIND_PATH(QT_QTCORE_INCLUDE_DIR QtCore
-                HINTS ${qt_headers}
+                HINTS ${qt_headers} ${QT_LIBRARY_DIR}
-                ${QT_LIBRARY_DIR}/QtCore.framework/Headers
                 PATH_SUFFIXES QtCore
         )
 
@@ -682,6 +630,10 @@ IF (QT4_QMAKE_FOUND)
       ENDIF()
   ENDIF()
 
+  IF(APPLE)
+    SET(CMAKE_FIND_FRAMEWORK ${CMAKE_FIND_FRAMEWORK_OLD})
+  ENDIF(APPLE)
+
   # Set QT_INCLUDE_DIR based on QT_HEADERS_DIR
   IF(QT_HEADERS_DIR)
     IF(QT_USE_FRAMEWORKS)
@@ -1075,32 +1027,7 @@ IF (QT4_QMAKE_FOUND)
   # get the directory of the current file, used later on in the file
   GET_FILENAME_COMPONENT( _qt4_current_dir  "${CMAKE_CURRENT_LIST_FILE}" PATH)
 
-  ######################################
-  #
-  #       decide if Qt got found
-  #
-  ######################################
-
-  # if the includes,libraries,moc,uic and rcc are found then we have it
-  IF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND 
-      QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
-    SET( QT4_FOUND "YES" )
-    INCLUDE(FindPackageMessage)
-    FIND_PACKAGE_MESSAGE(Qt4 "Found Qt-Version ${QTVERSION} (using ${QT_QMAKE_EXECUTABLE})"
-      "[${QT_LIBRARY_DIR}][${QT_INCLUDE_DIR}][${QT_MOC_EXECUTABLE}][${QT_UIC_EXECUTABLE}][${QT_RCC_EXECUTABLE}]")
-  ELSE( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND
-        QT_UIC_EXECUTABLE AND QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
-    SET( QT4_FOUND "NO")
-    SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
-    IF( Qt4_FIND_REQUIRED)
-      MESSAGE( FATAL_ERROR "Qt libraries, includes, moc, uic or/and rcc NOT found!")
-    ENDIF( Qt4_FIND_REQUIRED)
-  ENDIF( QT_LIBRARY_DIR AND QT_INCLUDE_DIR AND QT_MOC_EXECUTABLE AND 
-         QT_UIC_EXECUTABLE AND  QT_RCC_EXECUTABLE AND QT_QTCORE_LIBRARY)
   
-  SET(QT_FOUND ${QT4_FOUND})
-
-
   ###############################################
   #
   #       configuration/system dependent settings  
@@ -1192,44 +1119,58 @@ IF (QT4_QMAKE_FOUND)
 
   INCLUDE("${_qt4_current_dir}/Qt4Macros.cmake")
 
+  # set version variables
+  STRING(REGEX REPLACE "^([0-9]+)\\.[0-9]+\\.[0-9]+.*" "\\1" QT_VERSION_MAJOR "${QTVERSION}")
+  STRING(REGEX REPLACE "^[0-9]+\\.([0-9])+\\.[0-9]+.*" "\\1" QT_VERSION_MINOR "${QTVERSION}")
+  STRING(REGEX REPLACE "^[0-9]+\\.[0-9]+\\.([0-9]+).*" "\\1" QT_VERSION_PATCH "${QTVERSION}")
 
-  #######################################
+ENDIF(QT_QMAKE_EXECUTABLE AND QTVERSION)
-  #
-  #       compatibility settings 
-  #
-  #######################################
-  # Backwards compatibility for CMake1.4 and 1.2
-  SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
-  SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
 
-  SET( QT_QT_LIBRARY "")
+#support old QT_MIN_VERSION if set, but not if version is supplied by find_package()
+IF(NOT Qt4_FIND_VERSION AND QT_MIN_VERSION)
+  SET(Qt4_FIND_VERSION ${QT_MIN_VERSION})
+ENDIF(NOT Qt4_FIND_VERSION AND QT_MIN_VERSION)
 
-ELSE(QT4_QMAKE_FOUND)
+IF( Qt4_FIND_COMPONENTS )
-   
+
-   SET(QT_QMAKE_EXECUTABLE "${QT_QMAKE_EXECUTABLE}-NOTFOUND" CACHE FILEPATH "Invalid qmake found" FORCE)
+  # if components specified in find_package(), make sure each of those pieces were found
-   
+  SET(_QT4_FOUND_REQUIRED_VARS QT_QMAKE_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_INCLUDE_DIR QT_LIBRARY_DIR)
-   # The code below is overly complex to make sure we do not break compatibility with CMake 2.6.x
+  FOREACH( component ${Qt4_FIND_COMPONENTS} )
-   # For CMake 2.8, it should be simplified by getting rid of QT4_INSTALLED_VERSION_TOO_OLD and 
+    STRING( TOUPPER ${component} _COMPONENT )
-   # QT4_INSTALLED_VERSION_TOO_NEW
+    if(${_COMPONENT} STREQUAL "QTMAIN")
-   IF(Qt4_FIND_REQUIRED)
+      IF(Q_WS_WIN)
-      IF(QT4_INSTALLED_VERSION_TOO_OLD)
+        SET(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_${_COMPONENT}_LIBRARY)
-    IF( Qt4_FIND_VERSION_EXACT )
+      ENDIF(Q_WS_WIN)
-      MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, version ${QT_MIN_VERSION} is required")
+    else(${_COMPONENT} STREQUAL "QTMAIN")
-    ELSE( Qt4_FIND_VERSION_EXACT )
+      SET(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_${_COMPONENT}_INCLUDE_DIR QT_${_COMPONENT}_LIBRARY)
-      MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
+    endif(${_COMPONENT} STREQUAL "QTMAIN")
-    ENDIF( Qt4_FIND_VERSION_EXACT )
+  ENDFOREACH( component )
-      ELSE(QT4_INSTALLED_VERSION_TOO_OLD)
+
-      IF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
+  if(Qt4_FIND_COMPONENTS MATCHES QtGui)
-      MESSAGE(FATAL_ERROR "The installed Qt version ${QTVERSION} is too new, version ${QT_MIN_VERSION} is required")
+    SET(_QT4_FOUND_REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS} QT_UIC_EXECUTABLE)
-    ELSE( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
+  endif(Qt4_FIND_COMPONENTS MATCHES QtGui)
-      MESSAGE( FATAL_ERROR "Qt qmake not found!")
+
-    ENDIF( Qt4_FIND_VERSION_EXACT AND QT4_INSTALLED_VERSION_TOO_NEW )
+ELSE( Qt4_FIND_COMPONENTS )
-      ENDIF(QT4_INSTALLED_VERSION_TOO_OLD)
+
-   ELSE(Qt4_FIND_REQUIRED)
+  # if no components specified, we'll make a default set of required variables to say Qt is found
-      IF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
+  SET(_QT4_FOUND_REQUIRED_VARS QT_QMAKE_EXECUTABLE QT_MOC_EXECUTABLE QT_RCC_EXECUTABLE QT_UIC_EXECUTABLE QT_INCLUDE_DIR
-         MESSAGE(STATUS "The installed Qt version ${QTVERSION} is too old, at least version ${QT_MIN_VERSION} is required")
+    QT_LIBRARY_DIR QT_QTCORE_LIBRARY)
-      ENDIF(QT4_INSTALLED_VERSION_TOO_OLD AND NOT Qt4_FIND_QUIETLY)
+
-   ENDIF(Qt4_FIND_REQUIRED)
+ENDIF( Qt4_FIND_COMPONENTS )
- 
+
-ENDIF (QT4_QMAKE_FOUND)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Qt4
+  REQUIRED_VARS ${_QT4_FOUND_REQUIRED_VARS}
+  VERSION_VAR QTVERSION
+  )
+
+#######################################
+#
+#       compatibility settings
+#
+#######################################
+# Backwards compatibility for CMake1.4 and 1.2
+SET (QT_MOC_EXE ${QT_MOC_EXECUTABLE} )
+SET (QT_UIC_EXE ${QT_UIC_EXECUTABLE} )
+SET( QT_QT_LIBRARY "")
+SET(QT_FOUND ${QT4_FOUND})
 

Modules/Platform/AIX-GNU.cmake

@@ -19,5 +19,7 @@ endif()
 set(__AIX_COMPILER_GNU 1)
 
 macro(__aix_compiler_gnu lang)
+  set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG "-Wl,-blibpath:")
+  set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP ":")
   set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "${CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS} -Wl,-G")
 endmacro()

Modules/Platform/AIX-XL-C.cmake

@@ -1,4 +1,2 @@
-SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-G -Wl,-brtl,-bnoipath")  # -shared
+include(Platform/AIX-XL)
-SET(CMAKE_SHARED_LIBRARY_LINK_C_FLAGS "-Wl,-brtl,-bnoipath,-bexpall")  # +s, flag for exe link to use shared lib
+__aix_compiler_xl(C)
-SET(CMAKE_SHARED_LIBRARY_C_FLAGS " ")
-SET(CMAKE_SHARED_MODULE_C_FLAGS  " ")

Modules/Platform/AIX-XL-CXX.cmake

@@ -1,4 +1,2 @@
-SET(CMAKE_SHARED_LIBRARY_CREATE_CXX_FLAGS "-G -Wl,-brtl,-bnoipath")       # -shared
+include(Platform/AIX-XL)
-SET(CMAKE_SHARED_LIBRARY_LINK_CXX_FLAGS "-Wl,-brtl,-bnoipath,-bexpall")  # +s, flag for exe link to use shared lib
+__aix_compiler_xl(CXX)
-SET(CMAKE_SHARED_LIBRARY_CXX_FLAGS " ")
-SET(CMAKE_SHARED_MODULE_CXX_FLAGS  " ")

Modules/Platform/AIX-XL-Fortran.cmake

@@ -1,4 +1,2 @@
-SET(CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS "-G -Wl,-brtl,-bnoipath")  # -shared
+include(Platform/AIX-XL)
-SET(CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS "-Wl,-brtl,-bnoipath,-bexpall")  # +s, flag for exe link to use shared lib
+__aix_compiler_xl(Fortran)
-SET(CMAKE_SHARED_LIBRARY_Fortran_FLAGS " ")
-SET(CMAKE_SHARED_MODULE_Fortran_FLAGS  " ")

Modules/Platform/AIX-XL.cmake

@@ -0,0 +1,28 @@
+
+#=============================================================================
+# Copyright 2002-2011 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(__AIX_COMPILER_XL)
+  return()
+endif()
+set(__AIX_COMPILER_XL 1)
+
+macro(__aix_compiler_xl lang)
+  set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG "-Wl,-blibpath:")
+  set(CMAKE_SHARED_LIBRARY_RUNTIME_${lang}_FLAG_SEP ":")
+  set(CMAKE_SHARED_LIBRARY_CREATE_${lang}_FLAGS "-G -Wl,-brtl,-bnoipath")  # -shared
+  set(CMAKE_SHARED_LIBRARY_LINK_${lang}_FLAGS "-Wl,-brtl,-bnoipath,-bexpall")  # +s, flag for exe link to use shared lib
+  set(CMAKE_SHARED_LIBRARY_${lang}_FLAGS " ")
+  set(CMAKE_SHARED_MODULE_${lang}_FLAGS  " ")
+endmacro()

Modules/Platform/AIX.cmake

@@ -9,8 +9,6 @@ SET(CMAKE_DL_LIBS "-lld")
 # When our own RPATH is to be added it may be inserted before the
 # "always" paths.
 SET(CMAKE_PLATFORM_REQUIRED_RUNTIME_PATH /usr/lib /lib)
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG "-Wl,-blibpath:")
-SET(CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP ":")
 
 # Files named "libfoo.a" may actually be shared libraries.
 SET_PROPERTY(GLOBAL PROPERTY TARGET_ARCHIVES_MAY_BE_SHARED_LIBS 1)

Modules/Platform/Darwin.cmake

@@ -68,7 +68,8 @@ IF(NOT _CMAKE_OSX_SDKS)
   FIND_PROGRAM(CMAKE_XCODE_SELECT xcode-select)
   IF(CMAKE_XCODE_SELECT)
     EXECUTE_PROCESS(COMMAND ${CMAKE_XCODE_SELECT} "-print-path"
-      OUTPUT_VARIABLE OSX_DEVELOPER_ROOT)
+      OUTPUT_VARIABLE OSX_DEVELOPER_ROOT
+      OUTPUT_STRIP_TRAILING_WHITESPACE)
     FILE(GLOB _CMAKE_OSX_SDKS "${OSX_DEVELOPER_ROOT}/SDKs/*")
   ENDIF(CMAKE_XCODE_SELECT)
 ENDIF(NOT _CMAKE_OSX_SDKS)

Modules/Platform/Windows-GNU.cmake

@@ -43,6 +43,7 @@ endif()
 set(CMAKE_DL_LIBS "")
 set(CMAKE_LIBRARY_PATH_FLAG "-L")
 set(CMAKE_LINK_LIBRARY_FLAG "-l")
+set(CMAKE_LINK_DEF_FILE_FLAG "") # Empty string: passing the file is enough
 set(CMAKE_LINK_LIBRARY_SUFFIX "")
 set(CMAKE_CREATE_WIN32_EXE  "-mwindows")
 

Modules/UsewxWidgets.cmake

@@ -6,7 +6,7 @@
 #  # Note that for MinGW users the order of libs is important!
 #  FIND_PACKAGE(wxWidgets REQUIRED net gl core base)
 #  INCLUDE(${wxWidgets_USE_FILE})
-#  # and for each of your dependant executable/library targets:
+#  # and for each of your dependent executable/library targets:
 #  TARGET_LINK_LIBRARIES(<YourTarget> ${wxWidgets_LIBRARIES})
 #
 # DEPRECATED

Source/CMakeLists.txt

@@ -343,7 +343,7 @@ TARGET_LINK_LIBRARIES(CMakeLib cmsys
   ${CMAKE_TAR_LIBRARIES} ${CMAKE_COMPRESS_LIBRARIES}
   ${CMAKE_CURL_LIBRARIES} )
 
-# On Apple we need Carbon
+# On Apple we need CoreFoundation
 IF(APPLE)
   TARGET_LINK_LIBRARIES(CMakeLib "-framework CoreFoundation")
 ENDIF(APPLE)
@@ -465,7 +465,7 @@ IF(APPLE)
   ADD_EXECUTABLE(OSXScriptLauncher
     CPack/OSXScriptLauncher.cxx)
   TARGET_LINK_LIBRARIES(OSXScriptLauncher cmsys)
-  TARGET_LINK_LIBRARIES(OSXScriptLauncher "-framework Carbon")
+  TARGET_LINK_LIBRARIES(OSXScriptLauncher "-framework CoreFoundation")
 ENDIF(APPLE)
 
 # Build CMake executable

Source/CPack/OSXScriptLauncher.cxx

@@ -14,7 +14,6 @@
 #include <cmsys/ios/fstream>
 #include <cmsys/ios/iostream>
 
-#include <Carbon/Carbon.h>
 #include <CoreFoundation/CoreFoundation.h>
 
 // For the PATH_MAX constant

Source/CPack/cmCPackArchiveGenerator.cxx

@@ -121,9 +121,11 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
           << std::endl);
       // Begin the archive for this group
       std::string packageFileName= std::string(toplevel);
-      packageFileName += "/"
+      packageFileName += "/"+
-        +std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
+       GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-        +"-"+compGIt->first + this->GetOutputExtension();
+                                   compGIt->first,
+                                   true)
+         + this->GetOutputExtension();
       // open a block in order to automatically close archive
       // at the end of the block
       {
@@ -154,9 +156,11 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
       std::string packageFileName = std::string(toplevel);
 
       localToplevel += "/"+ compIt->first;
-      packageFileName += "/"
+      packageFileName += "/"+
-        +std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
+       GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-        +"-"+compIt->first + this->GetOutputExtension();
+                                   compIt->first,
+                                   false)
+        + this->GetOutputExtension();
       {
         DECLARE_AND_OPEN_ARCHIVE(packageFileName,archive);
         // Add the files of this component to the archive
@@ -177,7 +181,7 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne(bool allComponent)
   packageFileNames.push_back(std::string(toplevel));
   packageFileNames[0] += "/"
     +std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
-    +"-ALL" + this->GetOutputExtension();
+    + this->GetOutputExtension();
   cmCPackLogger(cmCPackLog::LOG_VERBOSE,
                 "Packaging all groups in one package..."
                 "(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE is set)"
@@ -226,8 +230,6 @@ int cmCPackArchiveGenerator::PackageFiles()
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
                 << toplevel << std::endl);
 
-  PrepareGroupingKind();
-
   if (SupportsComponentInstallation()) {
     // CASE 1 : COMPONENT ALL-IN-ONE package
     // If ALL GROUPS or ALL COMPONENTS in ONE package has been requested

Source/CPack/cmCPackGenerator.cxx

@@ -684,7 +684,14 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
         if (componentInstall)
           {
           tempInstallDirectory += "/";
-          tempInstallDirectory += installComponent;
+          // Some CPack generators would rather chose
+          // the local installation directory suffix.
+          // Some (e.g. RPM) use
+          //  one install directory for each component **GROUP**
+          // instead of the default
+          //  one install directory for each component.
+          tempInstallDirectory +=
+            GetComponentInstallDirNameSuffix(installComponent);
           }
 
         if (!setDestDir)
@@ -873,6 +880,12 @@ int cmCPackGenerator::DoPackage()
     return 0;
     }
 
+  // Digest Component grouping specification
+  if ( !this->PrepareGroupingKind() )
+    {
+    return 0;
+    }
+
   if ( cmSystemTools::IsOn(
       this->GetOption("CPACK_REMOVE_TOPLEVEL_DIRECTORY")) )
     {
@@ -1251,11 +1264,11 @@ int cmCPackGenerator::PrepareGroupingKind()
     cmCPackLogger(cmCPackLog::LOG_VERBOSE,  "["
         << this->Name << "]"
         << " requested component grouping = "<< groupingType <<std::endl);
-    if (groupingType == "ALL_GROUP_IN_ONE")
+    if (groupingType == "ALL_GROUPS_IN_ONE")
       {
       allGroupInOne = true;
       }
-    else if (groupingType == "ALL_COMPONENT_IN_ONE")
+    else if (groupingType == "ALL_COMPONENTS_IN_ONE")
       {
       allComponentInOne = true;
       }
@@ -1268,11 +1281,19 @@ int cmCPackGenerator::PrepareGroupingKind()
       cmCPackLogger(cmCPackLog::LOG_WARNING, "["
               << this->Name << "]"
               << " requested component grouping type <"<< groupingType
-              << "> UNKNOWN not in (ALL_GROUP_IN_ONE,"
+              << "> UNKNOWN not in (ALL_GROUPS_IN_ONE,"
-                    "ALL_COMPONENT_IN_ONE,IGNORE)" <<std::endl);
+                    "ALL_COMPONENTS_IN_ONE,IGNORE)" <<std::endl);
       }
     }
 
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,  "["
+        << this->Name << "]"
+        << " requested component grouping = ("
+        << "ALL_GROUPS_IN_ONE=" << allGroupInOne
+        << ", ALL_COMPONENTS_IN_ONE=" << allComponentInOne
+        << ", IGNORE_GROUPS=" << ignoreComponentGroup
+        << ")"
+        << std::endl);
   // Some components were defined but NO group
   // force ignoreGroups
   if (this->ComponentGroups.empty() && (!this->Components.empty())
@@ -1288,6 +1309,52 @@ int cmCPackGenerator::PrepareGroupingKind()
   return 1;
 }
 
+//----------------------------------------------------------------------
+std::string cmCPackGenerator::GetComponentInstallDirNameSuffix(
+    const std::string& componentName) {
+  return componentName;
+}
+//----------------------------------------------------------------------
+std::string cmCPackGenerator::GetComponentPackageFileName(
+    const std::string& initialPackageFileName,
+    const std::string& groupOrComponentName,
+    bool isGroupName) {
+
+  /*
+   * the default behavior is to use the
+   * component [group] name as a suffix
+   */
+  std::string suffix="-"+groupOrComponentName;
+  /* check if we should use DISPLAY name */
+  std::string dispNameVar = "CPACK_"+Name+"_USE_DISPLAY_NAME_IN_FILENAME";
+  if (IsOn(dispNameVar.c_str()))
+    {
+    /* the component Group case */
+    if (isGroupName)
+      {
+      std::string groupDispVar = "CPACK_COMPONENT_GROUP_"
+          + cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
+      const char* groupDispName = GetOption(groupDispVar.c_str());
+      if (groupDispName)
+        {
+        suffix = "-"+std::string(groupDispName);
+        }
+      }
+    /* the [single] component case */
+    else
+      {
+      std::string dispVar = "CPACK_COMPONENT_"
+           + cmSystemTools::UpperCase(groupOrComponentName) + "_DISPLAY_NAME";
+            const char* dispName = GetOption(dispVar.c_str());
+            if(dispName)
+              {
+              suffix = "-"+std::string(dispName);
+              }
+            }
+      }
+  return initialPackageFileName + suffix;
+}
+
 //----------------------------------------------------------------------
 bool cmCPackGenerator::SupportsComponentInstallation() const
 {

Source/CPack/cmCPackGenerator.h

@@ -131,6 +131,32 @@ protected:
    */
   virtual int PrepareGroupingKind();
 
+  /**
+   * Some CPack generators may prefer to have
+   * CPack install all components belonging to the same
+   * [component] group to be install in the same directory.
+   * The default behavior is to install each component in
+   * a separate directory.
+   * @param[in] componentName the name of the component to be installed
+   * @return the name suffix the generator wants for the specified component
+   *         default is "componentName"
+   */
+  virtual std::string GetComponentInstallDirNameSuffix(
+      const std::string& componentName);
+
+  /**
+   * CPack specific generator may mangle CPACK_PACKAGE_FILE_NAME
+   * with CPACK_COMPONENT_xxxx_<NAME>_DISPLAY_NAME if
+   * CPACK_<GEN>_USE_DISPLAY_NAME_IN_FILENAME is ON.
+   * @param[in] initialPackageFileName
+   * @param[in] groupOrComponentName
+   * @param[in] isGroupName
+   */
+  virtual std::string GetComponentPackageFileName(
+      const std::string& initialPackageFileName,
+      const std::string& groupOrComponentName,
+      bool isGroupName);
+
   /**
    * Package the list of files and/or components which
    * has been prepared by the beginning of DoPackage.

Source/CPack/cmCPackOSXX11Generator.cxx

@@ -150,7 +150,7 @@ int cmCPackOSXX11Generator::PackageFiles()
   // since we get random dashboard failures with this one
   // try running it more than once
   int numTries = 4;
-  bool res;
+  bool res = false;
   while(numTries > 0)
     {
     res = cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output,

Source/CPack/cmCPackPackageMakerGenerator.cxx

@@ -320,7 +320,7 @@ int cmCPackPackageMakerGenerator::PackageFiles()
   std::string output;
   int retVal = 1;
   int numTries = 4;
-  bool res;
+  bool res = false;
   while(numTries > 0)
     {
     res = cmSystemTools::RunSingleCommand(dmgCmd.str().c_str(), &output,

Source/CPack/cmCPackRPMGenerator.cxx

@@ -31,39 +31,94 @@ int cmCPackRPMGenerator::InitializeInternal()
     {
     this->SetOption("CPACK_SET_DESTDIR", "I_ON");
     }
+  /* Replace space in CPACK_PACKAGE_NAME in order to avoid
+   * rpmbuild scream on unwanted space in filename issue
+   * Moreover RPM file do not usually embed space in filename
+   */
+  if (this->GetOption("CPACK_PACKAGE_NAME")) {
+    std::string packageName=this->GetOption("CPACK_PACKAGE_NAME");
+    cmSystemTools::ReplaceString(packageName," ","-");
+    this->SetOption("CPACK_PACKAGE_NAME",packageName.c_str());
+  }
+  /* same for CPACK_PACKAGE_FILE_NAME */
+  if (this->GetOption("CPACK_PACKAGE_FILE_NAME")) {
+    std::string packageName=this->GetOption("CPACK_PACKAGE_FILE_NAME");
+    cmSystemTools::ReplaceString(packageName," ","-");
+    this->SetOption("CPACK_PACKAGE_FILE_NAME",packageName.c_str());
+  }
   return this->Superclass::InitializeInternal();
 }
 
 //----------------------------------------------------------------------
-int cmCPackRPMGenerator::PackageFiles()
+int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup)
 {
   int retval = 1;
-  /* Digest Component grouping specification */
+  /* Reset package file name list it will be populated during the
-  retval = PrepareGroupingKind();
+   * component packaging run*/
-  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
+  packageFileNames.clear();
-                  << toplevel << std::endl);
+  std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
 
-  /* Are we in the component packaging case */
+  // The default behavior is to have one package by component group
-  if (SupportsComponentInstallation() & (!this->ComponentGroups.empty()))
+  // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
+  if (!ignoreGroup)
+    {
+    std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
+    for (compGIt=this->ComponentGroups.begin();
+        compGIt!=this->ComponentGroups.end(); ++compGIt)
+      {
+      cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Packaging component group: "
+          << compGIt->first
+          << std::endl);
+      // Begin the archive for this group
+      std::string localToplevel(initialTopLevel);
+      std::string packageFileName(
+          cmSystemTools::GetParentDirectory(toplevel.c_str())
+                                 );
+      std::string outputFileName(
+       GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
+                                   compGIt->first,
+                                   true)
+                                   + this->GetOutputExtension()
+                                );
+
+      localToplevel += "/"+ compGIt->first;
+      /* replace the TEMP DIRECTORY with the component one */
+      this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
+      packageFileName += "/"+ outputFileName;
+      /* replace proposed CPACK_OUTPUT_FILE_NAME */
+      this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
+      /* replace the TEMPORARY package file name */
+      this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+                      packageFileName.c_str());
+      // Tell CPackRPM.cmake the name of the component GROUP.
+      this->SetOption("CPACK_RPM_PACKAGE_COMPONENT",compGIt->first.c_str());
+      if (!this->ReadListFile("CPackRPM.cmake"))
+        {
+        cmCPackLogger(cmCPackLog::LOG_ERROR,
+            "Error while execution CPackRPM.cmake" << std::endl);
+        retval = 0;
+        }
+      // add the generated package to package file names list
+      packageFileNames.push_back(packageFileName);
+      }
+    }
+  // CPACK_COMPONENTS_IGNORE_GROUPS is set
+  // We build 1 package per component
+  else
     {
-    /* Reset package file name list it will be populated during the
-     * component packaging run*/
-    packageFileNames.clear();
-    std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
-    /* One Package per component CASE */
-    /* Iterate over components */
     std::map<std::string, cmCPackComponent>::iterator compIt;
     for (compIt=this->Components.begin();
-        compIt!=this->Components.end(); ++compIt )
+         compIt!=this->Components.end(); ++compIt )
       {
       std::string localToplevel(initialTopLevel);
       std::string packageFileName(
           cmSystemTools::GetParentDirectory(toplevel.c_str())
                                  );
       std::string outputFileName(
-          std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")
+       GetComponentPackageFileName(this->GetOption("CPACK_PACKAGE_FILE_NAME"),
-                                )
+                                   compIt->first,
-        +"-"+compIt->first + this->GetOutputExtension());
+                                   false)
+       + this->GetOutputExtension());
 
       localToplevel += "/"+ compIt->first;
       /* replace the TEMP DIRECTORY with the component one */
@@ -82,12 +137,101 @@ int cmCPackRPMGenerator::PackageFiles()
                       "Error while execution CPackRPM.cmake" << std::endl);
         retval = 0;
         }
-
       // add the generated package to package file names list
       packageFileNames.push_back(packageFileName);
       }
     }
-  /* This is the non component case */
+  return retval;
+}
+
+//----------------------------------------------------------------------
+int cmCPackRPMGenerator::PackageComponentsAllInOne(bool allComponent)
+{
+  int retval = 1;
+  std::string compInstDirName;
+  /* Reset package file name list it will be populated during the
+   * component packaging run*/
+  packageFileNames.clear();
+  std::string initialTopLevel(this->GetOption("CPACK_TEMPORARY_DIRECTORY"));
+
+  // all GROUP in one vs all COMPONENT in one
+  if (allComponent)
+    {
+    compInstDirName = "ALL_COMPONENTS_IN_ONE";
+    }
+  else
+    {
+    compInstDirName = "ALL_GROUPS_IN_ONE";
+    }
+
+  cmCPackLogger(cmCPackLog::LOG_VERBOSE,
+                "Packaging all groups in one package..."
+                "(CPACK_COMPONENTS_ALL_[GROUPS_]IN_ONE_PACKAGE is set)"
+      << std::endl);
+
+  // The ALL GROUPS in ONE package case
+  std::string localToplevel(initialTopLevel);
+  std::string packageFileName(
+      cmSystemTools::GetParentDirectory(toplevel.c_str())
+                             );
+  std::string outputFileName(
+            std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME"))
+            + this->GetOutputExtension()
+                            );
+  // all GROUP in one vs all COMPONENT in one
+  localToplevel += "/"+compInstDirName;
+
+  /* replace the TEMP DIRECTORY with the component one */
+  this->SetOption("CPACK_TEMPORARY_DIRECTORY",localToplevel.c_str());
+  packageFileName += "/"+ outputFileName;
+  /* replace proposed CPACK_OUTPUT_FILE_NAME */
+  this->SetOption("CPACK_OUTPUT_FILE_NAME",outputFileName.c_str());
+  /* replace the TEMPORARY package file name */
+  this->SetOption("CPACK_TEMPORARY_PACKAGE_FILE_NAME",
+      packageFileName.c_str());
+  // Tell CPackRPM.cmake the name of the component GROUP.
+  this->SetOption("CPACK_RPM_PACKAGE_COMPONENT",compInstDirName.c_str());
+  if (!this->ReadListFile("CPackRPM.cmake"))
+    {
+    cmCPackLogger(cmCPackLog::LOG_ERROR,
+        "Error while execution CPackRPM.cmake" << std::endl);
+    retval = 0;
+    }
+  // add the generated package to package file names list
+  packageFileNames.push_back(packageFileName);
+
+  return retval;
+}
+
+//----------------------------------------------------------------------
+int cmCPackRPMGenerator::PackageFiles()
+{
+  int retval = 1;
+
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
+                  << toplevel << std::endl);
+
+  /* Are we in the component packaging case */
+  if (SupportsComponentInstallation()) {
+    // CASE 1 : COMPONENT ALL-IN-ONE package
+    // If ALL GROUPS or ALL COMPONENTS in ONE package has been requested
+    // then the package file is unique and should be open here.
+    if (allComponentInOne ||
+        (allGroupInOne && (!this->ComponentGroups.empty()))
+       )
+      {
+      return PackageComponentsAllInOne(allComponentInOne);
+      }
+    // CASE 2 : COMPONENT CLASSICAL package(s) (i.e. not all-in-one)
+    // There will be 1 package for each component group
+    // however one may require to ignore component group and
+    // in this case you'll get 1 package for each component.
+    else if ((!this->ComponentGroups.empty()) || (ignoreComponentGroup))
+      {
+      return PackageComponents(ignoreComponentGroup);
+      }
+  }
+  // CASE 3 : NON COMPONENT package.
   else
     {
     if (!this->ReadListFile("CPackRPM.cmake"))
@@ -118,3 +262,33 @@ bool cmCPackRPMGenerator::SupportsComponentInstallation() const
     }
   }
 
+std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix(
+    const std::string& componentName)
+  {
+  if (ignoreComponentGroup) {
+    return componentName;
+  }
+
+  if (allComponentInOne) {
+    return std::string("ALL_COMPONENTS_IN_ONE");
+  }
+  // We have to find the name of the COMPONENT GROUP
+  // the current COMPONENT belongs to.
+  std::string groupVar = "CPACK_COMPONENT_" +
+        cmSystemTools::UpperCase(componentName) + "_GROUP";
+    if (NULL != GetOption(groupVar.c_str()))
+      {
+      if (allGroupInOne)
+        {
+        return std::string("ALL_GROUPS_IN_ONE");
+        }
+      else
+        {
+        return std::string(GetOption(groupVar.c_str()));
+        }
+      }
+    else
+      {
+      return componentName;
+      }
+  }

Source/CPack/cmCPackRPMGenerator.h

@@ -38,8 +38,21 @@ public:
 protected:
   virtual int InitializeInternal();
   virtual int PackageFiles();
+  /**
+   * The method used to package files when component
+   * install is used. This will create one
+   * archive for each component group.
+   */
+  int PackageComponents(bool ignoreGroup);
+  /**
+   * Special case of component install where all
+   * components will be put in a single installer.
+   */
+  int PackageComponentsAllInOne(bool allComponent);
   virtual const char* GetOutputExtension() { return ".rpm"; }
   virtual bool SupportsComponentInstallation() const;
+  virtual std::string GetComponentInstallDirNameSuffix(
+      const std::string& componentName);
 
 };
 

Source/CTest/cmCTestCoverageHandler.cxx

@@ -825,7 +825,7 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
     // Call gcov to get coverage data for this *.gcda file:
     //
     std::string fileDir = cmSystemTools::GetFilenamePath(it->c_str());
-    std::string command = "\"" + gcovCommand + "\" -l -o \"" + fileDir
+    std::string command = "\"" + gcovCommand + "\" -l -p -o \"" + fileDir
       + "\" \"" + *it + "\"";
 
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, command.c_str()

Source/CTest/cmCTestMultiProcessHandler.cxx

@@ -484,7 +484,7 @@ void cmCTestMultiProcessHandler::CreateTestCostList()
     }
 
   TestComparator comp(this);
-  std::sort(SortedTests.begin(), SortedTests.end(), comp);
+  std::stable_sort(SortedTests.begin(), SortedTests.end(), comp);
 }
 
 //---------------------------------------------------------

Source/CursesDialog/form/frm_driver.c

@@ -1086,7 +1086,7 @@ _nc_Synchronize_Options(FIELD *field, Field_Options newopts)
 
       if (form->status & _POSTED)
         {
-          if ((form->curpage == field->page))
+          if (form->curpage == field->page)
             {
               if (changed_opts & O_VISIBLE)
                 {

Source/QtDialog/QCMakeCacheView.cxx

@@ -293,6 +293,8 @@ void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
       parentItems.append(new QStandardItem());
       parentItems[0]->setData(QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
       parentItems[1]->setData(QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
+      parentItems[0]->setData(1, GroupRole);
+      parentItems[1]->setData(1, GroupRole);
       root->appendRow(parentItems);
 
       int num = props2.size();
@@ -314,6 +316,7 @@ void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
       QStandardItem* parentItem = 
         new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key);
       root->appendRow(parentItem);
+      parentItem->setData(1, GroupRole);
 
       int num = props2.size();
       for(int i=0; i<num; i++)
@@ -478,10 +481,13 @@ QCMakePropertyList QCMakeCacheModel::properties() const
     }
     else
     {
-      // get data
+      if(!data(idx, GroupRole).toInt())
-      QCMakeProperty prop;
+      {
-      this->getPropertyData(idx, prop);
+        // get data
-      props.append(prop);
+        QCMakeProperty prop;
+        this->getPropertyData(idx, prop);
+        props.append(prop);
+      }
       
       // go to the next in the tree
       while(!idxs.isEmpty() && !idxs.last().sibling(idxs.last().row()+1, 0).isValid())

Source/QtDialog/QCMakeCacheView.h

@@ -67,7 +67,9 @@ public:
   enum { HelpRole = Qt::ToolTipRole,
          TypeRole = Qt::UserRole, 
          AdvancedRole,
-         StringsRole};
+         StringsRole,
+         GroupRole
+       };
 
   enum ViewType { FlatView, GroupView };
 

Source/cmAddCustomCommandCommand.cxx

@@ -286,6 +286,13 @@ bool cmAddCustomCommandCommand
     return false;
     }
 
+  // Convert working directory to a full path.
+  if(!working.empty())
+    {
+    const char* build_dir = this->Makefile->GetCurrentOutputDirectory();
+    working = cmSystemTools::CollapseFullPath(working.c_str(), build_dir);
+    }
+
   // Choose which mode of the command to use.
   bool escapeOldStyle = !verbatim;
   if(source.empty() && output.empty())

Source/cmAddCustomCommandCommand.h

@@ -110,6 +110,8 @@ public:
       "will be treated as PRE_LINK.\n"
       "If WORKING_DIRECTORY is specified the command will be executed "
       "in the directory given. "
+      "If it is a relative path it will be interpreted relative to the "
+      "build tree directory corresponding to the current source directory. "
       "If COMMENT is set, the value will be displayed as a "
       "message before the commands are executed at build time. "
       "If APPEND is specified the COMMAND and DEPENDS option values "

Source/cmAddCustomTargetCommand.cxx

@@ -166,6 +166,14 @@ bool cmAddCustomTargetCommand
     }
   }
 
+  // Convert working directory to a full path.
+  if(!working_directory.empty())
+    {
+    const char* build_dir = this->Makefile->GetCurrentOutputDirectory();
+    working_directory =
+      cmSystemTools::CollapseFullPath(working_directory.c_str(), build_dir);
+    }
+
   // Add the utility target to the makefile.
   bool escapeOldStyle = !verbatim;
   cmTarget* target =

Source/cmAddCustomTargetCommand.h

@@ -79,6 +79,8 @@ public:
       "empty target will be created. "
       "If WORKING_DIRECTORY is set, then the command will be run in that "
       "directory. "
+      "If it is a relative path it will be interpreted relative to the "
+      "build tree directory corresponding to the current source directory. "
       "If COMMENT is set, the value will be displayed as a "
       "message before the commands are executed at build time. "
       "Dependencies listed with the DEPENDS argument may reference files "

Source/cmDocumentVariables.cxx

@@ -96,6 +96,30 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
      "See also CMAKE_CURRENT_LIST_FILE.",false,
      "Variables that Provide Information");
 
+  cm->DefineProperty
+    ("CMAKE_SCRIPT_MODE_FILE", cmProperty::VARIABLE,
+     "Full path to the -P script file currently being processed. ",
+     "When run in -P script mode, CMake sets this variable to the full "
+     "path of the script file. When run to configure a CMakeLists.txt "
+     "file, this variable is not set.", false,
+     "Variables that Provide Information");
+
+  cm->DefineProperty
+    ("CMAKE_ARGC", cmProperty::VARIABLE,
+     "Number of command line arguments passed to CMake in script mode. ",
+     "When run in -P script mode, CMake sets this variable to the number "
+     "of command line arguments. See also CMAKE_ARGV0, 1, 2 ... ", false,
+     "Variables that Provide Information");
+
+  cm->DefineProperty
+    ("CMAKE_ARGV0", cmProperty::VARIABLE,
+     "Command line argument passed to CMake in script mode. ",
+     "When run in -P script mode, CMake sets this variable to "
+     "the first command line argument. It then also sets CMAKE_ARGV1, "
+     "CMAKE_ARGV2, ... and so on, up to the number of command line arguments "
+     "given. See also CMAKE_ARGC.", false,
+     "Variables that Provide Information");
+
   cm->DefineProperty
     ("CMAKE_BUILD_TOOL", cmProperty::VARIABLE,
      "Tool used for the actual build process.",
@@ -867,8 +891,14 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
   cm->DefineProperty
     ("MSVC_VERSION", cmProperty::VARIABLE,
      "The version of Microsoft Visual C/C++ being used if any.",
-     "The version of Microsoft Visual C/C++ being used if any. "
+     "Known version numbers are:\n"
-     "For example 1300 is MSVC 6.0.",
+     "  1200 = VS  6.0\n"
+     "  1300 = VS  7.0\n"
+     "  1310 = VS  7.1\n"
+     "  1400 = VS  8.0\n"
+     "  1500 = VS  9.0\n"
+     "  1600 = VS 10.0\n"
+     "",
      false,
      "Variables That Describe the System");
 

Source/cmExportFileGenerator.cxx

@@ -325,6 +325,12 @@ cmExportFileGenerator
     os << "SET_PROPERTY(TARGET " << targetName
        << " PROPERTY MACOSX_BUNDLE 1)\n";
     }
+
+  if (target->IsCFBundleOnApple())
+    {
+    os << "SET_PROPERTY(TARGET " << targetName
+       << " PROPERTY BUNDLE 1)\n";
+    }
   os << "\n";
 }
 

Source/cmExportInstallFileGenerator.cxx

@@ -263,6 +263,20 @@ cmExportInstallFileGenerator
       value += ".framework/";
       value += itgen->GetInstallFilename(target, config);
       }
+    else if(target->IsCFBundleOnApple())
+      {
+      const char *ext = target->GetProperty("BUNDLE_EXTENSION");
+      if (!ext)
+        {
+        ext = "bundle";
+        }
+
+      value += itgen->GetInstallFilename(target, config);
+      value += ".";
+      value += ext;
+      value += "/";
+      value += itgen->GetInstallFilename(target, config);
+      }
     else if(target->IsAppBundleOnApple())
       {
       value += itgen->GetInstallFilename(target, config);

Source/cmExtraCodeBlocksGenerator.cxx

@@ -416,11 +416,18 @@ void cmExtraCodeBlocksGenerator
         case cmTarget::STATIC_LIBRARY:
         case cmTarget::SHARED_LIBRARY:
         case cmTarget::MODULE_LIBRARY:
+        case cmTarget::UTILITY: // can have sources since 2.6.3
           {
           const std::vector<cmSourceFile*>&sources=ti->second.GetSourceFiles();
           for (std::vector<cmSourceFile*>::const_iterator si=sources.begin();
                si!=sources.end(); si++)
             {
+            // don't add source files which have the GENERATED property set:
+            if ((*si)->GetPropertyAsBool("GENERATED"))
+              {
+              continue;
+              }
+
             // check whether it is a C/C++ implementation file
             bool isCFile = false;
             if ((*si)->GetLanguage() && (*(*si)->GetLanguage() == 'C'))

Source/cmExtraEclipseCDT4Generator.cxx

@@ -102,7 +102,7 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() const
   fout <<
     "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     "<projectDescription>\n"
-    "\t<name>" << name << "</name>\n"
+    "\t<name>" << this->EscapeForXML(name) << "</name>\n"
     "\t<comment></comment>\n"
     "\t<projects>\n"
     "\t</projects>\n"
@@ -376,11 +376,10 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     "\t</natures>\n"
     ;
 
-  // TODO: refactor this
+  fout << "\t<linkedResources>\n";
   // create linked resources
   if (this->IsOutOfSourceBuild)
     {
-    fout << "\t<linkedResources>\n";
     // create a linked resource to CMAKE_SOURCE_DIR
     // (this is not done anymore for each project because of
     // http://public.kitware.com/Bug/view.php?id=9978 and because I found it
@@ -399,18 +398,48 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
       this->SrcLinkedResources.push_back(sourceLinkedResourceName);
       }
 
-    // for EXECUTABLE_OUTPUT_PATH when not in binary dir
-    this->AppendOutLinkedResource(fout,
-      mf->GetSafeDefinition("CMAKE_RUNTIME_OUTPUT_DIRECTORY"),
-      mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"));
-    // for LIBRARY_OUTPUT_PATH when not in binary dir
-    this->AppendOutLinkedResource(fout,
-      mf->GetSafeDefinition("CMAKE_LIBRARY_OUTPUT_DIRECTORY"),
-      mf->GetSafeDefinition("LIBRARY_OUTPUT_PATH"));
-
-    fout << "\t</linkedResources>\n";
     }
 
+  // for each sub project create a linked resource to the source dir
+  // - only if it is an out-of-source build
+  this->AppendLinkedResource(fout, "[Subprojects]",
+                             "virtual:/virtual");
+
+  for (std::map<cmStdString, std::vector<cmLocalGenerator*> >::const_iterator
+       it = this->GlobalGenerator->GetProjectMap().begin();
+       it != this->GlobalGenerator->GetProjectMap().end();
+       ++it)
+    {
+    std::string linkSourceDirectory = this->GetEclipsePath(
+                            it->second[0]->GetMakefile()->GetStartDirectory());
+    // a linked resource must not point to a parent directory of .project or
+    // .project itself
+    if ((this->HomeOutputDirectory != linkSourceDirectory) &&
+        !cmSystemTools::IsSubDirectory(this->HomeOutputDirectory.c_str(),
+                                       linkSourceDirectory.c_str()))
+      {
+      std::string linkName = "[Subprojects]/";
+      linkName += it->first;
+      this->AppendLinkedResource(fout, linkName,
+                                 this->GetEclipsePath(linkSourceDirectory));
+      this->SrcLinkedResources.push_back(it->first);
+      }
+    }
+
+  // I'm not sure this makes too much sense. There can be different
+  // output directories in different subdirs, so we would need more of them.
+
+  // for EXECUTABLE_OUTPUT_PATH when not in binary dir
+  this->AppendOutLinkedResource(fout,
+    mf->GetSafeDefinition("CMAKE_RUNTIME_OUTPUT_DIRECTORY"),
+    mf->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH"));
+  // for LIBRARY_OUTPUT_PATH when not in binary dir
+  this->AppendOutLinkedResource(fout,
+    mf->GetSafeDefinition("CMAKE_LIBRARY_OUTPUT_DIRECTORY"),
+    mf->GetSafeDefinition("LIBRARY_OUTPUT_PATH"));
+
+  fout << "\t</linkedResources>\n";
+
   fout << "</projectDescription>\n";
 }
 
@@ -431,7 +460,8 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
         {
         emittedDirs.insert(dir);
         fout << "<pathentry include=\""
-             << cmExtraEclipseCDT4Generator::GetEclipsePath(dir)
+             << cmExtraEclipseCDT4Generator::EscapeForXML(
+                              cmExtraEclipseCDT4Generator::GetEclipsePath(dir))
              << "\" kind=\"inc\" path=\"\" system=\"true\"/>\n";
         }
       }
@@ -550,14 +580,15 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
        it != this->SrcLinkedResources.end();
        ++it)
     {
-    fout << "<pathentry kind=\"src\" path=\"" << *it << "\"/>\n";
+    fout << "<pathentry kind=\"src\" path=\"" << this->EscapeForXML(*it)
+         << "\"/>\n";
 
     // exlude source directory from output search path
     // - only if not named the same as an output directory
     if (!cmSystemTools::FileIsDirectory(
            std::string(this->HomeOutputDirectory + "/" + *it).c_str()))
       {
-      excludeFromOut += *it + "/|";
+      excludeFromOut += this->EscapeForXML(*it) + "/|";
       }
     }
   excludeFromOut += "**/CMakeFiles/";
@@ -572,7 +603,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
        it != this->OutLinkedResources.end();
        ++it)
     {
-    fout << "<pathentry kind=\"out\" path=\"" << *it << "\"/>\n";
+    fout << "<pathentry kind=\"out\" path=\"" << this->EscapeForXML(*it)
+         << "\"/>\n";
     }
 
   // add pre-processor definitions to allow eclipse to gray out sections
@@ -875,8 +907,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   fout << "</cconfiguration>\n"
           "</storageModule>\n"
           "<storageModule moduleId=\"cdtBuildSystem\" version=\"4.0.0\">\n"
-          "<project id=\"" << mf->GetProjectName() << ".null.1\""
+          "<project id=\"" << this->EscapeForXML(mf->GetProjectName())
-          " name=\"" << mf->GetProjectName() << "\"/>\n"
+       << ".null.1\" name=\"" << this->EscapeForXML(mf->GetProjectName())
+       << "\"/>\n"
           "</storageModule>\n"
           "</cproject>\n"
           ;
@@ -927,7 +960,8 @@ cmExtraEclipseCDT4Generator::GenerateProjectName(const std::string& name,
                                                  const std::string& type,
                                                  const std::string& path)
 {
-  return name + (type.empty() ? "" : "-") + type + "@" + path;
+  return cmExtraEclipseCDT4Generator::EscapeForXML(name)
+                                +(type.empty() ? "" : "-") + type + "@" + path;
 }
 
 std::string cmExtraEclipseCDT4Generator::EscapeForXML(const std::string& value)
@@ -999,15 +1033,17 @@ void cmExtraEclipseCDT4Generator::AppendTarget(cmGeneratedFileStream& fout,
                                                const std::string&     path,
                                                const char* prefix)
 {
+  std::string targetXml = cmExtraEclipseCDT4Generator::EscapeForXML(target);
+  std::string pathXml = cmExtraEclipseCDT4Generator::EscapeForXML(path);
   fout <<
-    "<target name=\"" << prefix << target << "\""
+    "<target name=\"" << prefix << targetXml << "\""
-    " path=\"" << path.c_str() << "\""
+    " path=\"" << pathXml.c_str() << "\""
     " targetID=\"org.eclipse.cdt.make.MakeTargetBuilder\">\n"
     "<buildCommand>"
     << cmExtraEclipseCDT4Generator::GetEclipsePath(make)
     << "</buildCommand>\n"
     "<buildArguments>"  << makeArgs << "</buildArguments>\n"
-    "<buildTarget>" << target << "</buildTarget>\n"
+    "<buildTarget>" << targetXml << "</buildTarget>\n"
     "<stopOnError>true</stopOnError>\n"
     "<useDefaultCommand>false</useDefaultCommand>\n"
     "</target>\n"
@@ -1050,11 +1086,13 @@ void cmExtraEclipseCDT4Generator
 {
   fout <<
     "\t\t<link>\n"
-    "\t\t\t<name>" << name << "</name>\n"
+    "\t\t\t<name>"
+    << cmExtraEclipseCDT4Generator::EscapeForXML(name)
+    << "</name>\n"
     "\t\t\t<type>2</type>\n"
-    "\t\t\t<location>"
+    "\t\t\t<locationURI>"
-    << path
+    << cmExtraEclipseCDT4Generator::EscapeForXML(path)
-    << "</location>\n"
+    << "</locationURI>\n"
     "\t\t</link>\n"
     ;
 }

Source/cmFileCommand.cxx

@@ -75,6 +75,10 @@ bool cmFileCommand
     {
     return this->HandleDownloadCommand(args);
     }
+  else if ( subCommand == "UPLOAD" )
+    {
+    return this->HandleUploadCommand(args);
+    }
   else if ( subCommand == "READ" )
     {
     return this->HandleReadCommand(args);
@@ -1707,7 +1711,7 @@ protected:
   {
     DoingType = DoingLast1,
     DoingRename,
-    DoingSelf24
+    DoingLast2
   };
   virtual bool CheckKeyword(std::string const& arg);
   virtual bool CheckValue(std::string const& arg);
@@ -1846,22 +1850,12 @@ bool cmFileInstaller::CheckKeyword(std::string const& arg)
   else if(arg == "COMPONENTS" || arg == "CONFIGURATIONS" ||
           arg == "PROPERTIES")
     {
-    if(this->Makefile->IsOn("CMAKE_INSTALL_SELF_2_4"))
+    cmOStringStream e;
-      {
+    e << "INSTALL called with old-style " << arg << " argument.  "
-      // When CMake 2.4 builds this CMake version we need to support
+      << "This script was generated with an older version of CMake.  "
-      // the install scripts it generates since it asks this CMake
+      << "Re-run this cmake version on your build tree.";
-      // to install itself using the rules it generated.
+    this->FileCommand->SetError(e.str().c_str());
-      this->Doing = DoingSelf24;
+    this->Doing = DoingError;
-      }
-    else
-      {
-      cmOStringStream e;
-      e << "INSTALL called with old-style " << arg << " argument.  "
-        << "This script was generated with an older version of CMake.  "
-        << "Re-run this cmake version on your build tree.";
-      this->FileCommand->SetError(e.str().c_str());
-      this->Doing = DoingError;
-      }
     }
   else
     {
@@ -1884,12 +1878,6 @@ bool cmFileInstaller::CheckValue(std::string const& arg)
     case DoingRename:
       this->Rename = arg;
       break;
-    case DoingSelf24:
-      // Ignore these arguments for compatibility.  This should be
-      // reached only when CMake 2.4 is installing the current
-      // CMake.  It can be removed when CMake 2.6 or higher is
-      // required to build CMake.
-      break;
     default:
       return this->cmFileCopier::CheckValue(arg);
     }
@@ -2432,53 +2420,66 @@ bool cmFileCommand::HandleCMakePathCommand(std::vector<std::string>
   this->Makefile->AddDefinition(var, value.c_str());
   return true;
 }
+
+
 #if defined(CMAKE_BUILD_WITH_CMAKE)
 
-// Stuff for curl download
+// Stuff for curl download/upload
 typedef std::vector<char> cmFileCommandVectorOfChar;
-namespace{
+
+namespace {
+
   size_t
-  cmFileCommandWriteMemoryCallback(void *ptr, size_t size, size_t nmemb,
+  cmWriteToFileCallback(void *ptr, size_t size, size_t nmemb,
-                                          void *data)
+                        void *data)
-  { 
+    {
     register int realsize = (int)(size * nmemb);
     std::ofstream* fout = static_cast<std::ofstream*>(data);
     const char* chPtr = static_cast<char*>(ptr);
     fout->write(chPtr, realsize);
     return realsize;
-  }
+    }
+
+
+  size_t
+  cmWriteToMemoryCallback(void *ptr, size_t size, size_t nmemb,
+                          void *data)
+    {
+    register int realsize = (int)(size * nmemb);
+    cmFileCommandVectorOfChar *vec
+      = static_cast<cmFileCommandVectorOfChar*>(data);
+    const char* chPtr = static_cast<char*>(ptr);
+    vec->insert(vec->end(), chPtr, chPtr + realsize);
+    return realsize;
+    }
 
 
   static size_t
   cmFileCommandCurlDebugCallback(CURL *, curl_infotype, char *chPtr,
-                                        size_t size, void *data)
+                                 size_t size, void *data)
-  {
+    {
     cmFileCommandVectorOfChar *vec
       = static_cast<cmFileCommandVectorOfChar*>(data);
     vec->insert(vec->end(), chPtr, chPtr + size);
-
     return size;
-  }
+    }
 
 
   class cURLProgressHelper
   {
   public:
-    cURLProgressHelper(cmFileCommand *fc)
+    cURLProgressHelper(cmFileCommand *fc, const char *text)
       {
       this->CurrentPercentage = -1;
       this->FileCommand = fc;
+      this->Text = text;
       }
 
     bool UpdatePercentage(double value, double total, std::string &status)
       {
       int OldPercentage = this->CurrentPercentage;
 
-      if (0.0 == total)
+      if (total > 0.0)
-        {
-        this->CurrentPercentage = 100;
-        }
-      else
         {
         this->CurrentPercentage = static_cast<int>(value/total*100.0 + 0.5);
         }
@@ -2488,7 +2489,8 @@ namespace{
       if (updated)
         {
         cmOStringStream oss;
-        oss << "[download " << this->CurrentPercentage << "% complete]";
+        oss << "[" << this->Text << " " << this->CurrentPercentage
+            << "% complete]";
         status = oss.str();
         }
 
@@ -2503,14 +2505,15 @@ namespace{
   private:
     int CurrentPercentage;
     cmFileCommand *FileCommand;
+    std::string Text;
   };
 
 
   static int
-  cmFileCommandCurlProgressCallback(void *clientp,
+  cmFileDownloadProgressCallback(void *clientp,
-                                    double dltotal, double dlnow,
+                                 double dltotal, double dlnow,
-                                    double ultotal, double ulnow)
+                                 double ultotal, double ulnow)
-  {
+    {
     cURLProgressHelper *helper =
       reinterpret_cast<cURLProgressHelper *>(clientp);
 
@@ -2526,12 +2529,33 @@ namespace{
       }
 
     return 0;
-  }
+    }
+
+
+  static int
+  cmFileUploadProgressCallback(void *clientp,
+                               double dltotal, double dlnow,
+                               double ultotal, double ulnow)
+    {
+    cURLProgressHelper *helper =
+    reinterpret_cast<cURLProgressHelper *>(clientp);
+
+    static_cast<void>(dltotal);
+    static_cast<void>(dlnow);
+
+    std::string status;
+    if (helper->UpdatePercentage(ulnow, ultotal, status))
+      {
+      cmFileCommand *fc = helper->GetFileCommand();
+      cmMakefile *mf = fc->GetMakefile();
+      mf->DisplayStatus(status.c_str(), -1);
+      }
+
+    return 0;
+    }
 }
 
-#endif
 
-#if defined(CMAKE_BUILD_WITH_CMAKE)
 namespace {
 
   class cURLEasyGuard
@@ -2563,9 +2587,18 @@ namespace {
 #endif
 
 
+#define check_curl_result(result, errstr) \
+  if (result != CURLE_OK)                 \
+    {                                     \
+    std::string e(errstr);                \
+    e += ::curl_easy_strerror(result);    \
+    this->SetError(e.c_str());            \
+    return false;                         \
+    }
+
+
 bool
-cmFileCommand::HandleDownloadCommand(std::vector<std::string>
+cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args)
-                                     const& args)
 {
 #if defined(CMAKE_BUILD_WITH_CMAKE)
   std::vector<std::string>::const_iterator i = args.begin();
@@ -2658,10 +2691,6 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string>
 
     if (expectedMD5sum == actualMD5sum)
       {
-      this->Makefile->DisplayStatus(
-        "FILE(DOWNLOAD) returning early: file already exists with "
-        "expected MD5 sum", -1);
-
       if(statusVar.size())
         {
         cmOStringStream result;
@@ -2708,88 +2737,37 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string>
   cURLEasyGuard g_curl(curl);
 
   ::CURLcode res = ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
-  if (res != CURLE_OK)
+  check_curl_result(res, "DOWNLOAD cannot set url: ");
-    {
-    std::string e = "DOWNLOAD cannot set url: ";
-    e += ::curl_easy_strerror(res);
-    this->SetError(e.c_str());
-    return false;
-    }
 
   res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
-                           cmFileCommandWriteMemoryCallback);
+                           cmWriteToFileCallback);
-  if (res != CURLE_OK)
+  check_curl_result(res, "DOWNLOAD cannot set write function: ");
-    {
-    std::string e = "DOWNLOAD cannot set write function: ";
-    e += ::curl_easy_strerror(res);
-    this->SetError(e.c_str());
-    return false;
-    }
 
   res = ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
                            cmFileCommandCurlDebugCallback);
-  if (res != CURLE_OK)
+  check_curl_result(res, "DOWNLOAD cannot set debug function: ");
-    {
-    std::string e = "DOWNLOAD cannot set debug function: ";
-    e += ::curl_easy_strerror(res);
-    this->SetError(e.c_str());
-    return false;
-    }
 
   cmFileCommandVectorOfChar chunkDebug;
 
   res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&fout);
-
+  check_curl_result(res, "DOWNLOAD cannot set write data: ");
-  if (res != CURLE_OK)
-    {
-    std::string e = "DOWNLOAD cannot set write data: ";
-    e += ::curl_easy_strerror(res);
-    this->SetError(e.c_str());
-    return false;
-    }
 
   res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
-  if (res != CURLE_OK)
+  check_curl_result(res, "DOWNLOAD cannot set debug data: ");
-    {
-    std::string e = "DOWNLOAD cannot set debug data: ";
-    e += ::curl_easy_strerror(res);
-    this->SetError(e.c_str());
-    return false;
-    }
 
   res = ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
-  if (res != CURLE_OK)
+  check_curl_result(res, "DOWNLOAD cannot set follow-redirect option: ");
-    {
-    std::string e = "DOWNLOAD cannot set follow-redirect option: ";
-    e += ::curl_easy_strerror(res);
-    this->SetError(e.c_str());
-    return false;
-    }
 
   if(verboseLog.size())
     {
     res = ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
-
+    check_curl_result(res, "DOWNLOAD cannot set verbose: ");
-    if (res != CURLE_OK)
-      {
-      std::string e = "DOWNLOAD cannot set verbose: ";
-      e += ::curl_easy_strerror(res);
-      this->SetError(e.c_str());
-      return false;
-      }
     }
 
   if(timeout > 0)
     {
     res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout );
-
+    check_curl_result(res, "DOWNLOAD cannot set timeout: ");
-    if (res != CURLE_OK)
-      {
-      std::string e = "DOWNLOAD cannot set timeout: ";
-      e += ::curl_easy_strerror(res);
-      this->SetError(e.c_str());
-      return false;
-      }
     }
 
   // Need the progress helper's scope to last through the duration of
@@ -2797,39 +2775,20 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string>
   // scope intentionally, rather than inside the "if(showProgress)"
   // block...
   //
-  cURLProgressHelper helper(this);
+  cURLProgressHelper helper(this, "download");
 
   if(showProgress)
     {
-    res = ::curl_easy_setopt(curl,
+    res = ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
-      CURLOPT_NOPROGRESS, 0);
+    check_curl_result(res, "DOWNLOAD cannot set noprogress value: ");
-    if (res != CURLE_OK)
-      {
-      std::string e = "DOWNLOAD cannot set noprogress value: ";
-      e += ::curl_easy_strerror(res);
-      this->SetError(e.c_str());
-      return false;
-      }
 
     res = ::curl_easy_setopt(curl,
-      CURLOPT_PROGRESSFUNCTION, cmFileCommandCurlProgressCallback);
+      CURLOPT_PROGRESSFUNCTION, cmFileDownloadProgressCallback);
-    if (res != CURLE_OK)
+    check_curl_result(res, "DOWNLOAD cannot set progress function: ");
-      {
-      std::string e = "DOWNLOAD cannot set progress function: ";
-      e += ::curl_easy_strerror(res);
-      this->SetError(e.c_str());
-      return false;
-      }
 
     res = ::curl_easy_setopt(curl,
       CURLOPT_PROGRESSDATA, reinterpret_cast<void*>(&helper));
-    if (res != CURLE_OK)
+    check_curl_result(res, "DOWNLOAD cannot set progress data: ");
-      {
-      std::string e = "DOWNLOAD cannot set progress data: ";
-      e += ::curl_easy_strerror(res);
-      this->SetError(e.c_str());
-      return false;
-      }
     }
 
   res = ::curl_easy_perform(curl);
@@ -2905,3 +2864,220 @@ cmFileCommand::HandleDownloadCommand(std::vector<std::string>
   return false;
 #endif
 }
+
+
+bool
+cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args)
+{
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+  if(args.size() < 3)
+    {
+    this->SetError("UPLOAD must be called with at least three arguments.");
+    return false;
+    }
+  std::vector<std::string>::const_iterator i = args.begin();
+  ++i;
+  std::string filename = *i;
+  ++i;
+  std::string url = *i;
+  ++i;
+
+  long timeout = 0;
+  std::string logVar;
+  std::string statusVar;
+  bool showProgress = false;
+
+  while(i != args.end())
+    {
+    if(*i == "TIMEOUT")
+      {
+      ++i;
+      if(i != args.end())
+        {
+        timeout = atol(i->c_str());
+        }
+      else
+        {
+        this->SetError("UPLOAD missing time for TIMEOUT.");
+        return false;
+        }
+      }
+    else if(*i == "LOG")
+      {
+      ++i;
+      if( i == args.end())
+        {
+        this->SetError("UPLOAD missing VAR for LOG.");
+        return false;
+        }
+      logVar = *i;
+      }
+    else if(*i == "STATUS")
+      {
+      ++i;
+      if( i == args.end())
+        {
+        this->SetError("UPLOAD missing VAR for STATUS.");
+        return false;
+        }
+      statusVar = *i;
+      }
+    else if(*i == "SHOW_PROGRESS")
+      {
+      showProgress = true;
+      }
+
+    ++i;
+    }
+
+  // Open file for reading:
+  //
+  FILE *fin = fopen(filename.c_str(), "rb");
+  if(!fin)
+    {
+    std::string errStr = "UPLOAD cannot open file '";
+    errStr += filename + "' for reading.";
+    this->SetError(errStr.c_str());
+    return false;
+    }
+
+  struct stat st;
+  if(::stat(filename.c_str(), &st))
+    {
+    std::string errStr = "UPLOAD cannot stat file '";
+    errStr += filename + "'.";
+    this->SetError(errStr.c_str());
+    return false;
+    }
+
+  ::CURL *curl;
+  ::curl_global_init(CURL_GLOBAL_DEFAULT);
+  curl = ::curl_easy_init();
+  if(!curl)
+    {
+    this->SetError("UPLOAD error initializing curl.");
+    return false;
+    }
+
+  cURLEasyGuard g_curl(curl);
+
+  // enable HTTP ERROR parsing
+  ::CURLcode res = ::curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
+
+  // enable uploading
+  res = ::curl_easy_setopt(curl, CURLOPT_UPLOAD, 1);
+  check_curl_result(res, "UPLOAD cannot set upload flag: ");
+
+  res = ::curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+  check_curl_result(res, "UPLOAD cannot set url: ");
+
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION,
+                           cmWriteToMemoryCallback);
+  check_curl_result(res, "UPLOAD cannot set write function: ");
+
+  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGFUNCTION,
+                           cmFileCommandCurlDebugCallback);
+  check_curl_result(res, "UPLOAD cannot set debug function: ");
+
+  cmFileCommandVectorOfChar chunkResponse;
+  cmFileCommandVectorOfChar chunkDebug;
+
+  res = ::curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *)&chunkResponse);
+  check_curl_result(res, "UPLOAD cannot set write data: ");
+
+  res = ::curl_easy_setopt(curl, CURLOPT_DEBUGDATA, (void *)&chunkDebug);
+  check_curl_result(res, "UPLOAD cannot set debug data: ");
+
+  res = ::curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 1L);
+  check_curl_result(res, "UPLOAD cannot set follow-redirect option: ");
+
+  if(logVar.size())
+    {
+    res = ::curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
+    check_curl_result(res, "UPLOAD cannot set verbose: ");
+    }
+
+  if(timeout > 0)
+    {
+    res = ::curl_easy_setopt(curl, CURLOPT_TIMEOUT, timeout );
+    check_curl_result(res, "UPLOAD cannot set timeout: ");
+    }
+
+  // Need the progress helper's scope to last through the duration of
+  // the curl_easy_perform call... so this object is declared at function
+  // scope intentionally, rather than inside the "if(showProgress)"
+  // block...
+  //
+  cURLProgressHelper helper(this, "upload");
+
+  if(showProgress)
+    {
+    res = ::curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
+    check_curl_result(res, "UPLOAD cannot set noprogress value: ");
+
+    res = ::curl_easy_setopt(curl,
+      CURLOPT_PROGRESSFUNCTION, cmFileUploadProgressCallback);
+    check_curl_result(res, "UPLOAD cannot set progress function: ");
+
+    res = ::curl_easy_setopt(curl,
+      CURLOPT_PROGRESSDATA, reinterpret_cast<void*>(&helper));
+    check_curl_result(res, "UPLOAD cannot set progress data: ");
+    }
+
+  // now specify which file to upload
+  res = ::curl_easy_setopt(curl, CURLOPT_INFILE, fin);
+  check_curl_result(res, "UPLOAD cannot set input file: ");
+
+  // and give the size of the upload (optional)
+  res = ::curl_easy_setopt(curl,
+    CURLOPT_INFILESIZE, static_cast<long>(st.st_size));
+  check_curl_result(res, "UPLOAD cannot set input file size: ");
+
+  res = ::curl_easy_perform(curl);
+
+  /* always cleanup */
+  g_curl.release();
+  ::curl_easy_cleanup(curl);
+
+  if(statusVar.size())
+    {
+    cmOStringStream result;
+    result << (int)res << ";\"" << ::curl_easy_strerror(res) << "\"";
+    this->Makefile->AddDefinition(statusVar.c_str(),
+                                  result.str().c_str());
+    }
+
+  ::curl_global_cleanup();
+
+  fclose(fin);
+  fin = NULL;
+
+  if(logVar.size())
+    {
+    std::string log;
+
+    if(chunkResponse.size())
+      {
+      chunkResponse.push_back(0);
+      log += "Response:\n";
+      log += &*chunkResponse.begin();
+      log += "\n";
+      }
+
+    if(chunkDebug.size())
+      {
+      chunkDebug.push_back(0);
+      log += "Debug:\n";
+      log += &*chunkDebug.begin();
+      log += "\n";
+      }
+
+    this->Makefile->AddDefinition(logVar.c_str(), log.c_str());
+    }
+
+  return true;
+#else
+  this->SetError("UPLOAD not supported by bootstrap cmake.");
+  return false;
+#endif
+}

Source/cmFileCommand.h

@@ -82,6 +82,8 @@ public:
       "  file(TO_NATIVE_PATH path result)\n"
       "  file(DOWNLOAD url file [TIMEOUT timeout] [STATUS status] [LOG log]\n"
       "       [EXPECTED_MD5 sum] [SHOW_PROGRESS])\n"
+      "  file(UPLOAD filename url [TIMEOUT timeout] [STATUS status]\n"
+      "       [LOG log] [SHOW_PROGRESS])\n"
       "WRITE will write a message into a file called 'filename'. It "
       "overwrites the file if it already exists, and creates the file "
       "if it does not exist.\n"
@@ -165,6 +167,18 @@ public:
       "If SHOW_PROGRESS is specified, progress information will be printed "
       "as status messages until the operation is complete."
       "\n"
+      "UPLOAD will upload the given file to the given URL. "
+      "If LOG var is specified a log of the upload will be put in var. "
+      "If STATUS var is specified the status of the operation will"
+      " be put in var. The status is returned in a list of length 2. "
+      "The first element is the numeric return value for the operation, "
+      "and the second element is a string value for the error. A 0 "
+      "numeric error means no error in the operation. "
+      "If TIMEOUT time is specified, the operation will "
+      "timeout after time seconds, time should be specified as an integer. "
+      "If SHOW_PROGRESS is specified, progress information will be printed "
+      "as status messages until the operation is complete."
+      "\n"
       "The file() command also provides COPY and INSTALL signatures:\n"
       "  file(<COPY|INSTALL> files... DESTINATION <dir>\n"
       "       [FILE_PERMISSIONS permissions...]\n"
@@ -223,6 +237,7 @@ protected:
   bool HandleCopyCommand(std::vector<std::string> const& args);
   bool HandleInstallCommand(std::vector<std::string> const& args);
   bool HandleDownloadCommand(std::vector<std::string> const& args);
+  bool HandleUploadCommand(std::vector<std::string> const& args);
 };
 
 

Source/cmGetCMakePropertyCommand.cxx

@@ -22,21 +22,22 @@ bool cmGetCMakePropertyCommand
     this->SetError("called with incorrect number of arguments");
     return false;
     }
-  
+
   std::vector<std::string>::size_type cc;
   std::string variable = args[0];
   std::string output = "NOTFOUND";
 
-  if ( args[1] == "VARIABLES")
+  if ( args[1] == "VARIABLES" )
     {
     int cacheonly = 0;
     std::vector<std::string> vars = this->Makefile->GetDefinitions(cacheonly);
-    for ( cc = 0; cc < vars.size(); cc ++ )
+    if (vars.size()>0)
       {
-      if ( cc > 0 )
+      output = vars[0];
-        {
+      }
-        output += ";";
+    for ( cc = 1; cc < vars.size(); ++cc )
-        }
+      {
+      output += ";";
       output += vars[cc];
       }
     }
@@ -62,15 +63,15 @@ bool cmGetCMakePropertyCommand
     }
   else
     {
-    const char *prop = 
+    const char *prop =
       this->Makefile->GetCMakeInstance()->GetProperty(args[1].c_str());
     if (prop)
       {
       output = prop;
       }
     }
+
   this->Makefile->AddDefinition(variable.c_str(), output.c_str());
-  
+
   return true;
 }
-

Source/cmGlobalVisualStudio8Generator.cxx

@@ -358,6 +358,15 @@ static cmVS7FlagTable cmVS8ExtraFlagTable[] =
   {"ExceptionHandling", "EHsc", "enable c++ exceptions", "1", 0},
   {"ExceptionHandling", "EHa", "enable SEH exceptions", "2", 0},
 
+  {"EnablePREfast", "analyze", "", "true", 0},
+  {"EnablePREfast", "analyze-", "", "false", 0},
+
+  // Language options
+  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t",
+   "wchar_t is a built-in type", "true", 0},
+  {"TreatWChar_tAsBuiltInType", "Zc:wchar_t-",
+   "wchar_t is not a built-in type", "false", 0},
+
   {0,0,0,0,0}
 };
 cmIDEFlagTable const* cmGlobalVisualStudio8Generator::GetExtraFlagTableVS8()

Source/cmGlobalXCodeGenerator.cxx

@@ -165,13 +165,16 @@ void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
     }
   else
     {
-    mf->AddCacheDefinition(
+    if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
-      "CMAKE_CONFIGURATION_TYPES",
+      {
-      "Debug;Release;MinSizeRel;RelWithDebInfo",
+      mf->AddCacheDefinition(
-      "Semicolon separated list of supported configuration types, "
+        "CMAKE_CONFIGURATION_TYPES",
-      "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
+        "Debug;Release;MinSizeRel;RelWithDebInfo",
-      "anything else will be ignored.",
+        "Semicolon separated list of supported configuration types, "
-      cmCacheManager::STRING);
+        "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
+        "anything else will be ignored.",
+        cmCacheManager::STRING);
+      }
     }
   mf->AddDefinition("CMAKE_GENERATOR_CC", "gcc");
   mf->AddDefinition("CMAKE_GENERATOR_CXX", "g++");
@@ -578,6 +581,12 @@ cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
       }
     }
 
+  if(cmtarget.IsCFBundleOnApple())
+    {
+    cmtarget.SetProperty("PREFIX", "");
+    cmtarget.SetProperty("SUFFIX", "");
+    }
+
   // Add the fileRef to the top level Resources group/folder if it is not
   // already there.
   //
@@ -812,6 +821,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
     // some build phases only apply to bundles and/or frameworks
     bool isFrameworkTarget = cmtarget.IsFrameworkOnApple();
     bool isBundleTarget = cmtarget.GetPropertyAsBool("MACOSX_BUNDLE");
+    bool isCFBundleTarget = cmtarget.IsCFBundleOnApple();
 
     cmXCodeObject* buildFiles = 0;
 
@@ -857,7 +867,8 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
 
     // create resource build phase - only for framework or bundle targets
     cmXCodeObject* resourceBuildPhase = 0;
-    if (!resourceFiles.empty() && (isFrameworkTarget || isBundleTarget))
+    if (!resourceFiles.empty() &&
+        (isFrameworkTarget || isBundleTarget || isCFBundleTarget))
       {
       resourceBuildPhase =
         this->CreateObject(cmXCodeObject::PBXResourcesBuildPhase);
@@ -878,7 +889,7 @@ cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
     // create vector of "non-resource content file" build phases - only for
     // framework or bundle targets
     std::vector<cmXCodeObject*> contentBuildPhases;
-    if (isFrameworkTarget || isBundleTarget)
+    if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
       {
       typedef std::map<cmStdString, std::vector<cmSourceFile*> >
         mapOfVectorOfSourceFiles;
@@ -1605,7 +1616,33 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
     {
     buildSettings->AddAttribute("LIBRARY_STYLE",
                                 this->CreateString("BUNDLE"));
-    if(this->XcodeVersion >= 22)
+    if (target.GetPropertyAsBool("BUNDLE"))
+      {
+      // It turns out that a BUNDLE is basically the same
+      // in many ways as an application bundle, as far as
+      // link flags go
+      std::string createFlags =
+        this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", lang, "_FLAGS",
+                          "-bundle");
+      if(!createFlags.empty())
+        {
+        extraLinkOptions += " ";
+        extraLinkOptions += createFlags;
+        }
+      std::string plist = this->ComputeInfoPListLocation(target);
+      // Xcode will create the final version of Info.plist at build time,
+      // so let it replace the cfbundle name. This avoids creating
+      // a per-configuration Info.plist file. The cfbundle plist
+      // is very similar to the application bundle plist
+      this->CurrentLocalGenerator
+        ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
+                                 plist.c_str());
+      std::string path =
+        this->ConvertToRelativeForXCode(plist.c_str());
+      buildSettings->AddAttribute("INFOPLIST_FILE",
+                                  this->CreateString(path.c_str()));
+      }
+    else if(this->XcodeVersion >= 22)
       {
       buildSettings->AddAttribute("MACH_O_TYPE",
                                   this->CreateString("mh_bundle"));
@@ -1644,7 +1681,7 @@ void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
 
       std::string plist = this->ComputeInfoPListLocation(target);
       // Xcode will create the final version of Info.plist at build time,
-      // so let it replace the framework name.  This avoids creating
+      // so let it replace the framework name. This avoids creating
       // a per-configuration Info.plist file.
       this->CurrentLocalGenerator
         ->GenerateFrameworkInfoPList(&target, "$(EXECUTABLE_NAME)",
@@ -2043,7 +2080,10 @@ const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget)
     case cmTarget::STATIC_LIBRARY:
       return "archive.ar";
     case cmTarget::MODULE_LIBRARY:
-      return ((this->XcodeVersion >= 22)?
+      if (cmtarget.IsCFBundleOnApple())
+        return "wrapper.plug-in";
+      else
+        return ((this->XcodeVersion >= 22)?
               "compiled.mach-o.executable" : "compiled.mach-o.dylib");
     case cmTarget::SHARED_LIBRARY:
       return (cmtarget.GetPropertyAsBool("FRAMEWORK")?
@@ -2063,8 +2103,12 @@ const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget)
     case cmTarget::STATIC_LIBRARY:
       return "com.apple.product-type.library.static";
     case cmTarget::MODULE_LIBRARY:
-      return ((this->XcodeVersion >= 22)? "com.apple.product-type.tool" :
+      if (cmtarget.IsCFBundleOnApple())
-              "com.apple.product-type.library.dynamic");
+        return "com.apple.product-type.bundle";
+      else
+        return ((this->XcodeVersion >= 22)?
+                "com.apple.product-type.tool" :
+                "com.apple.product-type.library.dynamic");
     case cmTarget::SHARED_LIBRARY:
       return (cmtarget.GetPropertyAsBool("FRAMEWORK")?
               "com.apple.product-type.framework" :

Source/cmGraphVizWriter.cxx

@@ -272,6 +272,12 @@ void cmGraphVizWriter::WriteConnections(const char* targetName,
     std::map<cmStdString, cmStdString>::const_iterator libNameIt =
                                           this->TargetNamesNodes.find(libName);
 
+    // can happen e.g. if GRAPHVIZ_TARGET_IGNORE_REGEX is used
+    if(libNameIt == this->TargetNamesNodes.end())
+      {
+      continue;
+      }
+
     std::string connectionName = myNodeName;
     connectionName += "-";
     connectionName += libNameIt->second;

Source/cmIDEOptions.cxx

@@ -171,3 +171,9 @@ void cmIDEOptions::AddFlag(const char* flag, const char* value)
 {
   this->FlagMap[flag] = value;
 }
+
+//----------------------------------------------------------------------------
+void cmIDEOptions::RemoveFlag(const char* flag)
+{
+  this->FlagMap.erase(flag);
+}

Source/cmIDEOptions.h

@@ -28,6 +28,7 @@ public:
   void AddDefine(const std::string& define);
   void AddDefines(const char* defines);
   void AddFlag(const char* flag, const char* value);
+  void RemoveFlag(const char* flag);
 
 protected:
   // create a map of xml tags to the values they should have in the output

Source/cmListCommand.h

@@ -83,6 +83,14 @@ public:
       "REMOVE_DUPLICATES will remove duplicated items in the list.\n"
       "REVERSE reverses the contents of the list in-place.\n"
       "SORT sorts the list in-place alphabetically.\n"
+      "The list subcommands APPEND, INSERT, REMOVE_AT, REMOVE_ITEM, "
+      "REMOVE_DUPLICATES, REVERSE and SORT may create new values for "
+      "the list within the current CMake variable scope. Similar to "
+      "the SET command, the LIST command creates new variable values "
+      "in the current scope, even if the list itself is actually "
+      "defined in a parent scope. To propagate the results of these "
+      "operations upwards, use SET with PARENT_SCOPE, SET with CACHE "
+      "INTERNAL, or some other means of value propagation.\n"
       "NOTES: A list in cmake is a ; separated group of strings. "
       "To create a list the set command can be used. For example, "
       "set(var a b c d e)  creates a list with a;b;c;d;e, and "

Source/cmLocalGenerator.cxx

@@ -1893,6 +1893,7 @@ bool cmLocalGenerator::GetRealDependency(const char* inName,
     {
     // This is a full path.  Return it as given.
     dep = inName;
+    cmSystemTools::ConvertToUnixSlashes(dep);
     return true;
     }
 

Source/cmLocalVisualStudio6Generator.cxx

@@ -863,7 +863,7 @@ cmLocalVisualStudio6Generator::CreateTargetRules(cmTarget &target,
   event.Write(target.GetPreBuildCommands());
   event.Write(target.GetPreLinkCommands());
   cmsys::auto_ptr<cmCustomCommand> pcc(
-    this->MaybeCreateImplibDir(target, configName));
+    this->MaybeCreateImplibDir(target, configName, false));
   if(pcc.get())
     {
     event.Write(*pcc);

Source/cmLocalVisualStudio7Generator.cxx

@@ -381,6 +381,11 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[] =
    "Use sse2 instructions", "2", 0},
   {"EnableEnhancedInstructionSet", "arch:SSE",
    "Use sse instructions",   "1", 0},
+  {"FloatingPointModel", "fp:precise",
+   "Use precise floating point model", "0", 0},
+  {"FloatingPointModel", "fp:strict",
+   "Use strict floating point model", "1", 0},
+  {"FloatingPointModel", "fp:fast", "Use fast floating point model", "2", 0},
   {"FavorSizeOrSpeed",  "Ot", "Favor fast code",  "1", 0},
   {"FavorSizeOrSpeed",  "Os", "Favor small code", "2", 0},
   {"CompileAs", "TC", "Compile as c code",        "1", 0},
@@ -451,8 +456,13 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorFlagTable[] =
    "Turn off Run time type information for c++", "FALSE", 0},
   {"SmallerTypeCheck", "RTCc", "smaller type check", "TRUE", 0},
   {"SuppressStartupBanner", "nologo", "SuppressStartupBanner", "TRUE", 0},
+  {"WholeProgramOptimization", "GL",
+   "Enables whole program optimization", "TRUE", 0},
+  {"WholeProgramOptimization", "GL-",
+   "Disables whole program optimization", "FALSE", 0},
   {"WarnAsError", "WX", "Treat warnings as errors", "TRUE", 0},
   {"BrowseInformation", "FR", "Generate browse information", "1", 0},
+  {"StringPooling", "GF", "Enable StringPooling", "TRUE", 0},
   {0,0,0,0,0}
 };
 
@@ -466,6 +476,14 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] =
   {"GenerateManifest", "MANIFEST", "enable manifest generation", "TRUE", 0},
   {"LinkIncremental", "INCREMENTAL:NO", "link incremental", "1", 0},
   {"LinkIncremental", "INCREMENTAL:YES", "link incremental", "2", 0},
+  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK:NO", "", "false", 0},
+  {"CLRUnmanagedCodeCheck", "CLRUNMANAGEDCODECHECK", "", "true", 0},
+  {"DataExecutionPrevention", "NXCOMPAT:NO",
+   "Not known to work with Windows Data Execution Prevention", "1", 0},
+  {"DataExecutionPrevention", "NXCOMPAT",
+   "Known to work with Windows Data Execution Prevention", "2", 0},
+  {"DelaySign", "DELAYSIGN:NO", "", "false", 0},
+  {"DelaySign", "DELAYSIGN", "", "true", 0},
   {"EntryPointSymbol", "ENTRY:", "sets the starting address", "",
    cmVS7FlagTable::UserValue},
   {"IgnoreDefaultLibraryNames", "NODEFAULTLIB:", "default libs to ignore", "",
@@ -478,8 +496,16 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] =
   {"EnableCOMDATFolding", "OPT:NOICF", "Do not remove redundant COMDATs",
    "1", 0},
   {"EnableCOMDATFolding", "OPT:ICF", "Remove redundant COMDATs", "2", 0},
+  {"ResourceOnlyDLL", "NOENTRY", "Create DLL with no entry point", "true", 0},
   {"OptimizeReferences", "OPT:NOREF", "Keep unreferenced data", "1", 0},
   {"OptimizeReferences", "OPT:REF", "Eliminate unreferenced data", "2", 0},
+  {"Profile", "PROFILE", "", "true", 0},
+  {"RandomizedBaseAddress", "DYNAMICBASE:NO",
+   "Image may not be rebased at load-time", "1", 0},
+  {"RandomizedBaseAddress", "DYNAMICBASE",
+   "Image may be rebased at load-time", "2", 0},
+  {"SetChecksum", "RELEASE", "Enable setting checksum in header", "true", 0},
+  {"SupportUnloadOfDelayLoadedDLL", "DELAY:UNLOAD", "", "true", 0},
   {"TargetMachine", "MACHINE:I386", "Machine x86", "1", 0},
   {"TargetMachine", "MACHINE:X86", "Machine x86", "1", 0},
   {"TargetMachine", "MACHINE:AM33", "Machine AM33", "2", 0},
@@ -498,6 +524,8 @@ cmVS7FlagTable cmLocalVisualStudio7GeneratorLinkFlagTable[] =
   {"TargetMachine", "MACHINE:SH5", "Machine SH5", "15", 0},
   {"TargetMachine", "MACHINE:THUMB", "Machine THUMB", "16", 0},
   {"TargetMachine", "MACHINE:X64", "Machine x64", "17", 0},
+  {"TurnOffAssemblyGeneration", "NOASSEMBLY",
+   "No assembly even if CLR information is present in objects.", "true", 0},
   {"ModuleDefinitionFile", "DEF:", "add an export def file", "",
    cmVS7FlagTable::UserValue}, 
   {"GenerateMapFile", "MAP", "enable generation of map file", "TRUE", 0},
@@ -1695,7 +1723,7 @@ void cmLocalVisualStudio7Generator
   event.Start(tool);
   event.Write(target.GetPreLinkCommands());
   cmsys::auto_ptr<cmCustomCommand> pcc(
-    this->MaybeCreateImplibDir(target, configName));
+    this->MaybeCreateImplibDir(target, configName, this->FortranProject));
   if(pcc.get())
     {
     event.Write(*pcc);

Source/cmLocalVisualStudioGenerator.cxx

@@ -32,13 +32,17 @@ cmLocalVisualStudioGenerator::~cmLocalVisualStudioGenerator()
 //----------------------------------------------------------------------------
 cmsys::auto_ptr<cmCustomCommand>
 cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmTarget& target,
-                                                   const char* config)
+                                                   const char* config,
+                                                   bool isFortran)
 {
   cmsys::auto_ptr<cmCustomCommand> pcc;
 
   // If an executable exports symbols then VS wants to create an
   // import library but forgets to create the output directory.
-  if(target.GetType() != cmTarget::EXECUTABLE) { return pcc; }
+  // The Intel Fortran plugin always forgets to the directory.
+  if(target.GetType() != cmTarget::EXECUTABLE &&
+     !(isFortran && target.GetType() == cmTarget::SHARED_LIBRARY))
+    { return pcc; }
   std::string outDir = target.GetDirectory(config, false);
   std::string impDir = target.GetDirectory(config, true);
   if(impDir == outDir) { return pcc; }

Source/cmLocalVisualStudioGenerator.h

@@ -47,7 +47,7 @@ protected:
 
   /** Construct a custom command to make exe import lib dir.  */
   cmsys::auto_ptr<cmCustomCommand>
-  MaybeCreateImplibDir(cmTarget& target, const char* config);
+  MaybeCreateImplibDir(cmTarget& target, const char* config, bool isFortran);
 
   // Safe object file name generation.
   void ComputeObjectNameRequirements(std::vector<cmSourceGroup> const&);

Source/cmMakefile.cxx

@@ -2744,6 +2744,27 @@ void cmMakefile::SetHomeOutputDirectory(const char* lib)
     }
 }
 
+void cmMakefile::SetScriptModeFile(const char* scriptfile)
+{
+  this->AddDefinition("CMAKE_SCRIPT_MODE_FILE", scriptfile);
+}
+
+void cmMakefile::SetArgcArgv(const std::vector<std::string>& args)
+{
+  cmOStringStream strStream;
+  strStream << args.size();
+  this->AddDefinition("CMAKE_ARGC", strStream.str().c_str());
+  //this->MarkVariableAsUsed("CMAKE_ARGC");
+
+  for (unsigned int t = 0; t < args.size(); ++t)
+  {
+    cmOStringStream tmpStream;
+    tmpStream << "CMAKE_ARGV" << t;
+    this->AddDefinition(tmpStream.str().c_str(), args[t].c_str());
+    //this->MarkVariableAsUsed(tmpStream.str().c_str());
+  }
+}
+
 //----------------------------------------------------------------------------
 cmSourceFile* cmMakefile::GetSource(const char* sourceName)
 {

Source/cmMakefile.h

@@ -411,7 +411,17 @@ public:
       return this->HomeOutputDirectory.c_str();
     }
   //@}
-  
+
+  /**
+   * Set CMAKE_SCRIPT_MODE_FILE variable when running a -P script.
+   */
+  void SetScriptModeFile(const char* scriptfile);
+
+  /**
+   * Set CMAKE_ARGC, CMAKE_ARGV0 ... variables.
+   */
+  void SetArgcArgv(const std::vector<std::string>& args);
+
   //@{
   /**
    * Set/Get the start directory (or output directory). The start directory

Source/cmMakefileLibraryTargetGenerator.cxx

@@ -26,6 +26,12 @@ cmMakefileLibraryTargetGenerator
 ::cmMakefileLibraryTargetGenerator(cmTarget* target):
   cmMakefileTargetGenerator(target)
 {
+  if(this->Target->IsCFBundleOnApple())
+    {
+    target->SetProperty("PREFIX", "");
+    target->SetProperty("SUFFIX", "");
+    }
+
   this->CustomCommandDriver = OnDepends;
   this->Target->GetLibraryNames(
     this->TargetNameOut, this->TargetNameSO, this->TargetNameReal,
@@ -41,6 +47,20 @@ cmMakefileLibraryTargetGenerator
     this->MacContentDirectory += this->FrameworkVersion;
     this->MacContentDirectory += "/";
     }
+  else if(this->Target->IsCFBundleOnApple())
+    {
+    this->MacContentDirectory = this->Target->GetDirectory(this->ConfigName);
+    this->MacContentDirectory += "/";
+    this->MacContentDirectory += this->TargetNameOut;
+    this->MacContentDirectory += ".";
+    const char *ext = this->Target->GetProperty("BUNDLE_EXTENSION");
+    if (!ext)
+      {
+      ext = "bundle";
+      }
+    this->MacContentDirectory += ext;
+    this->MacContentDirectory += "/Contents/";
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -300,6 +320,27 @@ cmMakefileLibraryTargetGenerator
     }
 }
 
+//----------------------------------------------------------------------------
+void
+cmMakefileLibraryTargetGenerator::CreateCFBundle(std::string& targetName,
+                                                 std::string& outpath)
+{
+  // Compute bundle directory names.
+  outpath = this->MacContentDirectory;
+  outpath += "MacOS";
+  cmSystemTools::MakeDirectory(outpath.c_str());
+  this->Makefile->AddCMakeOutputFile(outpath.c_str());
+  outpath += "/";
+
+  // Configure the Info.plist file.  Note that it needs the executable name
+  // to be set.
+  std::string plist = this->MacContentDirectory + "Info.plist";
+  this->LocalGenerator->GenerateAppleInfoPList(this->Target,
+                                               targetName.c_str(),
+                                               plist.c_str());
+  this->Makefile->AddCMakeOutputFile(plist.c_str());
+}
+
 //----------------------------------------------------------------------------
 void cmMakefileLibraryTargetGenerator::WriteLibraryRules
 (const char* linkRuleVar, const char* extraFlags, bool relink)
@@ -354,6 +395,12 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
     outpath = this->MacContentDirectory;
     this->CreateFramework(targetName);
     }
+  else if(this->Target->IsCFBundleOnApple())
+    {
+    outpath = this->Target->GetDirectory(this->ConfigName);
+    outpath += "/";
+    this->CreateCFBundle(targetName, outpath);
+    }
   else if(relink)
     {
     outpath = this->Makefile->GetStartOutputDirectory();
@@ -417,6 +464,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules
         buildEcho += " shared library ";
         break;
       case cmTarget::MODULE_LIBRARY:
+        if (this->Target->IsCFBundleOnApple())
+            buildEcho += " CFBundle";
         buildEcho += " shared module ";
         break;
       default:

Source/cmMakefileLibraryTargetGenerator.h

@@ -33,6 +33,7 @@ protected:
   // MacOSX Framework support methods
   void WriteFrameworkRules(bool relink);
   void CreateFramework(std::string const& targetName);
+  void CreateCFBundle(std::string& targetName, std::string& outpath);
 
   // Store the computd framework version for OS X Frameworks.
   std::string FrameworkVersion;

Source/cmPolicies.cxx

@@ -453,7 +453,7 @@ cmPolicies::cmPolicies()
     "Starting with CMake 2.8.4, if a cmake-module shipped with CMake (i.e. "
     "located in the CMake module directory) calls include() or "
     "find_package(), the files located in the the CMake module directory are "
-    "prefered over the files in CMAKE_MODULE_PATH.  "
+    "preferred over the files in CMAKE_MODULE_PATH.  "
     "This makes sure that the modules belonging to "
     "CMake always get those files included which they expect, and against "
     "which they were developed and tested.  "

Source/cmSourceFile.cxx

@@ -482,17 +482,21 @@ void cmSourceFile::DefineProperties(cmake *cm)
 
   cm->DefineProperty
     ("MACOSX_PACKAGE_LOCATION", cmProperty::SOURCE_FILE, 
-     "Place a source file inside a Mac OS X bundle or framework.",
+     "Place a source file inside a Mac OS X bundle, CFBundle, or framework.",
      "Executable targets with the MACOSX_BUNDLE property set are built "
      "as Mac OS X application bundles on Apple platforms.  "
      "Shared library targets with the FRAMEWORK property set are built "
      "as Mac OS X frameworks on Apple platforms.  "
+     "Module library targets with the BUNDLE property set are built "
+     "as Mac OS X CFBundle bundles on Apple platforms.  "
      "Source files listed in the target with this property set will "
      "be copied to a directory inside the bundle or framework content "
      "folder specified by the property value.  "
      "For bundles the content folder is \"<name>.app/Contents\".  "
      "For frameworks the content folder is "
      "\"<name>.framework/Versions/<version>\".  "
+     "For cfbundles the content folder is "
+     "\"<name>.bundle/Contents\" (unless the extension is changed).  "
      "See the PUBLIC_HEADER, PRIVATE_HEADER, and RESOURCE target "
      "properties for specifying files meant for Headers, PrivateHeaders, "
      "or Resources directories.");

Source/cmStringCommand.cxx

@@ -72,7 +72,11 @@ bool cmStringCommand
     {
     return this->HandleRandomCommand(args);
     }
-  
+  else if(subCommand == "FIND")
+    {
+    return this->HandleFindCommand(args);
+    }
+
   std::string e = "does not recognize sub-command "+subCommand;
   this->SetError(e.c_str());
   return false;
@@ -498,6 +502,68 @@ void cmStringCommand::StoreMatches(cmMakefile* mf,cmsys::RegularExpression& re)
     }
 }
 
+//----------------------------------------------------------------------------
+bool cmStringCommand::HandleFindCommand(std::vector<std::string> const&
+                                           args)
+{
+  // check if all required parameters were passed
+  if(args.size() < 4 || args.size() > 5)
+    {
+    this->SetError("sub-command FIND requires 3 or 4 parameters.");
+    return false;
+    }
+
+  // check if the reverse flag was set or not
+  bool reverseMode = false;
+  if(args.size() == 5 && args[4] == "REVERSE")
+    {
+    reverseMode = true;
+    }
+
+  // if we have 5 arguments the last one must be REVERSE
+  if(args.size() == 5 && args[4] != "REVERSE")
+    {
+    this->SetError("sub-command FIND: unknown last parameter");
+    return false;
+    }
+
+  // local parameter names.
+  const std::string& sstring = args[1];
+  const std::string& schar = args[2];
+  const std::string& outvar = args[3];
+
+  // ensure that the user cannot accidentally specify REVERSE as a variable
+  if(outvar == "REVERSE")
+    {
+    this->SetError("sub-command FIND does not allow to select REVERSE as "
+                   "the output variable.  "
+                   "Maybe you missed the actual output variable?");
+    return false;
+    }
+
+  // try to find the character and return its position
+  size_t pos;
+  if(!reverseMode)
+    {
+    pos = sstring.find(schar);
+    }
+  else
+    {
+    pos = sstring.rfind(schar);
+    }
+  if(std::string::npos != pos)
+    {
+    cmOStringStream s;
+    s << pos;
+    this->Makefile->AddDefinition(outvar.c_str(), s.str().c_str());
+    return true;
+    }
+
+  // the character was not found, but this is not really an error
+  this->Makefile->AddDefinition(outvar.c_str(), "-1");
+  return true;
+}
+
 //----------------------------------------------------------------------------
 bool cmStringCommand::HandleCompareCommand(std::vector<std::string> const&
                                            args)

Source/cmStringCommand.h

@@ -90,6 +90,7 @@ public:
       "  string(STRIP <string> <output variable>)\n"
       "  string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>]\n"
       "         [RANDOM_SEED <seed>] <output variable>)\n"
+      "  string(FIND <string> <substring> <output variable> [REVERSE])\n"
       "REGEX MATCH will match the regular expression once and store the "
       "match in the output variable.\n"
       "REGEX MATCHALL will match the regular expression as many times as "
@@ -117,6 +118,10 @@ public:
       "characters and default alphabet is all numbers and upper and "
       "lower case letters.  If an integer RANDOM_SEED is given, its "
       "value will be used to seed the random number generator.\n"
+      "FIND will return the position where the given substring was found "
+      "in the supplied string. If the REVERSE flag was used, the command "
+      "will search for the position of the last occurrence of the "
+      "specified substring.\n"
       "The following characters have special meaning in regular expressions:\n"
       "   ^         Matches at beginning of a line\n"
       "   $         Matches at end of a line\n"
@@ -152,6 +157,7 @@ protected:
   bool HandleSubstringCommand(std::vector<std::string> const& args);
   bool HandleStripCommand(std::vector<std::string> const& args);
   bool HandleRandomCommand(std::vector<std::string> const& args);
+  bool HandleFindCommand(std::vector<std::string> const& args);
 
   class RegexReplacement
   {

Source/cmTarget.cxx

@@ -187,6 +187,22 @@ void cmTarget::DefineProperties(cmake *cm)
      "A message to display on some generators (such as makefiles) when "
      "the target is built.");
 
+  cm->DefineProperty
+    ("BUNDLE", cmProperty::TARGET,
+     "This target is a CFBundle on the Mac.",
+     "If a module library target has this property set to true it will "
+     "be built as a CFBundle when built on the mac. It will have the "
+     "directory structure required for a CFBundle and will be suitable "
+     "to be used for creating Browser Plugins or other application "
+     "resources.");
+
+  cm->DefineProperty
+    ("BUNDLE_EXTENSION", cmProperty::TARGET,
+     "The file extension used to name a BUNDLE target on the Mac.",
+     "The default value is \"bundle\" - you can also use \"plugin\" or "
+     "whatever file extension is required by the host app for your "
+     "bundle.");
+
   cm->DefineProperty
     ("FRAMEWORK", cmProperty::TARGET,
      "This target is a framework on the Mac.",
@@ -1210,6 +1226,14 @@ bool cmTarget::IsAppBundleOnApple()
           this->GetPropertyAsBool("MACOSX_BUNDLE"));
 }
 
+//----------------------------------------------------------------------------
+bool cmTarget::IsCFBundleOnApple()
+{
+  return (this->GetType() == cmTarget::MODULE_LIBRARY &&
+          this->Makefile->IsOn("APPLE") &&
+          this->GetPropertyAsBool("BUNDLE"));
+}
+
 //----------------------------------------------------------------------------
 class cmTargetTraceDependencies
 {

Source/cmTarget.h

@@ -326,7 +326,7 @@ public:
    */
   bool FindSourceFiles();
 
-  ///! Return the prefered linker language for this target
+  ///! Return the preferred linker language for this target
   const char* GetLinkerLanguage(const char* config = 0);
 
   ///! Return the rule variable used to create this type of target,
@@ -430,6 +430,9 @@ public:
       Apple.  */
   bool IsFrameworkOnApple();
 
+  /** Return whether this target is a CFBundle (plugin) on Apple.  */
+  bool IsCFBundleOnApple();
+
   /** Return whether this target is an executable Bundle on Apple.  */
   bool IsAppBundleOnApple();
 

Source/cmVisualStudio10TargetGenerator.cxx

@@ -167,6 +167,7 @@ void cmVisualStudio10TargetGenerator::Generate()
   // Write the encoding header into the file
   char magic[] = {0xEF,0xBB, 0xBF};
   this->BuildFileStream->write(magic, 3);
+  this->WriteString("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n",0);
   this->WriteString("<Project DefaultTargets=\"Build\" "
                     "ToolsVersion=\"4.0\" "
                     "xmlns=\"http://schemas.microsoft.com/"
@@ -998,6 +999,15 @@ OutputLinkIncremental(std::string const& configName)
   this->WritePlatformConfigTag("LinkIncremental", configName.c_str(), 3);
   *this->BuildFileStream << incremental
                          << "</LinkIncremental>\n"; 
+
+  const char* manifest = "true";
+  if(flags.find("MANIFEST:NO") != flags.npos)
+    {
+    manifest = "false";
+    }
+  this->WritePlatformConfigTag("GenerateManifest", configName.c_str(), 3);
+  *this->BuildFileStream << manifest
+                         << "</GenerateManifest>\n";
 }
 
 //----------------------------------------------------------------------------
@@ -1326,7 +1336,7 @@ void cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const&
   linkDirs += "%(AdditionalLibraryDirectories)";
   linkOptions.AddFlag("AdditionalLibraryDirectories", linkDirs.c_str());
   linkOptions.AddFlag("AdditionalDependencies", libs.c_str());
-  linkOptions.AddFlag("Version", "0.0");
+  linkOptions.AddFlag("Version", "");
   if(linkOptions.IsDebug() || flags.find("/debug") != flags.npos)
     {
     linkOptions.AddFlag("GenerateDebugInformation", "true");
@@ -1369,6 +1379,8 @@ void cmVisualStudio10TargetGenerator::WriteLinkOptions(std::string const&
     linkOptions.AddFlag("ModuleDefinitionFile",
                         this->ModuleDefinitionFile.c_str());
     }
+
+  linkOptions.RemoveFlag("GenerateManifest");
   linkOptions.OutputAdditionalOptions(*this->BuildFileStream, "      ", "");
   linkOptions.OutputFlagMap(*this->BuildFileStream, "      ");
   

Source/cmake.cxx

@@ -462,7 +462,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
           }
         }
       std::cerr << "loading initial cache file " << path.c_str() << "\n";
-      this->ReadListFile(path.c_str());
+      this->ReadListFile(args, path.c_str());
       }
     else if(arg.find("-P",0) == 0)
       {
@@ -478,13 +478,14 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
         cmSystemTools::Error("No cmake script provided.");
         return false;
         }
-      this->ReadListFile(path.c_str());
+      this->ReadListFile(args, path.c_str());
       }
     }
   return true;
 }
 
-void cmake::ReadListFile(const char *path)
+void cmake::ReadListFile(const std::vector<std::string>& args,
+                         const char *path)
 {
   // if a generator was not yet created, temporarily create one
   cmGlobalGenerator *gg = this->GetGlobalGenerator();
@@ -510,6 +511,14 @@ void cmake::ReadListFile(const char *path)
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
     lg->GetMakefile()->SetStartDirectory
       (cmSystemTools::GetCurrentWorkingDirectory().c_str());
+    if (this->GetScriptMode())
+      {
+      std::string file(cmSystemTools::CollapseFullPath(path));
+      cmSystemTools::ConvertToUnixSlashes(file);
+      lg->GetMakefile()->SetScriptModeFile(file.c_str());
+
+      lg->GetMakefile()->SetArgcArgv(args);
+      }
     if (!lg->GetMakefile()->ReadListFile(0, path))
       {
       cmSystemTools::Error("Error processing file:", path);
@@ -979,37 +988,39 @@ void CMakeCommandUsage(const char* program)
   errorStream
     << "Usage: " << program << " -E [command] [arguments ...]\n"
     << "Available commands: \n"
+    << "  build build_dir           - build the project in build_dir.\n"
     << "  chdir dir cmd [args]...   - run command in a given directory\n"
-    << "  rename oldname newname    - rename a file or directory "
+    << "  compare_files file1 file2 - check if file1 is same as file2\n"
-       "(on one volume)\n"
     << "  copy file destination     - copy file to destination (either file "
        "or directory)\n"
-    << "  copy_if_different in-file out-file  - copy file if input has "
-       "changed\n"
     << "  copy_directory source destination   - copy directory 'source' "
        "content to directory 'destination'\n"
-    << "  compare_files file1 file2 - check if file1 is same as file2\n"
+    << "  copy_if_different in-file out-file  - copy file if input has "
+       "changed\n"
     << "  echo [string]...          - displays arguments as text\n"
     << "  echo_append [string]...   - displays arguments as text but no new "
        "line\n"
     << "  environment               - display the current environment\n"
     << "  make_directory dir        - create a directory\n"
     << "  md5sum file1 [...]        - compute md5sum of files\n"
-    << "  remove_directory dir      - remove a directory and its contents\n"
     << "  remove [-f] file1 file2 ... - remove the file(s), use -f to force "
        "it\n"
+    << "  remove_directory dir      - remove a directory and its contents\n"
+    << "  rename oldname newname    - rename a file or directory "
+       "(on one volume)\n"
     << "  tar [cxt][vfz][cvfj] file.tar "
     "file/dir1 file/dir2 ... - create a tar "
     "archive\n"
     << "  time command [args] ...   - run command and return elapsed time\n"
     << "  touch file                - touch a file.\n"
     << "  touch_nocreate file       - touch a file but do not create it.\n"
-    << "  build build_dir           - build the project in build_dir.\n"
 #if defined(_WIN32) && !defined(__CYGWIN__)
-    << "  write_regv key value      - write registry value\n"
+    << "Available on Windows only:\n"
-    << "  delete_regv key           - delete registry value\n"
     << "  comspec                   - on windows 9x use this for RunCommand\n"
+    << "  delete_regv key           - delete registry value\n"
+    << "  write_regv key value      - write registry value\n"
 #else
+    << "Available on UNIX only:\n"
     << "  create_symlink old new    - create a symbolic link new -> old\n"
 #endif
     ;
@@ -1984,8 +1995,32 @@ int cmake::Configure()
 
 }
 
+bool cmake::RejectUnsupportedPaths(const char* desc, std::string const& path)
+{
+  // Some characters are not well-supported by native build systems.
+  std::string::size_type pos = path.find_first_of("=");
+  if(pos == std::string::npos)
+    {
+    return false;
+    }
+  cmOStringStream e;
+  e << "The path to the " << desc << " directory:\n"
+    << "  " << path << "\n"
+    << "contains unsupported character '" << path[pos] << "'.\n"
+    << "Please use a different " << desc << " directory name.";
+  cmListFileBacktrace bt;
+  this->IssueMessage(cmake::FATAL_ERROR, e.str(), bt);
+  return true;
+}
+
 int cmake::ActualConfigure()
 {
+  if(this->RejectUnsupportedPaths("source", this->cmHomeDirectory) ||
+     this->RejectUnsupportedPaths("binary", this->HomeOutputDirectory))
+    {
+    return 1;
+    }
+
   // Construct right now our path conversion table before it's too late:
   this->UpdateConversionPathTable();
   this->CleanupCommandsAndMacros();
@@ -2197,13 +2232,14 @@ int cmake::ActualConfigure()
 
 void cmake::PreLoadCMakeFiles()
 {
+  std::vector<std::string> args;
   std::string pre_load = this->GetHomeDirectory();
   if ( pre_load.size() > 0 )
     {
     pre_load += "/PreLoad.cmake";
     if ( cmSystemTools::FileExists(pre_load.c_str()) )
       {
-      this->ReadListFile(pre_load.c_str());
+      this->ReadListFile(args, pre_load.c_str());
       }
     }
   pre_load = this->GetHomeOutputDirectory();
@@ -2212,7 +2248,7 @@ void cmake::PreLoadCMakeFiles()
     pre_load += "/PreLoad.cmake";
     if ( cmSystemTools::FileExists(pre_load.c_str()) )
       {
-      this->ReadListFile(pre_load.c_str());
+      this->ReadListFile(args, pre_load.c_str());
       }
     }
 }
@@ -4108,7 +4144,10 @@ int cmake::VisualStudioLinkNonIncremental(std::vector<std::string>& args,
     return -1;
     }
   // Run the link command as given
-  linkCommand.push_back("/MANIFEST");
+  if (hasManifest)
+    {
+    linkCommand.push_back("/MANIFEST");
+    }
   if(!cmake::RunCommand("LINK", linkCommand, verbose))
     {
     return -1;

Source/cmake.h

@@ -406,7 +406,7 @@ protected:
   bool DoSuppressDevWarnings;
 
   ///! read in a cmake list file to initialize the cache
-  void ReadListFile(const char *path);
+  void ReadListFile(const std::vector<std::string>& args, const char *path);
 
   ///! Check if CMAKE_CACHEFILE_DIR is set. If it is not, delete the log file.
   ///  If it is set, truncate it to 50kb
@@ -451,6 +451,8 @@ protected:
 
   ///! Find the full path to one of the cmake programs like ctest, cpack, etc.
   std::string FindCMakeProgram(const char* name) const;
+
+  bool RejectUnsupportedPaths(const char* desc, std::string const& path);
 private:
   cmake(const cmake&);  // Not implemented.
   void operator=(const cmake&);  // Not implemented.

Source/cmakemain.cxx

@@ -71,11 +71,13 @@ static const char * cmDocumentationOptions[][3] =
   {"-E", "CMake command mode.",
    "For true platform independence, CMake provides a list of commands "
    "that can be used on all systems. Run with -E help for the usage "
-   "information. Commands available are: chdir, copy, copy_if_different "
+   "information. Commands available are: build, chdir, compare_files, copy, "
-   "copy_directory, compare_files, echo, echo_append, environment, "
+   "copy_directory, copy_if_different, echo, echo_append, environment, "
-   "make_directory, md5sum, remove_directory, remove, tar, time, "
+   "make_directory, md5sum, remove, remove_directory, rename, tar, time, "
-   "touch, touch_nocreate, write_regv, delete_regv, comspec, "
+   "touch, touch_nocreate. In addition, some platform specific commands "
-   "create_symlink."},
+   "are available. "
+   "On Windows: comspec, delete_regv, write_regv. "
+   "On UNIX: create_symlink."},
   {"-i", "Run in wizard mode.",
    "Wizard mode runs cmake interactively without a GUI.  The user is "
    "prompted to answer questions about the project configuration.  "

Source/kwsys/CMakeLists.txt

@@ -1,6 +1,6 @@
 #=============================================================================
 # KWSys - Kitware System Library
-# Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+# Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -44,9 +44,7 @@
 #      SET(KWSYS_IOS_FORCE_OLD 1)
 #
 #
-# Optional settings to setup install rules work in one of two ways.
+# Optional settings to setup install rules are as follows:
-# The modern way utilizes the CMake 2.4 INSTALL command.  Settings
-# for this mode are as follows:
 #
 #  KWSYS_INSTALL_BIN_DIR     = The installation target directories into
 #  KWSYS_INSTALL_LIB_DIR       which the libraries and headers from
@@ -70,25 +68,6 @@
 #      SET(KWSYS_INSTALL_INCLUDE_DIR include)
 #      SET(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME Runtime)
 #      SET(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT Development)
-#
-# The old way uses the original CMake INSTALL_* commands.  Settings
-# for this mode are as follows:
-#
-#  KWSYS_LIBRARY_INSTALL_DIR = The installation target directories into
-#  KWSYS_HEADER_INSTALL_DIR    which the libraries and headers from
-#                              kwsys should be installed by a "make install".
-#                              The values should be specified relative to
-#                              the installation prefix and start with a '/'.
-#    Example:
-#
-#      SET(KWSYS_LIBRARY_INSTALL_DIR /lib)
-#      SET(KWSYS_HEADER_INSTALL_DIR /include)
-#
-# The modern way will be used whenever the INSTALL command is
-# available.  If the settings are not available the old names will be
-# used to construct them.  The old way will be used whenever the
-# INSTALL command is not available.  If the settings are not available
-# the new names will be used to construct them.
 
 # Once configured, kwsys should be used as follows from C or C++ code:
 #
@@ -105,13 +84,7 @@
 # any outside mailing list and no documentation of the change will be
 # written.
 
-CMAKE_MINIMUM_REQUIRED(VERSION 2.4.5 FATAL_ERROR)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6.3 FATAL_ERROR)
-IF(COMMAND CMAKE_POLICY)
-  CMAKE_POLICY(SET CMP0003 NEW)
-ENDIF(COMMAND CMAKE_POLICY)
-
-# Allow empty endif() and such with CMake 2.4.
-SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS 1)
 
 #-----------------------------------------------------------------------------
 # If a namespace is not specified, use "kwsys" and enable testing.
@@ -126,23 +99,11 @@ ENDIF(NOT KWSYS_NAMESPACE)
 # The project name is that of the specified namespace.
 PROJECT(${KWSYS_NAMESPACE})
 
-# Some properties we set only with CMake 2.6 and above.
-IF(COMMAND SET_PROPERTY)
-  MACRO(KWSYS_SET_PROPERTY)
-    SET_PROPERTY(${ARGV})
-  ENDMACRO(KWSYS_SET_PROPERTY)
-ELSE(COMMAND SET_PROPERTY)
-  MACRO(KWSYS_SET_PROPERTY)
-  ENDMACRO(KWSYS_SET_PROPERTY)
-ENDIF(COMMAND SET_PROPERTY)
-
 # Tell CMake how to follow dependencies of sources in this directory.
-IF(COMMAND SET_PROPERTY)
+SET_PROPERTY(DIRECTORY
-  SET_PROPERTY(DIRECTORY
+  PROPERTY IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
-    PROPERTY IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
+  "KWSYS_HEADER(%)=<${KWSYS_NAMESPACE}/%>"
-    "KWSYS_HEADER(%)=<${KWSYS_NAMESPACE}/%>"
+  )
-    )
-ENDIF(COMMAND SET_PROPERTY)
 
 # Select library components.
 IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
@@ -208,97 +169,75 @@ INCLUDE(CheckTypeSize)
 # Do full dependency headers.
 INCLUDE_REGULAR_EXPRESSION("^.*$")
 
-# Choose which kind of install commands to use.
+# Use new KWSYS_INSTALL_*_DIR variable names to control installation.
-IF(COMMAND INSTALL)
+# Take defaults from the old names.  Note that there was no old name
-  # Use new KWSYS_INSTALL_*_DIR variable names to control installation.
+# for the bin dir, so we take the old lib dir name so DLLs will be
-  # Take defaults from the old names.  Note that there was no old name
+# installed in a compatible way for old code.
-  # for the bin dir, so we take the old lib dir name so DLLs will be
+IF(NOT KWSYS_INSTALL_INCLUDE_DIR)
-  # installed in a compatible way for old code.
+  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_INCLUDE_DIR
-  IF(NOT KWSYS_INSTALL_INCLUDE_DIR)
+    "${KWSYS_HEADER_INSTALL_DIR}")
-    STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_INCLUDE_DIR
+ENDIF(NOT KWSYS_INSTALL_INCLUDE_DIR)
-      "${KWSYS_HEADER_INSTALL_DIR}")
+IF(NOT KWSYS_INSTALL_LIB_DIR)
-  ENDIF(NOT KWSYS_INSTALL_INCLUDE_DIR)
+  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
-  IF(NOT KWSYS_INSTALL_LIB_DIR)
+    "${KWSYS_LIBRARY_INSTALL_DIR}")
-    STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
+ENDIF(NOT KWSYS_INSTALL_LIB_DIR)
-      "${KWSYS_LIBRARY_INSTALL_DIR}")
+IF(NOT KWSYS_INSTALL_BIN_DIR)
-  ENDIF(NOT KWSYS_INSTALL_LIB_DIR)
+  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
-  IF(NOT KWSYS_INSTALL_BIN_DIR)
+    "${KWSYS_LIBRARY_INSTALL_DIR}")
-    STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
+ENDIF(NOT KWSYS_INSTALL_BIN_DIR)
-      "${KWSYS_LIBRARY_INSTALL_DIR}")
-  ENDIF(NOT KWSYS_INSTALL_BIN_DIR)
 
-  # Setup header install rules.
+# Setup header install rules.
-  SET(KWSYS_INSTALL_INCLUDE_OPTIONS)
+SET(KWSYS_INSTALL_INCLUDE_OPTIONS)
+IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
+  SET(KWSYS_INSTALL_INCLUDE_OPTIONS ${KWSYS_INSTALL_INCLUDE_OPTIONS}
+    COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
+    )
+ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
+
+# Setup library install rules.
+SET(KWSYS_INSTALL_LIBRARY_RULE)
+IF(KWSYS_INSTALL_LIB_DIR)
+  IF(KWSYS_INSTALL_EXPORT_NAME)
+    LIST(APPEND KWSYS_INSTALL_LIBRARY_RULE EXPORT ${KWSYS_INSTALL_EXPORT_NAME})
+  ENDIF()
+  # Install the shared library to the lib directory.
+  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+    LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR}
+    )
+  # Assign the shared library to the runtime component.
+  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
+    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
+      )
+  ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
+
+  # Install the archive to the lib directory.
+  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+    ARCHIVE DESTINATION ${KWSYS_INSTALL_LIB_DIR}
+    )
+  # Assign the archive to the development component.
   IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-    SET(KWSYS_INSTALL_INCLUDE_OPTIONS ${KWSYS_INSTALL_INCLUDE_OPTIONS}
+    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
       )
   ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-
+ENDIF(KWSYS_INSTALL_LIB_DIR)
-  # Setup library install rules.
+IF(KWSYS_INSTALL_BIN_DIR)
-  SET(KWSYS_INSTALL_LIBRARY_RULE)
+  # Install the runtime library to the bin directory.
-  IF(KWSYS_INSTALL_LIB_DIR)
+  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-    IF(KWSYS_INSTALL_EXPORT_NAME)
+    RUNTIME DESTINATION ${KWSYS_INSTALL_BIN_DIR}
-      LIST(APPEND KWSYS_INSTALL_LIBRARY_RULE EXPORT ${KWSYS_INSTALL_EXPORT_NAME})
+    )
-    ENDIF()
+  # Assign the runtime library to the runtime component.
-    # Install the shared library to the lib directory.
+  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
     SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-      LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR}
+      COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
       )
-    # Assign the shared library to the runtime component.
+  ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
-    IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
+ENDIF(KWSYS_INSTALL_BIN_DIR)
-      SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
-        )
-    ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
 
-    # Install the archive to the lib directory.
+# Do not support old KWSYS_*a_INSTALL_DIR variable names.
-    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+SET(KWSYS_HEADER_INSTALL_DIR)
-      ARCHIVE DESTINATION ${KWSYS_INSTALL_LIB_DIR}
+SET(KWSYS_LIBRARY_INSTALL_DIR)
-      )
-    # Assign the archive to the development component.
-    IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-      SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
-        )
-    ENDIF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-  ENDIF(KWSYS_INSTALL_LIB_DIR)
-  IF(KWSYS_INSTALL_BIN_DIR)
-    # Install the runtime library to the bin directory.
-    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-      RUNTIME DESTINATION ${KWSYS_INSTALL_BIN_DIR}
-      )
-    # Assign the runtime library to the runtime component.
-    IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
-      SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
-        COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
-        )
-    ENDIF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
-  ENDIF(KWSYS_INSTALL_BIN_DIR)
-
-  # Do not support old KWSYS_*_INSTALL_DIR variable names.
-  SET(KWSYS_HEADER_INSTALL_DIR)
-  SET(KWSYS_LIBRARY_INSTALL_DIR)
-
-ELSE(COMMAND INSTALL)
-  # Use old KWSYS_*_INSTALL_DIR variable names.
-  # Take defaults from the new names.
-  IF(KWSYS_INSTALL_LIB_DIR)
-    IF(NOT KWSYS_LIBRARY_INSTALL_DIR)
-      SET(KWSYS_LIBRARY_INSTALL_DIR "/${KWSYS_INSTALL_LIB_DIR}")
-    ENDIF(NOT KWSYS_LIBRARY_INSTALL_DIR)
-  ENDIF(KWSYS_INSTALL_LIB_DIR)
-  IF(KWSYS_INSTALL_INCLUDE_DIR)
-    IF(NOT KWSYS_HEADER_INSTALL_DIR)
-      SET(KWSYS_HEADER_INSTALL_DIR "/${KWSYS_INSTALL_INCLUDE_DIR}")
-    ENDIF(NOT KWSYS_HEADER_INSTALL_DIR)
-  ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-
-  # Do not support new KWSYS_INSTALL_*_DIR variable names.
-  SET(KWSYS_INSTALL_BIN_DIR)
-  SET(KWSYS_INSTALL_INCLUDE_DIR)
-  SET(KWSYS_INSTALL_LIB_DIR)
-ENDIF(COMMAND INSTALL)
 
 # Generated source files will need this header.
 STRING(COMPARE EQUAL "${PROJECT_SOURCE_DIR}" "${PROJECT_BINARY_DIR}"
@@ -680,10 +619,6 @@ FOREACH(header
         DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
         ${KWSYS_INSTALL_INCLUDE_OPTIONS})
     ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-    IF(KWSYS_HEADER_INSTALL_DIR)
-      INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/stl
-        FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx)
-    ENDIF(KWSYS_HEADER_INSTALL_DIR)
   ELSE(KWSYS_STL_HEADER_EXTRA_${header})
     SET(KWSYS_STL_HEADER_EXTRA "")
   ENDIF(KWSYS_STL_HEADER_EXTRA_${header})
@@ -697,10 +632,6 @@ FOREACH(header
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-  IF(KWSYS_HEADER_INSTALL_DIR)
-    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/stl
-      FILES ${KWSYS_HEADER_DIR}/stl/${header})
-  ENDIF(KWSYS_HEADER_INSTALL_DIR)
 ENDFOREACH(header)
 
 # Provide cstddef header.
@@ -711,10 +642,6 @@ IF(KWSYS_INSTALL_INCLUDE_DIR)
   INSTALL(FILES ${KWSYS_HEADER_DIR}/cstddef
     DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
     ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-  IF(KWSYS_HEADER_INSTALL_DIR)
-    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
-      FILES ${KWSYS_HEADER_DIR}/cstddef)
-  ENDIF(KWSYS_HEADER_INSTALL_DIR)
 ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
 
 #-----------------------------------------------------------------------------
@@ -732,10 +659,6 @@ FOREACH(header iostream fstream sstream iosfwd)
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/ios
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-  IF(KWSYS_HEADER_INSTALL_DIR)
-    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}/ios
-      FILES ${KWSYS_HEADER_DIR}/ios/${header})
-  ENDIF(KWSYS_HEADER_INSTALL_DIR)
 ENDFOREACH(header)
 
 #-----------------------------------------------------------------------------
@@ -824,10 +747,6 @@ FOREACH(c ${KWSYS_CLASSES})
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-  IF(KWSYS_HEADER_INSTALL_DIR)
-    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
-                  FILES  ${KWSYS_HEADER_DIR}/${c}.hxx)
-  ENDIF(KWSYS_HEADER_INSTALL_DIR)
 ENDFOREACH(c)
 
 # Configure C headers.
@@ -843,10 +762,6 @@ FOREACH(h ${KWSYS_H_FILES})
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-  IF(KWSYS_HEADER_INSTALL_DIR)
-    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
-                  FILES  ${KWSYS_HEADER_DIR}/${h}.h)
-  ENDIF(KWSYS_HEADER_INSTALL_DIR)
 ENDFOREACH(h)
 
 # Configure other C++ headers.
@@ -862,10 +777,6 @@ FOREACH(h ${KWSYS_HXX_FILES})
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
   ENDIF(KWSYS_INSTALL_INCLUDE_DIR)
-  IF(KWSYS_HEADER_INSTALL_DIR)
-    INSTALL_FILES(${KWSYS_HEADER_INSTALL_DIR}/${KWSYS_NAMESPACE}
-                  FILES  ${KWSYS_HEADER_DIR}/${h}.hxx)
-  ENDIF(KWSYS_HEADER_INSTALL_DIR)
 ENDFOREACH(h)
 
 #-----------------------------------------------------------------------------
@@ -873,7 +784,7 @@ ENDFOREACH(h)
 IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
   ADD_LIBRARY(${KWSYS_NAMESPACE} ${KWSYS_LIBRARY_TYPE}
     ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
-  KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY LABELS ${KWSYS_LABELS_LIB})
+  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY LABELS ${KWSYS_LABELS_LIB})
   IF(KWSYS_USE_DynamicLoader)
     IF(UNIX)
       TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${CMAKE_DL_LIBS})
@@ -895,15 +806,12 @@ IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
   IF(KWSYS_INSTALL_LIBRARY_RULE)
     INSTALL(TARGETS ${KWSYS_NAMESPACE} ${KWSYS_INSTALL_LIBRARY_RULE})
   ENDIF(KWSYS_INSTALL_LIBRARY_RULE)
-  IF(KWSYS_LIBRARY_INSTALL_DIR)
-    INSTALL_TARGETS(${KWSYS_LIBRARY_INSTALL_DIR} ${KWSYS_NAMESPACE})
-  ENDIF(KWSYS_LIBRARY_INSTALL_DIR)
 ENDIF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
 
 # Add a C-only library if requested.
 IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
   ADD_LIBRARY(${KWSYS_NAMESPACE}_c ${KWSYS_LIBRARY_TYPE} ${KWSYS_C_SRCS})
-  KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}_c PROPERTY LABELS ${KWSYS_LABELS_LIB})
+  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}_c PROPERTY LABELS ${KWSYS_LABELS_LIB})
 
   # Apply user-defined target properties to the library.
   IF(KWSYS_PROPERTIES_C)
@@ -916,9 +824,6 @@ IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
   IF(KWSYS_INSTALL_LIBRARY_RULE)
     INSTALL(TARGETS ${KWSYS_NAMESPACE}_c ${KWSYS_INSTALL_LIBRARY_RULE})
   ENDIF(KWSYS_INSTALL_LIBRARY_RULE)
-  IF(KWSYS_LIBRARY_INSTALL_DIR)
-    INSTALL_TARGETS(${KWSYS_LIBRARY_INSTALL_DIR} ${KWSYS_NAMESPACE}_c)
-  ENDIF(KWSYS_LIBRARY_INSTALL_DIR)
 ENDIF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
 
 # For building kwsys itself, we use a macro defined on the command
@@ -942,8 +847,8 @@ IF(KWSYS_USE_Process)
     # encode it into a C file.
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}ProcessFwd9x ProcessFwd9x.c)
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}EncodeExecutable EncodeExecutable.c)
-    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}ProcessFwd9x PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}ProcessFwd9x PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}EncodeExecutable PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}EncodeExecutable PROPERTY LABELS ${KWSYS_LABELS_EXE})
 
     # Construct the location of the executable to be encoded.
     SET(BIN_DIR ${CMAKE_CURRENT_BINARY_DIR})
@@ -959,23 +864,12 @@ IF(KWSYS_USE_Process)
     # Take advantage of a better custom command syntax if possible.
     SET(CMD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}EncodeExecutable.exe)
     SET(FWD ${BIN_DIR}${CFG_INTDIR}/${KWSYS_NAMESPACE}ProcessFwd9x.exe)
-    IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
+    ADD_CUSTOM_COMMAND(
-      ADD_CUSTOM_COMMAND(
+      OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
-        OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
+      COMMAND ${CMD}
-        COMMAND ${CMD}
+      ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
-        ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
+           ${KWSYS_NAMESPACE} ProcessFwd9x
-             ${KWSYS_NAMESPACE} ProcessFwd9x
+      DEPENDS ${CMD} ${FWD})
-        DEPENDS ${CMD} ${FWD})
-    ELSE("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
-      ADD_CUSTOM_COMMAND(
-        TARGET ${KWSYS_NAMESPACE}
-        SOURCE ${CMAKE_CURRENT_SOURCE_DIR}/ProcessFwd9x.c
-        COMMAND ${CMD}
-        ARGS ${FWD} ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
-             ${KWSYS_NAMESPACE} ProcessFwd9x
-        OUTPUTS ${CMAKE_CURRENT_BINARY_DIR}/${KWSYS_NAMESPACE}ProcessFwd9xEnc.c
-        DEPENDS ${CMD} ${FWD})
-    ENDIF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" GREATER 1.6)
 
     # Make sure build occurs in proper order.
     ADD_DEPENDENCIES(${KWSYS_NAMESPACE} ${KWSYS_NAMESPACE}ProcessFwd9x
@@ -998,19 +892,19 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       testEncode
       testTerminal
       )
-    IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
+    IF(KWSYS_STANDALONE)
       SET(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail)
-    ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
+    ENDIF()
     CREATE_TEST_SOURCELIST(
       KWSYS_C_TEST_SRCS ${KWSYS_NAMESPACE}TestsC.c
       ${KWSYS_C_TESTS}
       )
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
-    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_NAMESPACE}_c)
     FOREACH(test ${KWSYS_C_TESTS})
       ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
-      KWSYS_SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
+      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
     ENDFOREACH(test)
 
     # C++ tests
@@ -1034,7 +928,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader)
       # If kwsys contains the DynamicLoader, need extra library
       ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
-      KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
+      SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
       ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_NAMESPACE})
     ENDIF(KWSYS_USE_DynamicLoader)
     CREATE_TEST_SOURCELIST(
@@ -1042,7 +936,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       ${KWSYS_CXX_TESTS}
       )
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
-    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_NAMESPACE})
     SET(TEST_SYSTEMTOOLS_BIN_FILE
       "${CMAKE_CURRENT_SOURCE_DIR}/testSystemTools.bin")
@@ -1089,19 +983,19 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       )
     FOREACH(test ${KWSYS_CXX_TESTS})
       ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
-      KWSYS_SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
+      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
     ENDFOREACH(test)
 
     # Process tests.
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestProcess testProcess.c)
-    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
     TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_NAMESPACE}_c)
     IF(NOT CYGWIN)
       SET(KWSYS_TEST_PROCESS_7 7)
     ENDIF(NOT CYGWIN)
     FOREACH(n 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7})
       ADD_TEST(kwsys.testProcess-${n} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestProcess ${n})
-      KWSYS_SET_PROPERTY(TEST kwsys.testProcess-${n} PROPERTY LABELS ${KWSYS_LABELS_TEST})
+      SET_PROPERTY(TEST kwsys.testProcess-${n} PROPERTY LABELS ${KWSYS_LABELS_TEST})
       SET_TESTS_PROPERTIES(kwsys.testProcess-${n} PROPERTIES TIMEOUT 120)
     ENDFOREACH(n)
 
@@ -1115,13 +1009,13 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
                    ${PROJECT_BINARY_DIR}/testSharedForward.c @ONLY IMMEDIATE)
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestSharedForward
                    ${PROJECT_BINARY_DIR}/testSharedForward.c)
-    KWSYS_SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
     ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_NAMESPACE}_c)
     ADD_TEST(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
-    KWSYS_SET_PROPERTY(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
+    SET_PROPERTY(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
 
     # Configure some test properties.
-    IF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
+    IF(KWSYS_STANDALONE)
       # We expect test to fail
       SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES WILL_FAIL ON)
       GET_TEST_PROPERTY(kwsys.testFail WILL_FAIL wfv)
@@ -1129,7 +1023,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       SET_TESTS_PROPERTIES(kwsys.testRegistry PROPERTIES PASS_REGULAR_EXPRESSION "Test passed")
       SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
       MESSAGE(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
-    ENDIF(COMMAND SET_TESTS_PROPERTIES AND COMMAND GET_TEST_PROPERTY AND KWSYS_STANDALONE)
+    ENDIF()
 
     # Suppress known consistent failures on buggy systems.
     IF(KWSYS_TEST_BOGUS_FAILURES)

Source/kwsys/kwsysDateStamp.cmake

@@ -15,7 +15,7 @@
 SET(KWSYS_DATE_STAMP_YEAR  2011)
 
 # KWSys version date month component.  Format is MM.
-SET(KWSYS_DATE_STAMP_MONTH 01)
+SET(KWSYS_DATE_STAMP_MONTH 03)
 
 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   30)
+SET(KWSYS_DATE_STAMP_DAY   02)

Tests/BundleTest/BundleLib.cxx

@@ -3,7 +3,7 @@
 #include <stdlib.h>
 #include <unistd.h>
 
-#include <Carbon/Carbon.h>
+#include <CoreFoundation/CoreFoundation.h>
 
 int fileExists(char* filename)
 {
@@ -51,7 +51,7 @@ int findBundleFile(char* exec, const char* file)
 
 int foo(char *exec)
 {
-  // Call a "Carbon" function...
+  // Call a CoreFoundation function...
   //
   CFBundleRef br = CFBundleGetMainBundle();
   (void) br;

Tests/BundleTest/BundleTest.cxx

@@ -1,6 +1,6 @@
 #include <stdio.h>
 
-#include <Carbon/Carbon.h>
+#include <CoreFoundation/CoreFoundation.h>
 
 extern int foo(char* exec);
 
@@ -8,8 +8,8 @@ int main(int argc, char* argv[])
 {
   printf("Started with: %d arguments\n", argc);
 
-  // Call a "Carbon" function... but pull in the link dependency on "-framework
+  // Call a CoreFoundation function... but pull in the link dependency on "-framework
-  // Carbon" via CMake's dependency chaining mechanism. This code exists to
+  // CoreFoundation" via CMake's dependency chaining mechanism. This code exists to
   // verify that the chaining mechanism works with "-framework blah" style
   // link dependencies.
   //

Tests/BundleTest/CMakeLists.txt

@@ -25,14 +25,14 @@ SET_SOURCE_FILES_PROPERTIES(
 SET(EXECUTABLE_OUTPUT_PATH "${CMAKE_CURRENT_BINARY_DIR}/foobar")
 
 # Test building a bundle linking to a shared library where the
-# shared library links to Carbon, but the executable does not
+# shared library links to CoreFoundation, but the executable does not
-# explicitly link to Carbon, but the executable does *depend*
+# explicitly link to CoreFoundation, but the executable does *depend*
-# on Carbon. There should be a link failure for the executable
+# on CoreFoundation. There should be a link failure for the executable
 # if CMake's dependency chaining for libraries with "-framework
 # blah" style dependencies gets broken...
 #
 ADD_LIBRARY(BundleTestLib SHARED BundleLib.cxx)
-TARGET_LINK_LIBRARIES(BundleTestLib "-framework Carbon")
+TARGET_LINK_LIBRARIES(BundleTestLib "-framework CoreFoundation")
 
 ADD_EXECUTABLE(BundleTest
   MACOSX_BUNDLE
@@ -43,8 +43,8 @@ ADD_EXECUTABLE(BundleTest
   )
 TARGET_LINK_LIBRARIES(BundleTest BundleTestLib)
 #
-# DO NOT: TARGET_LINK_LIBRARIES(BundleTest "-framework Carbon")
+# DO NOT: TARGET_LINK_LIBRARIES(BundleTest "-framework CoreFoundation")
-#   (see above comments about Carbon)
+#   (see above comments about CoreFoundation)
 #
 
 # Test bundle installation.

Tests/CFBundleTest/CMakeLists.txt

@@ -0,0 +1,56 @@
+#this is adapted from FireBreath (http://www.firebreath.org)
+
+cmake_minimum_required(VERSION 2.8)
+
+project(CFBundleTest)
+
+include(PluginConfig.cmake)
+
+message ("Creating Mac Browser Plugin project ${PROJECT_NAME}")
+set(SOURCES
+    np_macmain.cpp
+    Localized.r
+    ${CMAKE_CURRENT_BINARY_DIR}/Info.plist
+    ${CMAKE_CURRENT_BINARY_DIR}/InfoPlist.strings
+    ${CMAKE_CURRENT_BINARY_DIR}/Localized.rsrc
+)
+
+add_library( ${PROJECT_NAME} MODULE
+    ${SOURCES}
+    )
+
+set (RCFILES ${CMAKE_CURRENT_SOURCE_DIR}/Localized.r)
+
+configure_file(Info.plist.in ${CMAKE_CURRENT_BINARY_DIR}/Info.plist)
+configure_file(InfoPlist.strings.in ${CMAKE_CURRENT_BINARY_DIR}/InfoPlist.strings)
+
+# Compile the resource file
+find_program(RC_COMPILER Rez NO_DEFAULT_PATHS PATHS /Developer/Tools)
+if(NOT RC_COMPILER)
+  message(FATAL_ERROR "could not find Rez to build resources from .r file...")
+endif()
+
+execute_process(COMMAND
+    ${RC_COMPILER} ${RCFILES} -useDF -o ${CMAKE_CURRENT_BINARY_DIR}/Localized.rsrc
+    )
+
+set_source_files_properties(
+    ${CMAKE_CURRENT_BINARY_DIR}/Localized.rsrc
+    PROPERTIES GENERATED 1
+    )
+# note that for some reason, the makefile and xcode generators use a different
+# property to indicate where the Info.plist file is :-/ For that reason, we
+# specify it twice so it will work both places
+set_target_properties(CFBundleTest PROPERTIES
+    BUNDLE 1
+    BUNDLE_EXTENSION plugin
+    XCODE_ATTRIBUTE_WRAPPER_EXTENSION plugin  #sets the extension to .plugin
+    XCODE_ATTRIBUTE_MACH_O_TYPE mh_bundle
+    XCODE_ATTRIBUTE_INFOPLIST_FILE ${CMAKE_CURRENT_BINARY_DIR}/Info.plist
+    MACOSX_BUNDLE_INFO_PLIST ${CMAKE_CURRENT_BINARY_DIR}/Info.plist
+    LINK_FLAGS "-Wl,-exported_symbols_list,\"${CMAKE_CURRENT_SOURCE_DIR}/ExportList_plugin.txt\"")
+
+set_source_files_properties(
+    ${CMAKE_CURRENT_BINARY_DIR}/InfoPlist.strings
+    ${CMAKE_CURRENT_BINARY_DIR}/Localized.rsrc
+    PROPERTIES MACOSX_PACKAGE_LOCATION "Resources/English.lproj")

Tests/CFBundleTest/ExportList_plugin.txt

@@ -0,0 +1,3 @@
+_NP_GetEntryPoints
+_NP_Initialize
+_NP_Shutdown

Tests/CFBundleTest/Info.plist.in

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>CFBundleDevelopmentRegion</key>
+  <string>English</string>
+  <key>CFBundleExecutable</key>
+  <string>${PLUGIN_NAME}</string>
+  <key>CFBundleGetInfoString</key>
+    <string>${PLUGIN_NAME} ${FBSTRING_PLUGIN_VERSION}, ${FBSTRING_LegalCopyright}</string>
+  <key>CFBundleIdentifier</key>
+    <string>com.${ACTIVEX_PROGID}</string>
+  <key>CFBundleInfoDictionaryVersion</key>
+  <string>6.0</string>
+  <key>CFBundlePackageType</key>
+  <string>BRPL</string>
+  <key>CFBundleShortVersionString</key>
+    <string>${PLUGIN_NAME} ${FBSTRING_PLUGIN_VERSION}</string>
+  <key>CFBundleSignature</key>
+  <string>????</string>
+  <key>CFBundleVersion</key>
+    <string>${FBSTRING_PLUGIN_VERSION}</string>
+  <key>CFPlugInDynamicRegisterFunction</key>
+  <string></string>
+  <key>CFPlugInDynamicRegistration</key>
+  <string>NO</string>
+  <key>CFPlugInFactories</key>
+  <dict>
+    <key>00000000-0000-0000-0000-000000000000</key>
+    <string>MyFactoryFunction</string>
+  </dict>
+  <key>CFPlugInTypes</key>
+  <dict>
+    <key>00000000-0000-0000-0000-000000000000</key>
+    <array>
+      <string>00000000-0000-0000-0000-000000000000</string>
+    </array>
+  </dict>
+  <key>CFPlugInUnloadFunction</key>
+  <string></string>
+  <key>WebPluginName</key>
+  <string>${FBSTRING_ProductName}</string>
+  <key>WebPluginDescription</key>
+  <string>${FBSTRING_FileDescription}</string>
+  <key>WebPluginMIMETypes</key>
+  <dict>
+    <key>${FBSTRING_MIMEType}</key>
+    <dict>
+      <key>WebPluginTypeDescription</key>
+      <string>${FBSTRING_FileDescription}</string>
+    </dict>
+  </dict>
+</dict>
+</plist>

Tests/CFBundleTest/InfoPlist.strings.in

@@ -0,0 +1,4 @@
+/* Localized versions of Info.plist keys */
+
+CFBundleName = "${PLUGIN_NAME}.plugin";
+NSHumanReadableCopyright = "${FBSTRING_LegalCopyright}";

Tests/CFBundleTest/Localized.r

@@ -0,0 +1,18 @@
+#include <CoreServices/CoreServices.r>
+
+resource 'STR#' (126)
+{ {
+    "${FBSTRING_LegalCopyright}",
+    "${FBSTRING_ProductName}"
+} };
+
+resource 'STR#' (127)
+{ {
+    "${FBSTRING_FileDescription}"
+} };
+
+resource 'STR#' (128)
+{ {
+    "${FBSTRING_MIMEType}",
+    "${FBSTRING_FileExtents}"
+} };

Tests/CFBundleTest/PluginConfig.cmake

@@ -0,0 +1,21 @@
+#/**********************************************************\
+# Auto-Generated Plugin Configuration file
+# for CFTestPlugin
+#\**********************************************************/
+
+set(PLUGIN_NAME "CFTestPlugin")
+set(PLUGIN_PREFIX "CFTP")
+set(COMPANY_NAME "FBDevTeam")
+
+set(MOZILLA_PLUGINID "@firebreath.googlecode.com/CFTestPlugin")
+
+# strings
+set(FBSTRING_CompanyName "Firebreath Dev Team")
+set(FBSTRING_FileDescription "CFBundle Test Plugin - Plugin for testing cmake patch to improve FireBreath project generation")
+set(FBSTRING_PLUGIN_VERSION "1.0.0")
+set(FBSTRING_LegalCopyright "Copyright 2010 Firebreath Dev Team")
+set(FBSTRING_PluginFileName "np${PLUGIN_NAME}.dll")
+set(FBSTRING_ProductName "CFTestPlugin")
+set(FBSTRING_FileExtents "")
+set(FBSTRING_PluginName "CFTestPlugin")
+set(FBSTRING_MIMEType "application/x-fbtestplugin")

Tests/CFBundleTest/README.txt

@@ -0,0 +1,16 @@
+
+CFBundle test project.  The generated .plugin/ bundle from either makefiles or XCode should look like this:
+
+./Contents
+./Contents/Info.plist
+./Contents/MacOS
+./Contents/MacOS/CFBundleTest
+./Contents/Resources
+./Contents/Resources/English.lproj
+./Contents/Resources/English.lproj/InfoPlist.strings
+./Contents/Resources/English.lproj/Localized.rsrc
+
+file Contents/MacOS/CFBundleTest should return something like:
+Contents/MacOS/CFBundleTest: Mach-O 64-bit bundle x86_64
+
+It is okay if it is a 32 bit binary; if it is not Mach-O, or is spelled differently, it is not okay.

Tests/CFBundleTest/VerifyResult.cmake

@@ -0,0 +1,32 @@
+if(NOT DEFINED CTEST_CONFIGURATION_TYPE)
+  message(FATAL_ERROR "expected variable CTEST_CONFIGURATION_TYPE not defined")
+endif()
+
+if(NOT DEFINED dir)
+  message(FATAL_ERROR "expected variable dir not defined")
+endif()
+
+if(NOT DEFINED gen)
+  message(FATAL_ERROR "expected variable gen not defined")
+endif()
+
+message(STATUS "CTEST_CONFIGURATION_TYPE='${CTEST_CONFIGURATION_TYPE}'")
+message(STATUS "dir='${dir}'")
+message(STATUS "gen='${gen}'")
+
+if(gen MATCHES "Make" OR
+   "${CTEST_CONFIGURATION_TYPE}" STREQUAL "" OR
+   "${CTEST_CONFIGURATION_TYPE}" STREQUAL "." OR
+   "${CTEST_CONFIGURATION_TYPE}" STREQUAL "NoConfig")
+  set(expected_filename "${dir}/CFBundleTest.plugin/Contents/MacOS/CFBundleTest")
+else()
+  set(expected_filename "${dir}/${CTEST_CONFIGURATION_TYPE}/CFBundleTest.plugin/Contents/MacOS/CFBundleTest")
+endif()
+
+if(NOT EXISTS "${expected_filename}")
+  message(FATAL_ERROR "test fails: expected output file does not exist [${expected_filename}]")
+endif()
+
+file(COPY "${expected_filename}"
+  DESTINATION "${dir}/LatestBuildResult"
+  )

Tests/CFBundleTest/np_macmain.cpp

@@ -0,0 +1,49 @@
+/***********************************************************\
+  Written by: Richard Bateman (taxilian)
+
+  Based on the default np_macmain.cpp from FireBreath
+  http://firebreath.googlecode.com
+
+  This file has been stripped to prevent it from accidently
+  doing anything useful.
+\***********************************************************/
+
+
+#include <stdio.h>
+
+typedef void (*NPP_ShutdownProcPtr)(void);
+typedef short NPError;
+
+#pragma GCC visibility push(default)
+
+struct NPNetscapeFuncs;
+struct NPPluginFuncs;
+
+extern "C" {
+    NPError NP_Initialize(NPNetscapeFuncs *browserFuncs);
+    NPError NP_GetEntryPoints(NPPluginFuncs *pluginFuncs);
+    NPError NP_Shutdown(void);
+}
+
+#pragma GCC visibility pop
+
+void initPluginModule()
+{
+}
+
+NPError NP_GetEntryPoints(NPPluginFuncs* pFuncs)
+{
+    printf("NP_GetEntryPoints()\n");
+    return 0;
+}
+
+NPError NP_Initialize(NPNetscapeFuncs* pFuncs)
+{
+    printf("NP_Initialize()\n");
+    return 0;
+}
+
+NPError NP_Shutdown()
+{
+    return 0;
+}

Tests/CMakeLists.txt

@@ -563,30 +563,40 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
 
   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")
+    # set up list of CPack generators
-
+    list(APPEND GENLST "ZIP")
-    ADD_TEST(CPackComponentsForAll-ZIP-default ${CMAKE_CTEST_COMMAND}
+    # set up list of component packaging ways
-      --build-and-test
+    list(APPEND CWAYLST "default")
-      "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
+    list(APPEND CWAYLST "OnePackPerGroup")
-      "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/buildZIP-NoComponent"
+    list(APPEND CWAYLST "IgnoreGroup")
-      --build-generator ${CMAKE_TEST_GENERATOR}
+    list(APPEND CWAYLST "AllInOne")
-      --build-project CPackComponentsForAll
+    list(APPEND CWAYLST "AllGroupsInOne")
-      --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
+    foreach(CPackGen ${GENLST})
-      --build-options
+      set(CPackRun_CPackGen  "-DCPackGen=${CPackGen}")
-        -DCPACK_BINARY_ZIP:BOOL=ON
+      foreach(CPackComponentWay ${CWAYLST})
-        ${CPackComponentsForAll_EXTRA_OPTIONS}
+        set(CPackRun_CPackComponentWay "-DCPackComponentWay=${CPackComponentWay}")
-        --graphviz=CPackComponentsForAll.dot
+        ADD_TEST(CPackComponentsForAll-${CPackGen}-${CPackComponentWay} ${CMAKE_CTEST_COMMAND}
-      --test-command ${CMAKE_CMAKE_COMMAND}
+          --build-and-test
-        "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/buildZIP-NoComponent"
+          "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll"
-        "${CPackRun_CPackCommand}"
+          "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
-        "${CPackRun_CPackGen}"
+          --build-generator ${CMAKE_TEST_GENERATOR}
-        "${CPackRun_CPackComponentWay}"
+          --build-project CPackComponentsForAll
-        -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
+          --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
-
+          --build-options
-    LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll")
+             -DCPACK_BINARY_${CPackGen}:BOOL=ON
+             ${CPackRun_CPackComponentWay}
+             ${CPackComponentsForAll_EXTRA_OPTIONS}
+             --graphviz=CPackComponentsForAll.dot
+          --test-command ${CMAKE_CMAKE_COMMAND}
+            "-DCPackComponentsForAll_BINARY_DIR:PATH=${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}"
+            "${CPackRun_CPackCommand}"
+            "${CPackRun_CPackGen}"
+            "${CPackRun_CPackComponentWay}"
+            -P "${CMake_SOURCE_DIR}/Tests/CPackComponentsForAll/RunCPackVerifyResult.cmake")
+        LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CPackComponentsForAll/build${CPackGen}-${CPackComponentWay}")
+      endforeach(CPackComponentWay)
+    endforeach(CPackGen)
   ENDIF(CTEST_RUN_CPackComponentsForAll)
 
   # By default, turn this test off (because it takes a long time...)
@@ -805,11 +815,8 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
     --test-command ${CMAKE_CTEST_COMMAND} -V
     )
   LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/ExternalProject")
-  # The ExternalProject test takes 900 seconds on some machines!
+  SET_TESTS_PROPERTIES(ExternalProject PROPERTIES
-  GET_TEST_PROPERTY(ExternalProject TIMEOUT PREVIOUS_TIMEOUT)
+    TIMEOUT ${CMAKE_LONG_TEST_TIMEOUT})
-  IF("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
-    SET_TESTS_PROPERTIES(ExternalProject PROPERTIES TIMEOUT 1000)
-  ENDIF("${PREVIOUS_TIMEOUT}" MATCHES NOTFOUND)
 
   # do each of the tutorial steps
   FOREACH(STP RANGE 1 7)
@@ -1072,8 +1079,11 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
   IF(CMAKE_TEST_MSVC)
     ADD_TEST_MACRO(ForceInclude foo)
     ADD_TEST_MACRO(PrecompiledHeader foo)
+  ENDIF()
+  IF(CMAKE_TEST_MSVC OR
+      "${CMAKE_TEST_GENERATOR}" MATCHES "(MSYS|MinGW) Makefiles")
     ADD_TEST_MACRO(ModuleDefinition example_exe)
-  ENDIF(CMAKE_TEST_MSVC)
+  ENDIF()
 
   ADD_TEST_MACRO(CheckCompilerRelatedVariables CheckCompilerRelatedVariables)
 
@@ -1134,6 +1144,21 @@ ${CMake_BINARY_DIR}/bin/cmake -DVERSION=master -P ${CMake_SOURCE_DIR}/Utilities/
       ${BundleTestInstallDir}/Applications/SecondBundleExe.app/Contents/MacOS/SecondBundleExe)
     LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/BundleTest")
 
+    ADD_TEST(CFBundleTest ${CMAKE_CTEST_COMMAND}
+      --build-and-test
+      "${CMake_SOURCE_DIR}/Tests/CFBundleTest"
+      "${CMake_BINARY_DIR}/Tests/CFBundleTest"
+      --build-two-config
+      --build-generator ${CMAKE_TEST_GENERATOR}
+      --build-makeprogram ${CMAKE_TEST_MAKEPROGRAM}
+      --build-project CFBundleTest
+      --test-command
+      ${CMAKE_CMAKE_COMMAND} -DCTEST_CONFIGURATION_TYPE=\${CTEST_CONFIGURATION_TYPE}
+        -Ddir=${CMake_BINARY_DIR}/Tests/CFBundleTest
+        -Dgen=${CMAKE_TEST_GENERATOR}
+        -P ${CMake_SOURCE_DIR}/Tests/CFBundleTest/VerifyResult.cmake)
+    LIST(APPEND TEST_BUILD_DIRS "${CMake_BINARY_DIR}/Tests/CFBundleTest")
+
     ADD_TEST_MACRO(ObjC++ ObjC++)
   ENDIF (APPLE AND CMAKE_COMPILER_IS_GNUCXX)
 

Tests/CMakeTests/CMakeLists.txt

@@ -33,6 +33,8 @@ set_property(TEST CMake.FileDownload PROPERTY
   PASS_REGULAR_EXPRESSION "file already exists with expected MD5 sum"
   )
 
+AddCMakeTest(FileUpload "")
+
 if(HAVE_ELF_H)
   AddCMakeTest(ELF "")
 endif()

Tests/CMakeTests/FileDownloadTest.cmake.in

@@ -37,5 +37,7 @@ file(DOWNLOAD
   ${url}
   ${dir}/file3.png
   TIMEOUT 2
+  STATUS status
   EXPECTED_MD5 d16778650db435bda3a8c3435c3ff5d1
   )
+message(STATUS "${status}")

Tests/CMakeTests/FileTest.cmake.in

@@ -27,7 +27,7 @@ check_cmake_test(File
 # Also execute each test listed in FileTestScript.cmake:
 #
 set(scriptname "@CMAKE_CURRENT_SOURCE_DIR@/FileTestScript.cmake")
-set(number_of_tests_expected 56)
+set(number_of_tests_expected 62)
 
 include("@CMAKE_CURRENT_SOURCE_DIR@/ExecuteScriptTests.cmake")
 execute_all_script_tests(${scriptname} number_of_tests_executed)

Tests/CMakeTests/FileTestScript.cmake

@@ -201,6 +201,26 @@ elseif(testname STREQUAL download_with_bogus_protocol) # pass
   message("l='${l}'")
   message("s='${s}'")
 
+elseif(testname STREQUAL upload_wrong_number_of_args) # fail
+  file(UPLOAD ./ffff)
+
+elseif(testname STREQUAL upload_missing_time) # fail
+  file(UPLOAD ./ffff zzzz://bogus/ffff TIMEOUT)
+
+elseif(testname STREQUAL upload_missing_log_var) # fail
+  file(UPLOAD ./ffff zzzz://bogus/ffff TIMEOUT 2 LOG)
+
+elseif(testname STREQUAL upload_missing_status_var) # fail
+  file(UPLOAD ./ffff zzzz://bogus/ffff TIMEOUT 2 LOG l STATUS)
+
+elseif(testname STREQUAL upload_file_that_doesnt_exist) # fail
+  file(UPLOAD ./ffff zzzz://bogus/ffff)
+
+elseif(testname STREQUAL upload_with_bogus_protocol) # pass
+  file(UPLOAD ${CMAKE_CURRENT_LIST_FILE} zzzz://bogus/ffff TIMEOUT 2 LOG l STATUS s)
+  message("l='${l}'")
+  message("s='${s}'")
+
 else() # fail
   message(FATAL_ERROR "testname='${testname}' - error: no such test in '${CMAKE_CURRENT_LIST_FILE}'")
 

Tests/CMakeTests/FileUploadTest.cmake.in

@@ -0,0 +1,49 @@
+file(REMOVE_RECURSE "@CMAKE_CURRENT_BINARY_DIR@/uploads")
+
+if(EXISTS "@CMAKE_CURRENT_BINARY_DIR@/uploads/file1.png")
+  message(FATAL_ERROR "error: file1.png exists - should have been deleted")
+endif()
+if(EXISTS "@CMAKE_CURRENT_BINARY_DIR@/uploads/file2.png")
+  message(FATAL_ERROR "error: file2.png exists - should have been deleted")
+endif()
+
+file(MAKE_DIRECTORY "@CMAKE_CURRENT_BINARY_DIR@/uploads")
+
+set(filename "@CMAKE_CURRENT_SOURCE_DIR@/FileDownloadInput.png")
+set(urlbase "file://@CMAKE_CURRENT_BINARY_DIR@/uploads")
+
+message(STATUS "FileUpload:1")
+file(UPLOAD
+  ${filename}
+  ${urlbase}/file1.png
+  TIMEOUT 2
+  )
+
+message(STATUS "FileUpload:2")
+file(UPLOAD
+  ${filename}
+  ${urlbase}/file2.png
+  STATUS status
+  LOG log
+  SHOW_PROGRESS
+  )
+
+execute_process(COMMAND ${CMAKE_COMMAND} -E md5sum
+  "@CMAKE_CURRENT_BINARY_DIR@/uploads/file1.png"
+  OUTPUT_VARIABLE sum1
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+if(NOT sum1 MATCHES "^d16778650db435bda3a8c3435c3ff5d1  .*/uploads/file1.png$")
+  message(FATAL_ERROR "file1.png did not upload correctly (sum1='${sum1}')")
+endif()
+
+execute_process(COMMAND ${CMAKE_COMMAND} -E md5sum
+  "@CMAKE_CURRENT_BINARY_DIR@/uploads/file2.png"
+  OUTPUT_VARIABLE sum2
+  OUTPUT_STRIP_TRAILING_WHITESPACE)
+if(NOT sum2 MATCHES "^d16778650db435bda3a8c3435c3ff5d1  .*/uploads/file2.png$")
+  message(FATAL_ERROR "file2.png did not upload correctly (sum2='${sum2}')")
+endif()
+
+message(STATUS "log='${log}'")
+message(STATUS "status='${status}'")
+message(STATUS "DONE")

Tests/CMakeTests/StringTest.cmake.in

@@ -1,7 +1,7 @@
 # Execute each test listed in StringTestScript.cmake:
 #
 set(scriptname "@CMAKE_CURRENT_SOURCE_DIR@/StringTestScript.cmake")
-set(number_of_tests_expected 52)
+set(number_of_tests_expected 69)
 
 include("@CMAKE_CURRENT_SOURCE_DIR@/ExecuteScriptTests.cmake")
 execute_all_script_tests(${scriptname} number_of_tests_executed)

Tests/CMakeTests/StringTestScript.cmake

@@ -194,6 +194,85 @@ elseif(testname STREQUAL random_with_various_alphabets) # pass
   string(RANDOM LENGTH 78 ALPHABET "~`!@#$%^&*()_-+={}[]\\|:\\;'\",.<>/?" v)
   message(STATUS "v='${v}'")
 
+  message(STATUS "CMAKE_SCRIPT_MODE_FILE='${CMAKE_SCRIPT_MODE_FILE}'")
+
+elseif(testname STREQUAL string_find_with_no_parameter) # fail
+  string(FIND)
+
+elseif(testname STREQUAL string_find_with_one_parameter) # fail
+  string(FIND "CMake is great.")
+
+elseif(testname STREQUAL string_find_with_two_parameters) # fail
+  string(FIND "CMake is great." "a")
+
+elseif(testname STREQUAL string_find_with_three_parameters) # pass
+  string(FIND "CMake is great." "a" v)
+  message(STATUS "v='${v}'")
+
+elseif(testname STREQUAL string_find_with_four_parameters) # fail
+  string(FIND "CMake is great." "a" v v2)
+
+elseif(testname STREQUAL string_find_reverse_with_no_parameter) # fail
+  string(FIND REVERSE)
+
+elseif(testname STREQUAL string_find_reverse_with_one_parameter) # fail
+  string(FIND "CMake is great." REVERSE)
+
+elseif(testname STREQUAL string_find_reverse_with_two_parameters) # fail
+  string(FIND "CMake is great." "a" REVERSE)
+
+elseif(testname STREQUAL string_find_reverse_with_three_parameters) # pass
+  string(FIND "CMake is great." "a" v REVERSE)
+  message(STATUS "v='${v}'")
+
+elseif(testname STREQUAL string_find_reverse_with_four_parameters_part1) # fail
+  string(FIND "CMake is great." "a" v v2 REVERSE)
+
+elseif(testname STREQUAL string_find_reverse_with_four_parameters_part2) # fail
+  string(FIND "CMake is great." "a" v REVERSE v2)
+
+elseif(testname STREQUAL string_find_with_no_possible_result) # pass
+  string(FIND "CMake is a great application." "z" v)
+  message(STATUS "v='${v}'")
+  if(NOT(-1 EQUAL ${v}))
+    message(SEND_ERROR "FIND sub-command should return -1 but returned ${v}.")
+  endif(NOT(-1 EQUAL ${v}))
+
+elseif(testname STREQUAL string_find_reverse_with_no_possible_result) # pass
+  string(FIND "CMake is a great application." "z" v REVERSE)
+  message(STATUS "v='${v}'")
+  if(NOT(-1 EQUAL ${v}))
+    message(SEND_ERROR "FIND REVERSE sub-command should return -1 but returned ${v}.")
+  endif(NOT(-1 EQUAL ${v}))
+
+elseif(testname STREQUAL string_find_with_required_result) # pass
+  string(FIND "CMake is a great application." "g" v)
+  message(STATUS "v='${v}'")
+  if(NOT(11 EQUAL ${v}))
+    message(SEND_ERROR "FIND sub-command should return 11 but returned ${v}.")
+  endif(NOT(11 EQUAL ${v}))
+
+elseif(testname STREQUAL string_find_reverse_with_required_result) # pass
+  string(FIND "CMake is a great application." "e" v REVERSE)
+  message(STATUS "v='${v}'")
+  if(NOT(13 EQUAL ${v}))
+    message(SEND_ERROR "FIND REVERSE sub-command should return 13 but returned ${v}.")
+  endif(NOT(13 EQUAL ${v}))
+
+elseif(testname STREQUAL string_find_word_reverse_with_required_result) # pass
+  string(FIND "The command should find REVERSE in this string. Or maybe this REVERSE?!" "REVERSE" v)
+  message(STATUS "v='${v}'")
+  if(NOT(24 EQUAL ${v}))
+    message(SEND_ERROR "FIND sub-command should return 24 but returned ${v}.")
+  endif(NOT(24 EQUAL ${v}))
+
+elseif(testname STREQUAL string_find_reverse_word_reverse_with_required_result) # pass
+  string(FIND "The command should find REVERSE in this string. Or maybe this REVERSE?!" "REVERSE" v REVERSE)
+  message(STATUS "v='${v}'")
+  if(NOT(62 EQUAL ${v}))
+    message(SEND_ERROR "FIND sub-command should return 62 but returned ${v}.")
+  endif(NOT(62 EQUAL ${v}))
+
 else() # fail
   message(FATAL_ERROR "testname='${testname}' - error: no such test in '${CMAKE_CURRENT_LIST_FILE}'")
 

Tests/CPackComponentsForAll/CMakeLists.txt

@@ -107,14 +107,14 @@ 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
+# to tailor CPack behavior on a CPack generator specific way
 # (Behavior would be different for RPM or TGZ or DEB ...)
-if (USE_CPACK_PROJECT_CONFIG)
+if (NOT ("${CPackComponentWay}" STREQUAL "default"))
   # Setup project specific CPack-time CPack Config file.
-  configure_file(${MyLib_SOURCE_DIR}/MyLibCPackConfig.cmake.in
+  configure_file(${CPackComponentsForAll_SOURCE_DIR}/MyLibCPackConfig-${CPackComponentWay}.cmake.in
-    ${MyLib_BINARY_DIR}/MyLibCPackConfig.cmake
+    ${CPackComponentsForAll_BINARY_DIR}/MyLibCPackConfig-${CPackComponentWay}.cmake
     @ONLY)
-  set(CPACK_PROJECT_CONFIG_FILE ${MyLib_BINARY_DIR}/MyLibCPackConfig.cmake)
+  set(CPACK_PROJECT_CONFIG_FILE ${CPackComponentsForAll_BINARY_DIR}/MyLibCPackConfig-${CPackComponentWay}.cmake)
-endif (USE_CPACK_PROJECT_CONFIG)
+endif (NOT ("${CPackComponentWay}" STREQUAL "default"))
 # Include CPack to introduce the appropriate targets
 include(CPack)

Tests/CPackComponentsForAll/MyLibCPackConfig-AllGroupsInOne.cmake.in

@@ -0,0 +1,18 @@
+#
+# Activate component packaging
+#
+if(CPACK_GENERATOR MATCHES "ZIP")
+   set(CPACK_ARCHIVE_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "ZIP")
+
+if(CPACK_GENERATOR MATCHES "RPM")
+   set(CPACK_RPM_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "RPM")
+
+#
+# Choose grouping way
+#
+set(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE 1)
+#set(CPACK_COMPONENTS_GROUPING)
+#set(CPACK_COMPONENTS_IGNORE_GROUPS 1)
+#set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE 1)

Tests/CPackComponentsForAll/MyLibCPackConfig-AllInOne.cmake.in

@@ -0,0 +1,18 @@
+#
+# Activate component packaging
+#
+if(CPACK_GENERATOR MATCHES "ZIP")
+   set(CPACK_ARCHIVE_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "ZIP")
+
+if(CPACK_GENERATOR MATCHES "RPM")
+   set(CPACK_RPM_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "RPM")
+
+#
+# Choose grouping way
+#
+#set(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE 1)
+#set(CPACK_COMPONENTS_GROUPING)
+#set(CPACK_COMPONENTS_IGNORE_GROUPS 1)
+set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE 1)

Tests/CPackComponentsForAll/MyLibCPackConfig-IgnoreGroup.cmake.in

@@ -0,0 +1,18 @@
+#
+# Activate component packaging
+#
+if(CPACK_GENERATOR MATCHES "ZIP")
+   set(CPACK_ARCHIVE_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "ZIP")
+
+if(CPACK_GENERATOR MATCHES "RPM")
+   set(CPACK_RPM_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "RPM")
+
+#
+# Choose grouping way
+#
+#set(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE)
+#set(CPACK_COMPONENTS_GROUPING)
+set(CPACK_COMPONENTS_IGNORE_GROUPS 1)
+#set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE 1)

Tests/CPackComponentsForAll/MyLibCPackConfig-OnePackPerGroup.cmake.in

@@ -0,0 +1,18 @@
+#
+# Activate component packaging
+#
+if(CPACK_GENERATOR MATCHES "ZIP")
+   set(CPACK_ARCHIVE_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "ZIP")
+
+if(CPACK_GENERATOR MATCHES "RPM")
+   set(CPACK_RPM_COMPONENT_INSTALL "ON")
+endif(CPACK_GENERATOR MATCHES "RPM")
+
+#
+# Choose grouping way
+#
+#set(CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE)
+#set(CPACK_COMPONENTS_GROUPING)
+#set(CPACK_COMPONENTS_IGNORE_GROUPS)
+#set(CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE)

Tests/CPackComponentsForAll/MyLibCPackConfig.cmake.in

@@ -1,7 +0,0 @@
-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

@@ -32,6 +32,34 @@ if(config_type)
   set(config_args -C ${config_type})
 endif()
 message(" ${config_args}")
+
+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")
+    if (${CPackComponentWay} STREQUAL "OnePackPerGroup")
+        set(expected_count 2)
+    endif (${CPackComponentWay} STREQUAL "OnePackPerGroup")
+    if (${CPackComponentWay} STREQUAL "IgnoreGroup")
+        set(expected_count 4)
+    endif (${CPackComponentWay} STREQUAL "IgnoreGroup")
+    if (${CPackComponentWay} STREQUAL "AllInOne")
+        set(expected_count 1)
+    endif (${CPackComponentWay} STREQUAL "AllInOne")
+    if (${CPackComponentWay} STREQUAL "AllGroupsInOne")
+        set(expected_count 1)
+    endif (${CPackComponentWay} STREQUAL "AllGroupsInOne")
+endif(CPackGen MATCHES "ZIP")
+
+# clean-up previously CPack generated files
+if(expected_file_mask)
+  file(GLOB expected_file "${expected_file_mask}")
+  if (expected_file)
+    file(REMOVE ${expected_file})
+  endif(expected_file)
+endif(expected_file_mask)
+
 execute_process(COMMAND ${CPackCommand} -G ${CPackGen} ${config_args}
     RESULT_VARIABLE CPack_result
     OUTPUT_VARIABLE CPack_output
@@ -44,13 +72,6 @@ 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