Merge branch 'dev/add_test-working-directory' into dev/strict-mode

Conflicts:
	Tests/CMakeLists.txt

CMakeLists.txt

@@ -418,7 +418,7 @@ ENDIF()
 # The CMake version number.
 SET(CMake_VERSION_MAJOR 2)
 SET(CMake_VERSION_MINOR 8)
-SET(CMake_VERSION_PATCH 2)
+SET(CMake_VERSION_PATCH 3)
 #SET(CMake_VERSION_TWEAK 0)
 #SET(CMake_VERSION_RC 1)
 

CTestCustom.cmake.in

@@ -24,6 +24,7 @@ SET(CTEST_CUSTOM_WARNING_EXCEPTION
   "is not used for resolving any symbol"
   "Clock skew detected"
   "remark\\(1209"
+  "remark: .*LOOP WAS VECTORIZED"
   "LINK : warning LNK4089: all references to.*ADVAPI32.dll.*discarded by /OPT:REF"
   "LINK : warning LNK4089: all references to.*USER32.dll.*discarded by /OPT:REF"
   "Warning: library was too large for page size.*"

ChangeLog.manual

@@ -1,3 +1,413 @@
+No changes in CMake 2.8.3 since 2.8.3-rc4.
+
+Changes in CMake 2.8.3-rc4 (since 2.8.3-rc3)
+--------------------------------------------
+Bill Hoffman (1):
+      When processing DartMeasurements use the tests working directory.
+
+David Cole (2):
+      ExternalProject: No svn --username if empty (#11173)
+      Avoid problem reading jni.h on Macs.
+
+David Partyka (5):
+      Fixed appending PATH to dumpbin tool from growing without bounds.
+      Switch to CMAKE_PATH when doing PATH comparisons on Windows.
+      Remove unecessary TO_CMAKE_PATH for gp_cmd_dir.
+      Append the gp_tool path to the system PATH using native slashes.
+      Fixes to GetPrerequisites for cygwin
+
+Eric NOULARD (1):
+      CPackDeb Added several optional debian binary package fields
+
+Marcus D. Hanwell (2):
+      ENH: Added case for Python 2.7.
+      Fixed parallel build for generators with EXTRA.
+
+Changes in CMake 2.8.3-rc3 (since 2.8.3-rc2)
+--------------------------------------------
+Alex Neundorf (4):
+      Remove trailing whitespace
+      Add automatic variable CMAKE_CURRENT_LIST_DIR(dir of CMAKE_CURRENT_LIST_FILE)
+      Use absolute path to FindPackageHandleStandardArgs.cmake everywhere
+      CodeBlocks Generator: Do not omit files in the project file listing.
+
+Brad King (4):
+      VS10: Order .vcxproj dependencies deterministically (#10502)
+      Document ENABLE_EXPORTS behavior on Mac (#11295)
+      FindHDF5: Fix typo in parallel-IO support check (#11291)
+      Xcode: Recognize .hh as C++ (#11307)
+
+Clinton Stimpson (1):
+      Find imports dir in Qt 4.7
+
+David Partyka (1):
+      Update module to locate newely released MS MPI HPC Pack R2.
+
+Philip Lowman (1):
+      Remove superfluous variable Boost_COMPAT_STATIC_RUNTIME.
+
+Rolf Eike Beer (2):
+      FindSubversion: Fix for German localized client (#11273)
+      FindSubversion: Use C locale to detect version (#11273)
+
+Changes in CMake 2.8.3-rc2 (since 2.8.3-rc1)
+--------------------------------------------
+Alex Neundorf (5):
+      APPEND and not-APPEND mode of feature_summary() were swapped
+      Set a default DESCRIPTION if none is given for ALL mode of feature_summary()
+      Close ENDFUNCTION() properly with the same name as FUNCTION()
+      Make cmake-gui remember whether the "Advanced" checkbox was checked or not
+      Also store the required version number in the details message.
+
+Ben Boeckel (3):
+      Add test that CMake errors with empty libs
+      Fix which string is checked for in the test
+      XCode generation should fail if lang isn't known
+
+Bill Hoffman (5):
+      Fix the name of the variable being tested.
+      Fix KWStyle line length issues.
+      Add a delay after untar on windows to make external project work on windows 7
+      Add a new line to the end of the generated main.cxx for the hpux compiler.
+      Fix for bug #11274, VS10 custom commands that create files in INTDIR fix.
+
+Brad King (12):
+      Evaluate <OBJECT_DIR> rule variable for executables
+      ccmake: Fix search with '/'
+      MinGW: Support long object file lists
+      Document IMPORTED_NO_SONAME target property
+      FindMPI: Recoginze -f flags from mpicc (#10771)
+      Add module-dir flag for Compaq Visual Fortran (#11248)
+      FindPythonInterp: Look for python2.7 interpreter
+      VS10: Use $(IntDir) for per-source output directory (#11270)
+      Reset platform/compiler info status for each language
+      Remove trailing whitespace from Xcode generator source
+      VS10: Skip targets with no linker language (#11230)
+      VS10: Encode custom command comments for echo (#11283)
+
+Clinton Stimpson (1):
+      Fix regression in cross-compile patches with finding Qt libs.
+
+David Cole (7):
+      Enable calling commands with : in argv[1] (#9963)
+      No extra spaces in CustomCommand test (#9963)
+      Avoid CustomCommand test failure on VS71 (#9963)
+      Update release scripts.
+      Avoid CustomCommand test failure on VS71 (#9963)
+      Honor MAKECOMMAND value saved in cache (#11026)
+      New USE_FOLDERS property OFF by default. (#3796)
+
+David Gobbi (1):
+      Set the module prefix, updated Windows suffix.
+
+Eric NOULARD (2):
+      InstallGen/CPack  fix handling absolute installed file regression
+      CPackRPM  Handle parenthesis in CPACK_SYSTEM_NAME (fix bug 10737)
+
+James Bigler (2):
+      Fix for bug 0011263.
+      Allow -g3 for CUDA v3.0+.
+
+Mikkel Krautz (2):
+      Xcode: Avoid trailing space in ARCHS list (#11244)
+      Xcode: Quote string values containing '$' (#11244)
+
+Philip Lowman (12):
+      FindBoost.cmake fixes for issues 11204 & 8529
+      FindBoost.cmake: Miscellaneous changes and refactoring
+      FindBoost.cmake: Add Boost_NO_SYSTEM_PATHS option
+      FindBoost.cmake: Fix compiling against a boost source tree
+      FindBoost.cmake: Fixes 11246
+      FindBoost.cmake: Fixes 11121
+      FindBoost.cmake: Fixes 10436
+      FindBoost.cmake: Implements 11160
+      Fix 11136: [patch] FindThreads.cmake documents the wrong variable
+      FindBoost.cmake: Fix library search path glitch introduced in earlier commit
+      FindFLEX.cmake: Fix issue 11249
+      Fixes issue 11279: CMakeDetermineVSServicePack support for VS10
+
+Yaakov Selkowitz (2):
+      FindFLTK*: Use Cygwin fltk on Cygwin (#11290)
+      Use 'uname -m' for processor on Cygwin (#10774)
+
+Changes in CMake 2.8.3-rc1 (since 2.8.2)
+----------------------------------------
+Alex Neundorf (39):
+      fix build on SUSE 11.2 in cmcurl due to ssize_t
+      -add an additional name for finding libtiff on Windows
+      -fix typo in docs of deprecated MacroAddFileDependencies.cmake
+      add 2nd, more powerful mode to find_package_handle_standard_args()
+      -fix indentation of the documentation
+      Add version checking support to FindFlex and FindPerlLibs
+      FindSquish doesn't detect the version, remove that from the documentation
+      Improved version checking for FindRuby using the new mode of FPHSA()
+      Improved version checking for FindJava using the new FPHSA() mode
+      Fix DETAILS string with version number in FHPSA()
+      Improved version checking for FindSubversion using the new mode of FPHSA()
+      Improved version checking for FindCUDA using the new mode of FPHSA
+      Use FPHSA() in FindSWIG, including version checking.
+      Change documentation of Subversion_FOUND and SUBVERSION_FOUND.
+      Add macro CMakeParseArguments() and use it in FPHSA()
+      Fix ZLIB version parsing if no TWEAK version exists
+      Fix EclipseCDT include path parsing with spaces (#10868)
+      Fix EclipseCDT parsing of builtin macros with spaces (#10868)
+      Remove trailing spaces
+      Detect a COMPILER_ID also for ASM.
+      Add timeout to execute_process() in CMAKE_DETERMINE_COMPILER_ID().
+      Fix parsing of builtin macros so Eclipse handles them properly (#10868)
+      Log the required package version and major improvement to FeatureSummary
+      Improve documentation.
+      Improve wording of the documentation.
+      Add macro ADD_FEATURE_INFO() and improve docs.
+      Remove trailing whitespace
+      Make target_link_libraries() complain if bad target name is used
+      Just warn in case of a bad target as only argument for t_l_l()
+      Remove trailing whitespace
+      New CMP0016 for deciding whether an unknown target in TLL() is an error.
+      Record all considered Config files and their versions.
+      Improve error message in Config-mode when no appropriate version was found
+      Replace the two vector<string,string> with one vector<struct{string,string}>
+      Small cleanup of FindPackageHandleStandardArgs.cmake
+      Don't create an empty element at the end of Foo_CONSIDERED_CONFIGS/VERSIONS
+      Add option CONFIG_MODE to FPHSA()
+      Improve version notice in the generated message
+      Improve wording of the error message of find_package() in config-mode
+
+Andrew Maclean (3):
+      Adding a FindPostgreSQL.cmake module
+      Forgot the copyright notice.
+      Changed ADDITIONAL_SEARCH_PATHS to PostgreSQL_ADDITIONAL_SEARCH_PATHS.
+
+Arjen Verweij (1):
+      Pass objects to Intel linker using a response file
+
+Bill Hoffman (9):
+      Disable gcc 33 on OpenBSD because it crashes CPack by default.
+      Fix for bug#10483, INCLUDE_EXTERNAL_MSPROJECT: ProjectGUID now ProjectGuid
+      Remove the ctest submit larget output test.
+      Let CMake recognize .CPP .CXX and .C++ as c++ files.
+      Fix for bug 10388, fix various default flags.
+      Only use .CPP .CXX and .C++ do not work by default with g+++.
+      Fix targets with . in the name for VS 10 IDE.
+      Only test for .CPP on Microsoft compilers which will handle .CPP as c++.
+      Allow testing of .CPP on WIN32 as it is a case insensitive OS and should work.
+
+Brad King (69):
+      ExternalProject: Add LOG_* options to hide step output
+      FindMPI: Do not parse -l in middle of library name
+      FindMPI: Parse mpicc flags more carefully (#9093)
+      Fix or cast integer conversions in cmake
+      Begin post-2.8.2 development
+      FindMPI: Failure is not an error if not REQUIRED
+      FindMPI: Trust mpicc -showme on BlueGene/L
+      VS: Always separate preprocessor defs by semicolon (#10902)
+      KWSys: Cleanup putenv leak option implementation
+      KWSys: Pass ptrdiff_t check result to System.c
+      Fix or cast more integer conversions in cmake
+      Use same type in both cases of '?:' operator
+      FindMPI: Fix parsing of mpicc -Wl,-L link flags (#9093)
+      Fix signed/unsigned comparison warnings in ccmake
+      Fix integer conversions in cpack
+      bootstrap: Detect known C/C++ compiler toolchains
+      KWSys: Use short fallback timeout for Process tests
+      KWSys: Optionally suppress consistent test failures
+      KWSys: Avoid Clang optimizer bug in testProcess-[45]
+      Poison GCC 3.3 on OpenBSD a bit later
+      KWSys: Avoid undefined behavior in Process crash tests
+      Optionally use system bzip2 library (#10932)
+      ctest_update: Abort if Git FETCH_HEAD has no candidates
+      ctest_update: Support ".git file" work trees
+      ctest_update: Run 'git submodule' at top level
+      FindBoost: Search for Boost 1.42
+      Add FindLibArchive module (#10923)
+      Add option CMAKE_USE_SYSTEM_LIBARCHIVE (#10923)
+      Refer to self with CMake_(SOURCE|BINARY)_DIR (#10046)
+      ExternalProject: Fix $(MAKE) with cygpath on Windows
+      FindBoost: Search for Boost 1.43 and 1.44
+      Include headers from chosen libarchive (#10923)
+      No response files with GNU ld <= 2.16 (#10913)
+      Create class cmArchiveWrite to wrap libarchive (#11020)
+      Include entries for directories in tarballs (#11020)
+      cmArchiveWrite: Fix signed/unsigned compare/convert
+      cmArchiveWrite: Fix signed/unsigned again
+      CPack: Avoid member shadowing after API refactor
+      KWSys: Fix SplitPath for leading '\' on Windows
+      KWSys: Fix GetActualCaseForPath for UNC paths
+      ModuleNoticesTest: Do not require "Kitware" copyright
+      Modules: Fix CMakeParseArguments copyright notice
+      FortranCInterface: Fix doc typo FC.h -> FCMangle.h
+      CTest: Avoid use of old EscapeSpaces method
+      Remove cmSystemTools::EscapeSpaces method
+      Clarify install(TARGETS) docs for EXPORT option
+      Factor out global generator ComputeTargetDepends method
+      Factor out duplicate VS target dependency code
+      Refactor VS <= 7.1 utility-depends workaround
+      Restore GetTargetDirectDepends const return
+      Split notion of node lists and edge lists
+      Distinguish "strong" and "weak" target dependency edges
+      Honor strong intra-component target dependencies
+      libarchive: Remove SCHILY dev,ino,nlink attributes (#11176)
+      Fix unused parameter warning in VS 7.1 generator
+      KWSys: Avoid empty string dereference in SplitString
+      KWSys: Improve SplitPath method documentation
+      KWSys: Use SplitPath in GetActualCaseForPath
+      Add whitespace=tab-in-indent attribute for sources
+      Search MacPorts /opt/local prefix on Mac
+      HP-UX: Always add /usr/lib to rpath (#10571)
+      No CMAKE_CONFIGURATION_TYPES in single-config generators (#10202)
+      KWSys: Suppress -Wcast-align warning in MD5.c
+      Suppress -Wcast-align in curl and bzip2
+      libarchive: Fix purposeful crash
+      bootstrap: Honor CFLAGS during "make" test (#10545)
+      file(DOWNLOAD): Fix error message formatting
+      Fix line-too-long style errors
+      Report missing source files with context of target
+
+Clinton Stimpson (10):
+      Fix performance issue with getting version from zlib.h
+      Fix bug 10418 - GetPrerequisites returning "not" as a dependency.
+      Fix regression in 5e6634fd77969433a87c150a2fb3f2079131484f for Windows.
+      Change Qt4ConfigDependentSettings to use more standard find modules.
+      Add cross-compiling support to FindQt4.cmake
+      Tweak for cygwin, don't convert : to ;
+      Fix some issues with refinding when qmake executable is changed.
+      Find correct Qt plugins for cross-compiling.
+      Fix mingw/VS warning message with cross compile re-org.
+      Make sure moc parameters file goes in binary directory.
+
+David Cole (20):
+      CheckSourceTree test: read UpdateCommand from Update.xml.
+      Eliminate -Wconversion warnings.
+      Detect CMake warnings and errors in build output.
+      Activate retry code on any curl submit failure.
+      Add another expected output for the failed submit tests.
+      ExternalProject: Use $(MAKE) whenever possible.
+      Copy Resources in Frameworks during fixup_bundle (#10020)
+      Update path to git. dashmacmini2 was "upgraded."
+      ExternalProject: Remove 'unknown keyword' warning (#11034)
+      Add documentation for CPACK_PROJECT_CONFIG_FILE.
+      Add STEP_TARGETS to ExternalProject module.
+      Refine formatting for cmake --help-module output.
+      Improve documentation of OPTION command.
+      Add FOLDER target property, for IDEs (#3796)
+      Avoid adding self as prerequisite. (#10417)
+      Correct CMAKE_INSTALL_PREFIX value for Win64 apps (#9992)
+      Preserve timestamps on files on tar extract.
+      Use QUIET to avoid Java status messages.
+      VS2010: Honor PROJECT_LABEL target property (#10611)
+      VS2010: Set IntDir for utility and global targets.
+
+David Genest (1):
+      Honor CMAKE_USER_MAKE_RULES_OVERRIDE in try_compile (#10902)
+
+Eric NOULARD (20):
+      CPackRPM:: Replace - with _ in RPM Version (fix bug 0010934)
+      Provides default changelog if no file is provided
+      CPackRPM:: Quote every filenames in %file section (see bugs 10701,10871,10345)
+      CPackRPM:: [partially] support relocatable package
+      CPackDEB:  merge wrong installed size patch. see bugs 10296 (and 10292)
+      CPackDeb  optionally generates auto-dependency list part fix of bug 10292
+      Proposal for bash-completion support file
+      CPack: Refactor API in order to handle multi-file packages
+      CPack: Avoid member shadowing after API refactor (part2)
+      Improve cmake-completion (install doc, ctest -R completion)
+      Add ZIP archive format and LZMA compress support to libarchive-wrapper
+      Add XZ compress support to libarchive-wrapper
+      Add Compress compress support to libarchive-wrapper
+      CPack   Backward-compatibly enforce DESTDIR for DEB and RPM
+      CPack   Enable better handling of absolute installed files
+      CPackArchiveGenerator  use cmArchiveWrite wrapper
+      CPackArchiveGenerator  add component supports
+      CPackArchiveGenerator improve usability and robustness
+      CPack fix broken compilation for CygwinSource generator
+      CPack  handle symlinks in CPACK_INSTALLED_DIRECTORIES fix for bug5430
+
+James Bigler (1):
+      Added CUDA 3.2 directory changes.  Disable emulation mode for CUDA 3.1+.
+
+Kai Wasserbäch (1):
+      Fix spelling errors reported by Lintian.
+
+Kovarththanan Rajaratnam (4):
+      FindZLIB: optimize zlib.h version parsing
+      FindCygwin: add new registry entry for Cygwin 1.7 (#10951)
+      FindZLIB: use the FPHSA version mode
+      FindSubversion: set compatibility variables based on FPHSA()
+
+Marcel Loose (1):
+      Issue 10199: Fixed code documentation and now set <prefix>_WC_ROOT
+
+Marcus D. Hanwell (1):
+      Bug with default library type of Python modules.
+
+Mathieu Malaterre (3):
+      Add missing PATHS to find_path commands to fix openssl searching
+      BUG: 0009611 Fix Arch independent FindJNI.cmake on Linux
+      Fix 11035 : debug/release library configuration mistake
+
+Michael Wild (2):
+      Improve documentation of BundleUtilities.cmake
+      Improve documentation of GetPrerequisites.cmake
+
+Miguel A. Figueroa-Villanueva (7):
+      ENH: #9775 Added support for new wxWidgets 2.9 libraries.
+      BUG: #9775 Fixed patch FindwxWidgets-fixed-bug-9775.
+      BUG #10658: FindwxWidgets USE_FILE should not include .cmake extension.
+      STYLE: Clarified/Fixed documentation of UsewxWidgets.
+      BUG #11123: Generic include dir should come after config specific one.
+      BUG #8184: Fixed FindwxWidgets wrong order of default libs for MinGW.
+      ENH #8993: FindwxWidgets add support for wx-config custom options.
+
+Mike McQuaid (1):
+      Make bundle items writable before fixup (#9284)
+
+Modestas Vainius (1):
+      CTestTestFailedSubmit-xmlrpc: Pass with "Submission problem"
+
+Patrick Gansterer (4):
+      VS: Convert PlatformName member to a virtual method
+      VS: Add more TargetMachine option values
+      VS: Map /ENTRY linker option to EntryPointSymbol
+      VS: Add ArchitectureId to VS 8 and 9 generators
+
+Philip Lowman (7):
+      Fixes problem finding libraries under Boost (#9510)
+      Add detection for new pangommconfig.h header file
+      Several fixes needed to improve Windows support
+      11041: Improve FindCxxTest to use Python or Perl automatically; custom flags
+      10241: FindBISON.cmake clears wrong variable
+      10688: FindGTK2.cmake doesn't auto-detect macports
+      Merge patch for detecting gdk-pixbuf library
+
+Pino Toscano (1):
+      GNU/Hurd platform support fixes (#9873)
+
+Robert Goulet (1):
+      VS2010: Disable PDBs when there is no debug info
+
+Rolf Eike Beer (2):
+      clean up some stuff in CPack RPM script
+      Set MSVC_VERSION for MSVC 6, 7, 7.1 (#7944)
+
+Todd Gamblin (3):
+      Modules: Fix spelling 'To distributed' -> 'To distribute'
+      Teach find_* commands to ignore some paths
+      Add platform files for BlueGene/P systems
+
+Zach Mullen (12):
+      Checksums on CTest submit files, and retry timed out submissions.
+      Cross-platform fixes for checksum/retry code
+      Fix subscript out of range crash
+      CTest should resubmit in the checksum failed case
+      Testing for CTest checksum
+      Mock checksum failure output for old CDash versions
+      Checksum test should use CMAKE_TESTS_CDASH_SERVER
+      Fix cycle detection for test dependencies
+      More robust cost-based scheduling impl
+      Fix hard-coded CDash URI in version query
+      Added CTest command --print-labels
+      We shouldn't ask CDash for its version info until/unless we actually need it.
+
 No changes in CMake 2.8.2 since 2.8.2-rc4.
 
 Changes in CMake 2.8.2-rc4 (since 2.8.2-rc3)

Docs/cmake-help.vim

@@ -0,0 +1,21 @@
+nmap ,hc :call OpenCmakeHelp()<CR>
+
+function! OpenCmakeHelp()
+    let s = getline( '.' )
+    let i = col( '.' ) - 1
+    while i > 0 && strpart( s, i, 1 ) =~ '[A-Za-z0-9_]'
+        let i = i - 1
+    endwhile
+    while i < col('$') && strpart( s, i, 1 ) !~ '[A-Za-z0-9_]'
+        let i = i + 1
+    endwhile
+    let start = match( s, '[A-Za-z0-9_]\+', i )
+    let end = matchend( s, '[A-Za-z0-9_]\+', i )
+    let ident = strpart( s, start, end - start )
+    execute "vertical new"
+    execute "%!cmake --help-command ".ident
+    set nomodified
+    set readonly
+endfunction
+
+autocmd BufRead,BufNewFile *.cmake,CMakeLists.txt,*.cmake.in nmap <F1> :call OpenCmakeHelp()<CR>

Modules/BundleUtilities.cmake

@@ -27,6 +27,11 @@
 # drag-n-drop copied to another machine and run on that machine as long as all
 # of the system libraries are compatible.
 #
+# If you pass plugins to fixup_bundle as the libs parameter, you should install
+# them or copy them into the bundle before calling fixup_bundle. The "libs"
+# parameter is a list of libraries that must be fixed up, but that cannot be
+# determined by otool output analysis. (i.e., plugins)
+#
 # Gather all the keys for all the executables and libraries in a bundle, and
 # then, for each key, copy each prerequisite into the bundle. Then fix each one
 # up according to its own list of prerequisites.
@@ -112,6 +117,13 @@
 # _EMBEDDED_ITEM keyed variable for that prerequisite. (Most likely changing to
 # an "@executable_path" style reference.)
 #
+# This function requires that the resolved_embedded_item be "inside" the bundle
+# already. In other words, if you pass plugins to fixup_bundle as the libs
+# parameter, you should install them or copy them into the bundle before
+# calling fixup_bundle. The "libs" parameter is a list of libraries that must
+# be fixed up, but that cannot be determined by otool output analysis. (i.e.,
+# plugins)
+#
 # Also, change the id of the item being fixed up to its own _EMBEDDED_ITEM
 # value.
 #
@@ -472,11 +484,11 @@ function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item)
   else()
     #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}")
     execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
+    if(UNIX AND NOT APPLE)
+      file(RPATH_REMOVE FILE "${resolved_embedded_item}")
+    endif(UNIX AND NOT APPLE)
   endif()
 
-  if(UNIX AND NOT APPLE)
-    file(RPATH_REMOVE FILE "${resolved_embedded_item}")
-  endif(UNIX AND NOT APPLE)
 endfunction(copy_resolved_item_into_bundle)
 
 
@@ -514,11 +526,11 @@ function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_ite
         execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_resources}" "${resolved_embedded_resources}")
       endif()
     endif()
+    if(UNIX AND NOT APPLE)
+      file(RPATH_REMOVE FILE "${resolved_embedded_item}")
+    endif(UNIX AND NOT APPLE)
   endif()
 
-  if(UNIX AND NOT APPLE)
-    file(RPATH_REMOVE FILE "${resolved_embedded_item}")
-  endif(UNIX AND NOT APPLE)
 endfunction(copy_resolved_framework_into_bundle)
 
 
@@ -527,6 +539,24 @@ function(fixup_bundle_item resolved_embedded_item exepath dirs)
   #
   get_item_key("${resolved_embedded_item}" ikey)
 
+  # Ensure the item is "inside the .app bundle" -- it should not be fixed up if
+  # it is not in the .app bundle... Otherwise, we'll modify files in the build
+  # tree, or in other varied locations around the file system, with our call to
+  # install_name_tool. Make sure that doesn't happen here:
+  #
+  get_dotapp_dir("${exepath}" exe_dotapp_dir)
+  string(LENGTH "${exe_dotapp_dir}/" exe_dotapp_dir_length)
+  string(SUBSTRING "${resolved_embedded_item}" 0 ${exe_dotapp_dir_length} item_substring)
+  if(NOT "${exe_dotapp_dir}/" STREQUAL "${item_substring}")
+    message("  exe_dotapp_dir/='${exe_dotapp_dir}/'")
+    message("  item_substring='${item_substring}'")
+    message("  resolved_embedded_item='${resolved_embedded_item}'")
+    message("")
+    message("Install or copy the item into the bundle before calling fixup_bundle")
+    message("")
+    message(FATAL_ERROR "cannot fixup an item that is not in the bundle...")
+  endif()
+
   set(prereqs "")
   get_prerequisites("${resolved_embedded_item}" prereqs 1 0 "${exepath}" "${dirs}")
 

Modules/CMakeASM_NASMInformation.cmake

@@ -0,0 +1,46 @@
+
+#=============================================================================
+# Copyright 2010 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# support for the nasm assembler
+
+set(CMAKE_ASM_NASM_SOURCE_FILE_EXTENSIONS nasm asm)
+
+if(NOT CMAKE_ASM_NASM_OBJECT_FORMAT)
+  if(WIN32)
+    if(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
+      SET(CMAKE_ASM_NASM_OBJECT_FORMAT win64)
+    else()
+      SET(CMAKE_ASM_NASM_OBJECT_FORMAT win32)
+    endif()
+  elseif(APPLE)
+    if(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
+      SET(CMAKE_ASM_NASM_OBJECT_FORMAT macho64)
+    else()
+      SET(CMAKE_ASM_NASM_OBJECT_FORMAT macho)
+    endif()
+  else()
+    if(CMAKE_C_SIZEOF_DATA_PTR EQUAL 8)
+      SET(CMAKE_ASM_NASM_OBJECT_FORMAT elf64)
+    else()
+      SET(CMAKE_ASM_NASM_OBJECT_FORMAT elf)
+    endif()
+  endif()
+endif()
+
+set(CMAKE_ASM_NASM_COMPILE_OBJECT "<CMAKE_ASM_NASM_COMPILER> <FLAGS> -f ${CMAKE_ASM_NASM_OBJECT_FORMAT} -o <OBJECT> <SOURCE>")
+
+# Load the generic ASMInformation file:
+set(ASM_DIALECT "_NASM")
+include(CMakeASMInformation)
+set(ASM_DIALECT)

Modules/CMakeCCompilerId.c.in

@@ -42,6 +42,9 @@
 #elif defined(__PATHSCALE__)
 # define COMPILER_ID "PathScale"
 
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+
 #elif defined(__GNUC__)
 # define COMPILER_ID "GNU"
 

Modules/CMakeCXXCompilerId.cpp.in

@@ -44,6 +44,9 @@
 #elif defined(__PATHSCALE__)
 # define COMPILER_ID "PathScale"
 
+#elif defined(_CRAYC)
+# define COMPILER_ID "Cray"
+
 #elif defined(__GNUC__)
 # define COMPILER_ID "GNU"
 

Modules/CMakeDetermineASMCompiler.cmake

@@ -65,6 +65,7 @@ IF(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
   SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_GNU "--version")
   SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_GNU "GNU assembler")
 
+  INCLUDE(CMakeDetermineCompilerId)
   CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT})
 
   IF(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)

Modules/CMakeDetermineASM_NASMCompiler.cmake

@@ -0,0 +1,27 @@
+
+#=============================================================================
+# Copyright 2010 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# Find the nasm assembler. yasm (http://www.tortall.net/projects/yasm/) is nasm compatible
+
+SET(CMAKE_ASM_NASM_COMPILER_INIT nasm yasm)
+
+IF(NOT CMAKE_ASM_NASM_COMPILER)
+  FIND_PROGRAM(CMAKE_ASM_NASM_COMPILER nasm
+    "$ENV{ProgramFiles}/NASM")
+ENDIF(NOT CMAKE_ASM_NASM_COMPILER)
+
+# Load the generic DetermineASM compiler file with the DIALECT set properly:
+SET(ASM_DIALECT "_NASM")
+INCLUDE(CMakeDetermineASMCompiler)
+SET(ASM_DIALECT)

Modules/CMakeDetermineCompilerABI.cmake

@@ -78,7 +78,8 @@ FUNCTION(CMAKE_DETERMINE_COMPILER_ABI lang src)
           AND NOT MULTI_ARCH
           # Skip this with Xcode for now.
           AND NOT "${CMAKE_GENERATOR}" MATCHES Xcode)
-        CMAKE_PARSE_IMPLICIT_LINK_INFO("${OUTPUT}" implicit_libs implicit_dirs log)
+        CMAKE_PARSE_IMPLICIT_LINK_INFO("${OUTPUT}" implicit_libs implicit_dirs log
+          "${CMAKE_${lang}_IMPLICIT_OBJECT_REGEX}")
         FILE(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
           "Parsed ${lang} implicit link information from above output:\n${log}\n\n")
       ENDIF()

Modules/CMakeDetermineFortranCompiler.cmake

@@ -169,6 +169,9 @@ IF(NOT CMAKE_Fortran_COMPILER_ID_RUN)
   LIST(APPEND CMAKE_Fortran_COMPILER_ID_VENDORS Compaq)
   SET(CMAKE_Fortran_COMPILER_ID_VENDOR_FLAGS_Compaq "-what")
   SET(CMAKE_Fortran_COMPILER_ID_VENDOR_REGEX_Compaq "Compaq Visual Fortran")
+  LIST(APPEND CMAKE_Fortran_COMPILER_ID_VENDORS NAG) # Numerical Algorithms Group
+  SET(CMAKE_Fortran_COMPILER_ID_VENDOR_FLAGS_NAG "-V")
+  SET(CMAKE_Fortran_COMPILER_ID_VENDOR_REGEX_NAG "NAG Fortran Compiler")
 
   # Try to identify the compiler.
   SET(CMAKE_Fortran_COMPILER_ID)

Modules/CMakeFindEclipseCDT4.cmake

@@ -17,6 +17,12 @@
 
 FIND_PROGRAM(CMAKE_ECLIPSE_EXECUTABLE NAMES eclipse DOC "The Eclipse executable")
 
+# This variable is used by the Eclipse generator and appended to the make invocation commands.
+SET(CMAKE_ECLIPSE_MAKE_ARGUMENTS "" CACHE STRING "Additional command line arguments when Eclipse invokes make. Enter e.g. -j<some_number> to get parallel builds")
+
+# This variable is used by the Eclipse generator in out-of-source builds only.
+SET(ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT FALSE CACHE BOOL "If enabled, CMake will generate a source project for Eclipse in CMAKE_SOURCE_DIR")
+MARK_AS_ADVANCED(ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT)
 
 # The Eclipse generator needs to know the standard include path
 # so that Eclipse ca find the headers at runtime and parsing etc. works better

Modules/CMakeFortranCompilerId.F.in

@@ -6,6 +6,8 @@
         PRINT *, 'INFO:compiler[Intel]'
 #elif defined(__SUNPRO_F90) || defined(__SUNPRO_F95)
         PRINT *, 'INFO:compiler[SunPro]'
+#elif defined(_CRAYFTN)
+        PRINT *, 'INFO:compiler[Cray]'
 #elif defined(__G95__)
         PRINT *, 'INFO:compiler[G95]'
 #elif defined(__PATHSCALE__)

Modules/CMakeFortranInformation.cmake

@@ -67,29 +67,29 @@ SET(CMAKE_NEEDS_REQUIRES_STEP_Fortran_FLAG 1)
 # Create a set of shared library variable specific to Fortran
 # For 90% of the systems, these are the same flags as the C versions
 # so if these are not set just copy the flags from the c version
-IF(NOT CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS)
+IF(NOT DEFINED CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS)
   SET(CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS ${CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS)
+ENDIF()
 
-IF(NOT CMAKE_SHARED_LIBRARY_Fortran_FLAGS)
+IF(NOT DEFINED CMAKE_SHARED_LIBRARY_Fortran_FLAGS)
   SET(CMAKE_SHARED_LIBRARY_Fortran_FLAGS ${CMAKE_SHARED_LIBRARY_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_Fortran_FLAGS)
+ENDIF()
 
 IF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS)
   SET(CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS ${CMAKE_SHARED_LIBRARY_LINK_C_FLAGS})
-ENDIF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS)
+ENDIF()
 
-IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG)
+IF(NOT DEFINED CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG)
   SET(CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG}) 
-ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG)
+ENDIF()
 
-IF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP)
+IF(NOT DEFINED CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP)
   SET(CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_C_FLAG_SEP})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP)
+ENDIF()
 
-IF(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_Fortran_FLAG)
+IF(NOT DEFINED CMAKE_SHARED_LIBRARY_RPATH_LINK_Fortran_FLAG)
   SET(CMAKE_SHARED_LIBRARY_RPATH_LINK_Fortran_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_C_FLAG})
-ENDIF(NOT CMAKE_SHARED_LIBRARY_RPATH_LINK_Fortran_FLAG)
+ENDIF()
 
 IF(NOT DEFINED CMAKE_EXE_EXPORTS_Fortran_FLAG)
   SET(CMAKE_EXE_EXPORTS_Fortran_FLAG ${CMAKE_EXE_EXPORTS_C_FLAG})
@@ -100,25 +100,25 @@ IF(NOT DEFINED CMAKE_SHARED_LIBRARY_SONAME_Fortran_FLAG)
 ENDIF()
 
 # repeat for modules
-IF(NOT CMAKE_SHARED_MODULE_CREATE_Fortran_FLAGS)
+IF(NOT DEFINED CMAKE_SHARED_MODULE_CREATE_Fortran_FLAGS)
   SET(CMAKE_SHARED_MODULE_CREATE_Fortran_FLAGS ${CMAKE_SHARED_MODULE_CREATE_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_MODULE_CREATE_Fortran_FLAGS)
+ENDIF()
 
-IF(NOT CMAKE_SHARED_MODULE_Fortran_FLAGS)
+IF(NOT DEFINED CMAKE_SHARED_MODULE_Fortran_FLAGS)
   SET(CMAKE_SHARED_MODULE_Fortran_FLAGS ${CMAKE_SHARED_MODULE_C_FLAGS})
-ENDIF(NOT CMAKE_SHARED_MODULE_Fortran_FLAGS)
+ENDIF()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG)
+IF(NOT DEFINED CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG)
   SET(CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG ${CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG})
-ENDIF(NOT CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG)
+ENDIF()
 
-IF(NOT CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG_SEP)
+IF(NOT DEFINED CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG_SEP)
   SET(CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG_SEP ${CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP})
-ENDIF(NOT CMAKE_EXECUTABLE_RUNTIME_Fortran_FLAG_SEP)
+ENDIF()
 
-IF(NOT CMAKE_EXECUTABLE_RPATH_LINK_Fortran_FLAG)
+IF(NOT DEFINED CMAKE_EXECUTABLE_RPATH_LINK_Fortran_FLAG)
   SET(CMAKE_EXECUTABLE_RPATH_LINK_Fortran_FLAG ${CMAKE_SHARED_LIBRARY_RPATH_LINK_Fortran_FLAG})
-ENDIF(NOT CMAKE_EXECUTABLE_RPATH_LINK_Fortran_FLAG)
+ENDIF()
 
 IF(NOT DEFINED CMAKE_SHARED_LIBRARY_LINK_Fortran_WITH_RUNTIME_PATH)
   SET(CMAKE_SHARED_LIBRARY_LINK_Fortran_WITH_RUNTIME_PATH ${CMAKE_SHARED_LIBRARY_LINK_C_WITH_RUNTIME_PATH})

Modules/CMakeParseImplicitLinkInfo.cmake

@@ -16,7 +16,7 @@
 # This is used internally by CMake and should not be included by user
 # code.
 
-function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var log_var)
+function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var log_var obj_regex)
   set(implicit_libs_tmp "")
   set(implicit_dirs_tmp)
   set(log "")
@@ -59,6 +59,11 @@ function(CMAKE_PARSE_IMPLICIT_LINK_INFO text lib_var dir_var log_var)
           # Unix library full path.
           list(APPEND implicit_libs_tmp ${arg})
           set(log "${log}    arg [${arg}] ==> lib [${arg}]\n")
+        elseif("${arg}" MATCHES "^(.:)?[/\\].*\\.o$"
+            AND obj_regex AND "${arg}" MATCHES "${obj_regex}")
+          # Object file full path.
+          list(APPEND implicit_libs_tmp ${arg})
+          set(log "${log}    arg [${arg}] ==> obj [${arg}]\n")
         elseif("${arg}" MATCHES "^-Y(P,)?")
           # Sun search path.
           string(REGEX REPLACE "^-Y(P,)?" "" dirs "${arg}")

Modules/CMakePlatformId.h.in

@@ -83,7 +83,7 @@
 #endif
 
 /* For windows compilers MSVC and Intel we can determine
-   the architecture of the compiler being used.  This is becase
+   the architecture of the compiler being used.  This is because
    the compilers do not have flags that can change the architecture,
    but rather depend on which compiler is being used
 */

Modules/CMakeTestASM-ATTCompiler.cmake

@@ -13,10 +13,10 @@
 #  License text for the above reference.)
 
 # This file is used by EnableLanguage in cmGlobalGenerator to
-# determine that that selected ASM-ATT compiler can actually compile
-# and link the most basic of programs.   If not, a fatal error
-# is set and cmake stops processing commands and will not generate
-# any makefiles or projects.
+# determine that the selected ASM-ATT "compiler" works.
+# For assembler this can only check whether the compiler has been found,
+# because otherwise there would have to be a separate assembler source file
+# for each assembler on every architecture.
 
 SET(ASM_DIALECT "-ATT")
 INCLUDE(CMakeTestASMCompiler)

Modules/CMakeTestASMCompiler.cmake

@@ -13,10 +13,11 @@
 #  License text for the above reference.)
 
 # This file is used by EnableLanguage in cmGlobalGenerator to
-# determine that that selected ASM compiler can actually compile
-# and link the most basic of programs.   If not, a fatal error
-# is set and cmake stops processing commands and will not generate
-# any makefiles or projects.
+# determine that the selected ASM compiler works.
+# For assembler this can only check whether the compiler has been found,
+# because otherwise there would have to be a separate assembler source file
+# for each assembler on every architecture.
+
 IF(CMAKE_ASM${ASM_DIALECT}_COMPILER)
   SET(CMAKE_ASM${ASM_DIALECT}_COMPILER_WORKS 1 CACHE INTERNAL "")
 ELSE(CMAKE_ASM${ASM_DIALECT}_COMPILER)

Modules/CMakeTestASM_MASMCompiler.cmake

@@ -13,10 +13,10 @@
 #  License text for the above reference.)
 
 # This file is used by EnableLanguage in cmGlobalGenerator to
-# determine that the selected ASM_MASM "compiler" (should be masm or masm64) 
-# can actually "compile" and link the most basic of programs.   If not, a 
-# fatal error is set and cmake stops processing commands and will not generate
-# any makefiles or projects.
+# determine that the selected ASM_MASM "compiler" (should be masm or masm64)
+# works. For assembler this can only check whether the compiler has been found,
+# because otherwise there would have to be a separate assembler source file
+# for each assembler on every architecture.
 
 SET(ASM_DIALECT "_MASM")
 INCLUDE(CMakeTestASMCompiler)

Modules/CMakeTestASM_NASMCompiler.cmake

@@ -0,0 +1,23 @@
+
+#=============================================================================
+# Copyright 2010 Kitware, Inc.
+#
+# Distributed under the OSI-approved BSD License (the "License");
+# see accompanying file Copyright.txt for details.
+#
+# This software is distributed WITHOUT ANY WARRANTY; without even the
+# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the License for more information.
+#=============================================================================
+# (To distribute this file outside of CMake, substitute the full
+#  License text for the above reference.)
+
+# This file is used by EnableLanguage in cmGlobalGenerator to
+# determine that the selected ASM_NASM "compiler" works.
+# For assembler this can only check whether the compiler has been found,
+# because otherwise there would have to be a separate assembler source file
+# for each assembler on every architecture.
+
+SET(ASM_DIALECT "_NASM")
+INCLUDE(CMakeTestASMCompiler)
+SET(ASM_DIALECT)

Modules/CPack.STGZ_Header.sh.in

@@ -80,7 +80,7 @@ then
 
   if [ "x${cpack_skip_license}x" != "xTRUEx" ]
   then
-    more << ____cpack__here_doc____
+    more << '____cpack__here_doc____'
 @CPACK_RESOURCE_FILE_LICENSE_CONTENT@
 ____cpack__here_doc____
     echo

Modules/CPackRPM.cmake

@@ -331,7 +331,7 @@ ELSE(CPACK_RPM_COMPRESSION_TYPE)
 ENDIF(CPACK_RPM_COMPRESSION_TYPE)
 
 if(CPACK_PACKAGE_RELOCATABLE)
-    set(CPACK_RPM_PACKAGE_RELOCATABLE TRUE)
+  set(CPACK_RPM_PACKAGE_RELOCATABLE TRUE)
 endif(CPACK_PACKAGE_RELOCATABLE)
 if(CPACK_RPM_PACKAGE_RELOCATABLE)
   if(CPACK_RPM_PACKAGE_DEBUG)
@@ -453,6 +453,17 @@ SET(CPACK_RPM_FILE_NAME "${CPACK_OUTPUT_FILE_NAME}")
 #STRING(REGEX REPLACE " " "\\\\ " CPACK_RPM_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}")
 SET(CPACK_RPM_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}")
 
+
+# Are we packaging components ?
+IF(CPACK_RPM_PACKAGE_COMPONENT)
+  SET(CPACK_RPM_PACKAGE_COMPONENT_PART_NAME "-${CPACK_RPM_PACKAGE_COMPONENT}")
+  SET(CPACK_RPM_PACKAGE_COMPONENT_PART_PATH "/${CPACK_RPM_PACKAGE_COMPONENT}")
+  SET(WDIR "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}/${CPACK_RPM_PACKAGE_COMPONENT}")
+ELSE(CPACK_RPM_PACKAGE_COMPONENT)
+  SET(CPACK_RPM_PACKAGE_COMPONENT_PART_NAME "")
+  SET(CPACK_RPM_PACKAGE_COMPONENT_PART_PATH "")
+  SET(WDIR "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}")
+ENDIF(CPACK_RPM_PACKAGE_COMPONENT)
 # Use files tree to construct files command (spec file)
 # We should not forget to include symlinks (thus -o -type l)
 # We must remove the './' due to the local search and escape the
@@ -460,10 +471,10 @@ SET(CPACK_RPM_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}")
 # Then we must authorize any man pages extension (adding * at the end)
 # because rpmbuild may automatically compress those files
 EXECUTE_PROCESS(COMMAND find -type f -o -type l
-               COMMAND sed {s:.*/man.*/.*:&*:}
-               COMMAND sed {s/\\.\\\(.*\\\)/\"\\1\"/}
-               WORKING_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}"
-               OUTPUT_VARIABLE CPACK_RPM_INSTALL_FILES)
+                COMMAND sed {s:.*/man.*/.*:&*:}
+                COMMAND sed {s/\\.\\\(.*\\\)/\"\\1\"/}
+                WORKING_DIRECTORY "${WDIR}"
+                OUTPUT_VARIABLE CPACK_RPM_INSTALL_FILES)
 
 if (CPACK_ABSOLUTE_DESTINATION_FILES)
   IF(CPACK_RPM_PACKAGE_DEBUG)
@@ -494,7 +505,7 @@ if (CPACK_ABSOLUTE_DESTINATION_FILES)
 endif(CPACK_ABSOLUTE_DESTINATION_FILES)
 
 # The name of the final spec file to be used by rpmbuild
-SET(CPACK_RPM_BINARY_SPECFILE "${CPACK_RPM_ROOTDIR}/SPECS/${CPACK_RPM_PACKAGE_NAME}.spec")
+SET(CPACK_RPM_BINARY_SPECFILE "${CPACK_RPM_ROOTDIR}/SPECS/${CPACK_RPM_PACKAGE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_NAME}.spec")
 
 # Print out some debug information if we were asked for that
 IF(CPACK_RPM_PACKAGE_DEBUG)
@@ -517,7 +528,7 @@ ENDIF(CPACK_RPM_PACKAGE_DEBUG)
 IF(CPACK_RPM_GENERATE_USER_BINARY_SPECFILE_TEMPLATE OR NOT CPACK_RPM_USER_BINARY_SPECFILE)
    FILE(WRITE ${CPACK_RPM_BINARY_SPECFILE}.in
       "# -*- rpm-spec -*-
-BuildRoot:      \@CPACK_RPM_DIRECTORY\@/\@CPACK_PACKAGE_FILE_NAME\@
+BuildRoot:      \@CPACK_RPM_DIRECTORY\@/\@CPACK_PACKAGE_FILE_NAME\@\@CPACK_RPM_PACKAGE_COMPONENT_PART_PATH\@
 Summary:        \@CPACK_RPM_PACKAGE_SUMMARY\@
 Name:           \@CPACK_RPM_PACKAGE_NAME\@
 Version:        \@CPACK_RPM_PACKAGE_VERSION\@
@@ -555,10 +566,9 @@ mv $RPM_BUILD_ROOT \"\@CPACK_TOPLEVEL_DIRECTORY\@/tmpBBroot\"
 %install
 if [ -e $RPM_BUILD_ROOT ];
 then
-  mv \"\@CPACK_TOPLEVEL_DIRECTORY\@/tmpBBroot/*\" $RPM_BUILD_ROOT
-else
-  mv \"\@CPACK_TOPLEVEL_DIRECTORY\@/tmpBBroot\" $RPM_BUILD_ROOT
+  rm -rf $RPM_BUILD_ROOT
 fi
+mv \"\@CPACK_TOPLEVEL_DIRECTORY\@/tmpBBroot\" $RPM_BUILD_ROOT
 
 %clean
 
@@ -608,15 +618,15 @@ IF(RPMBUILD_EXECUTABLE)
   # Now call rpmbuild using the SPECFILE
   EXECUTE_PROCESS(
     COMMAND "${RPMBUILD_EXECUTABLE}" -bb
-            --buildroot "${CPACK_RPM_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}"
+            --buildroot "${CPACK_RPM_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}"
             "${CPACK_RPM_BINARY_SPECFILE}"
-    WORKING_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}"
-    ERROR_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.err"
-    OUTPUT_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.out")
+    WORKING_DIRECTORY "${CPACK_TOPLEVEL_DIRECTORY}/${CPACK_PACKAGE_FILE_NAME}${CPACK_RPM_PACKAGE_COMPONENT_PART_PATH}"
+    ERROR_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_COMPONENT_PART_NAME}.err"
+    OUTPUT_FILE "${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_COMPONENT_PART_NAME}.out")
   IF(CPACK_RPM_PACKAGE_DEBUG)
     MESSAGE("CPackRPM:Debug: You may consult rpmbuild logs in: ")
-    MESSAGE("CPackRPM:Debug:    - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.err")
-    MESSAGE("CPackRPM:Debug:    - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild.out")
+    MESSAGE("CPackRPM:Debug:    - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_COMPONENT_PART_NAME}.err")
+    MESSAGE("CPackRPM:Debug:    - ${CPACK_TOPLEVEL_DIRECTORY}/rpmbuild${CPACK_RPM_PACKAGE_COMPONENT_PART_NAME}.out")
   ENDIF(CPACK_RPM_PACKAGE_DEBUG)
 ELSE(RPMBUILD_EXECUTABLE)
   IF(ALIEN_EXECUTABLE)

Modules/CheckCCompilerFlag.cmake

@@ -7,7 +7,7 @@
 # that can modify the build.
 
 #=============================================================================
-# Copyright 2006-2009 Kitware, Inc.
+# Copyright 2006-2010 Kitware, Inc.
 # Copyright 2006 Alexander Neundorf <neundorf@kde.org>
 #
 # Distributed under the OSI-approved BSD License (the "License");
@@ -29,6 +29,7 @@ MACRO (CHECK_C_COMPILER_FLAG _FLAG _RESULT)
      # Some compilers do not fail with a bad flag
      FAIL_REGEX "unrecognized .*option"                     # GNU
      FAIL_REGEX "ignoring unknown option"                   # MSVC
+     FAIL_REGEX "warning D9002"                             # MSVC, any lang
      FAIL_REGEX "[Uu]nknown option"                         # HP
      FAIL_REGEX "[Ww]arning: [Oo]ption"                     # SunPro
      FAIL_REGEX "command option .* is not recognized"       # XL

Modules/CheckCXXCompilerFlag.cmake

@@ -7,7 +7,7 @@
 # modify the build.
 
 #=============================================================================
-# Copyright 2006-2009 Kitware, Inc.
+# Copyright 2006-2010 Kitware, Inc.
 # Copyright 2006 Alexander Neundorf <neundorf@kde.org>
 #
 # Distributed under the OSI-approved BSD License (the "License");
@@ -29,6 +29,7 @@ MACRO (CHECK_CXX_COMPILER_FLAG _FLAG _RESULT)
      # Some compilers do not fail with a bad flag
      FAIL_REGEX "unrecognized .*option"                     # GNU
      FAIL_REGEX "ignoring unknown option"                   # MSVC
+     FAIL_REGEX "warning D9002"                             # MSVC, any lang
      FAIL_REGEX "[Uu]nknown option"                         # HP
      FAIL_REGEX "[Ww]arning: [Oo]ption"                     # SunPro
      FAIL_REGEX "command option .* is not recognized"       # XL

Modules/Compiler/Cray-C.cmake

@@ -0,0 +1 @@
+set(CMAKE_C_VERBOSE_FLAG "-v")

Modules/Compiler/Cray-CXX.cmake

@@ -0,0 +1 @@
+set(CMAKE_CXX_VERBOSE_FLAG "-v")

Modules/Compiler/Cray-Fortran.cmake

@@ -0,0 +1,4 @@
+set(CMAKE_Fortran_VERBOSE_FLAG "-v")
+set(CMAKE_Fortran_MODOUT_FLAG -em)
+set(CMAKE_Fortran_MODDIR_FLAG -J)
+set(CMAKE_Fortran_MODDIR_DEFAULT .)

Modules/Compiler/NAG-Fortran.cmake

@@ -0,0 +1,32 @@
+# Help CMAKE_PARSE_IMPLICIT_LINK_INFO detect NAG Fortran object files.
+if(NOT CMAKE_Fortran_COMPILER_WORKS AND NOT CMAKE_Fortran_COMPILER_FORCED)
+  message(STATUS "Detecting NAG Fortran directory")
+  # Run with -dryrun to see sample "link" line.
+  execute_process(
+    COMMAND ${CMAKE_Fortran_COMPILER} dummy.o -dryrun
+    OUTPUT_VARIABLE _dryrun
+    ERROR_VARIABLE _dryrun
+    )
+  # Match an object file.
+  string(REGEX MATCH "/[^ ]*/[^ /][^ /]*\\.o" _nag_obj "${_dryrun}")
+  if(_nag_obj)
+    # Parse object directory and convert to a regex.
+    string(REGEX REPLACE "/[^/]*$" "" _nag_dir "${_nag_obj}")
+    string(REGEX REPLACE "([][+.*()^])" "\\\\\\1" _nag_regex "${_nag_dir}")
+    set(CMAKE_Fortran_IMPLICIT_OBJECT_REGEX "^${_nag_regex}/")
+    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
+      "Detecting NAG Fortran directory with -dryrun found\n"
+      "  object: ${_nag_obj}\n"
+      "  directory: ${_nag_dir}\n"
+      "  regex: ${CMAKE_Fortran_IMPLICIT_OBJECT_REGEX}\n"
+      "from output:\n${_dryrun}\n\n")
+    message(STATUS "Detecting NAG Fortran directory - ${_nag_dir}")
+  else()
+    file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
+      "Detecting NAG Fortran directory with -dryrun failed:\n${_dryrun}\n\n")
+    message(STATUS "Detecting NAG Fortran directory - failed")
+  endif()
+endif()
+
+set(CMAKE_Fortran_MODDIR_FLAG "-mdir ")
+set(CMAKE_SHARED_LIBRARY_Fortran_FLAGS "-PIC")

Modules/ExternalProject.cmake

@@ -32,6 +32,7 @@
 #    [CMAKE_COMMAND /.../cmake]  # Specify alternative cmake executable
 #    [CMAKE_GENERATOR gen]       # Specify generator for native build
 #    [CMAKE_ARGS args...]        # Arguments to CMake command line
+#    [CMAKE_CACHE_ARGS args...]  # Initial cache arguments, of the form -Dvar:string=on
 #   #--Build step-----------------
 #    [BINARY_DIR dir]            # Specify build dir location
 #    [BUILD_COMMAND cmd...]      # Command to drive the native build
@@ -549,6 +550,47 @@ function(_ep_set_directories name)
   endforeach()
 endfunction(_ep_set_directories)
 
+function(_ep_write_initial_cache script_filename args)
+  # Write out values into an initial cache, that will be passed to CMake with -C
+  set(script_initial_cache "")
+  set(regex "^([^:]+):([^=]+)=(.*)$")
+  set(setArg "")
+  foreach(line ${args})
+    if("${line}" MATCHES "^-D")
+      if(setArg)
+        # This is required to build up lists in variables, or complete an entry
+        set(setArg "${setArg}${accumulator}\" CACHE ${type} \"Initial cache\" FORCE)")
+        set(script_initial_cache "${script_initial_cache}\n${setArg}")
+        set(accumulator "")
+        set(setArg "")
+      endif()
+      string(REGEX REPLACE "^-D" "" line ${line})
+      if("${line}" MATCHES "${regex}")
+        string(REGEX MATCH "${regex}" match "${line}")
+        set(name "${CMAKE_MATCH_1}")
+        set(type "${CMAKE_MATCH_2}")
+        set(value "${CMAKE_MATCH_3}")
+        set(setArg "set(${name} \"${value}")
+      else()
+        message(WARNING "Line '${line}' does not match regex. Ignoring.")
+      endif()
+    else()
+      # Assume this is a list to append to the last var
+      set(accumulator "${accumulator};${line}")
+    endif()
+  endforeach()
+  # Catch the final line of the args
+  if(setArg)
+    set(setArg "${setArg}${accumulator}\" CACHE ${type} \"Initial cache\" FORCE)")
+    set(script_initial_cache "${script_initial_cache}\n${setArg}")
+  endif()
+  # Write out the initial cache file to the location specified.
+  if(NOT EXISTS "${script_filename}.in")
+    file(WRITE "${script_filename}.in" "\@script_initial_cache\@\n")
+  endif()
+  configure_file("${script_filename}.in" "${script_filename}")
+endfunction(_ep_write_initial_cache)
+
 
 function(ExternalProject_Get_Property name)
   foreach(var ${ARGN})
@@ -1224,11 +1266,24 @@ function(_ep_add_configure_command name)
     get_property(cmake_args TARGET ${name} PROPERTY _EP_CMAKE_ARGS)
     list(APPEND cmd ${cmake_args})
 
+    # If there are any CMAKE_CACHE_ARGS, write an initial cache and use it
+    get_property(cmake_cache_args TARGET ${name} PROPERTY _EP_CMAKE_CACHE_ARGS)
+    if(cmake_cache_args)
+      set(_ep_cache_args_script "${tmp_dir}/${name}-cache.cmake")
+      _ep_write_initial_cache("${_ep_cache_args_script}" "${cmake_cache_args}")
+      list(APPEND cmd "-C${_ep_cache_args_script}")
+    endif()
+
     get_target_property(cmake_generator ${name} _EP_CMAKE_GENERATOR)
     if(cmake_generator)
       list(APPEND cmd "-G${cmake_generator}" "${source_dir}")
     else()
-      list(APPEND cmd "-G${CMAKE_GENERATOR}" "${source_dir}")
+      if(CMAKE_EXTRA_GENERATOR)
+        list(APPEND cmd "-G${CMAKE_EXTRA_GENERATOR} - ${CMAKE_GENERATOR}"
+          "${source_dir}")
+      else()
+        list(APPEND cmd "-G${CMAKE_GENERATOR}" "${source_dir}")
+      endif()
     endif()
   endif()
 
@@ -1237,10 +1292,11 @@ function(_ep_add_configure_command name)
   # Fixes issue http://public.kitware.com/Bug/view.php?id=10258
   #
   if(NOT EXISTS ${tmp_dir}/${name}-cfgcmd.txt.in)
-    file(WRITE ${tmp_dir}/${name}-cfgcmd.txt.in "cmd='@cmd@'\n")
+    file(WRITE ${tmp_dir}/${name}-cfgcmd.txt.in "cmd='\@cmd\@'\n")
   endif()
   configure_file(${tmp_dir}/${name}-cfgcmd.txt.in ${tmp_dir}/${name}-cfgcmd.txt)
   list(APPEND file_deps ${tmp_dir}/${name}-cfgcmd.txt)
+  list(APPEND file_deps ${_ep_cache_args_script})
 
   get_property(log TARGET ${name} PROPERTY _EP_LOG_CONFIGURE)
   if(log)

Modules/FindBISON.cmake

@@ -51,12 +51,19 @@ FIND_PROGRAM(BISON_EXECUTABLE bison DOC "path to the bison executable")
 MARK_AS_ADVANCED(BISON_EXECUTABLE)
 
 IF(BISON_EXECUTABLE)
+  # the bison commands should be executed with the C locale, otherwise
+  # the message (which are parsed) may be translated
+  SET(_Bison_SAVED_LC_ALL "$ENV{LC_ALL}")
+  SET(ENV{LC_ALL} C)
 
   EXECUTE_PROCESS(COMMAND ${BISON_EXECUTABLE} --version
     OUTPUT_VARIABLE BISON_version_output
     ERROR_VARIABLE BISON_version_error
     RESULT_VARIABLE BISON_version_result
     OUTPUT_STRIP_TRAILING_WHITESPACE)
+
+  SET(ENV{LC_ALL} ${_Bison_SAVED_LC_ALL})
+
   IF(NOT ${BISON_version_result} EQUAL 0)
     MESSAGE(SEND_ERROR "Command \"${BISON_EXECUTABLE} --version\" failed with output:\n${BISON_version_error}")
   ELSE()
@@ -115,7 +122,7 @@ IF(BISON_EXECUTABLE)
         IF("${ARGV5}" STREQUAL "VERBOSE")
           BISON_TARGET_option_verbose(${Name} ${BisonOutput} "${ARGV6}")
         ENDIF()
-      
+
         IF("${ARGV5}" STREQUAL "COMPILE_FLAGS")
           BISON_TARGET_option_extraopts("${ARGV6}")
         ENDIF()
@@ -125,10 +132,10 @@ IF(BISON_EXECUTABLE)
       LIST(APPEND BISON_TARGET_cmdopt "-d")
       STRING(REGEX REPLACE "^(.*)(\\.[^.]*)$" "\\2" _fileext "${ARGV2}")
       STRING(REPLACE "c" "h" _fileext ${_fileext})
-      STRING(REGEX REPLACE "^(.*)(\\.[^.]*)$" "\\1${_fileext}" 
+      STRING(REGEX REPLACE "^(.*)(\\.[^.]*)$" "\\1${_fileext}"
           BISON_${Name}_OUTPUT_HEADER "${ARGV2}")
       LIST(APPEND BISON_TARGET_outputs "${BISON_${Name}_OUTPUT_HEADER}")
-        
+
       ADD_CUSTOM_COMMAND(OUTPUT ${BISON_TARGET_outputs}
         ${BISON_TARGET_extraoutputs}
         COMMAND ${BISON_EXECUTABLE}
@@ -136,7 +143,7 @@ IF(BISON_EXECUTABLE)
         DEPENDS ${ARGV1}
         COMMENT "[BISON][${Name}] Building parser with bison ${BISON_VERSION}"
         WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
-    
+
       # define target variables
       SET(BISON_${Name}_DEFINED TRUE)
       SET(BISON_${Name}_INPUT ${ARGV1})

Modules/FindBoost.cmake

@@ -64,7 +64,8 @@
 # Currently this module searches for the following version numbers:
 # 1.33, 1.33.0, 1.33.1, 1.34, 1.34.0, 1.34.1, 1.35, 1.35.0, 1.35.1,
 # 1.36, 1.36.0, 1.36.1, 1.37, 1.37.0, 1.38, 1.38.0, 1.39, 1.39.0,
-# 1.40, 1.40.0, 1.41, 1.41.0, 1.42, 1.42.0, 1.43, 1.43.0, 1.44, 1.44.0
+# 1.40, 1.40.0, 1.41, 1.41.0, 1.42, 1.42.0, 1.43, 1.43.0, 1.44, 1.44.0,
+# 1.45, 1.45.0, 1.46, 1.46.0
 #
 # NOTE: If you add a new major 1.x version in Boost_ADDITIONAL_VERSIONS you should
 # add both 1.x and 1.x.0 as shown above.  Official Boost include directories
@@ -377,7 +378,7 @@ else(Boost_FIND_VERSION_EXACT)
   # The user has not requested an exact version.  Among known
   # versions, find those that are acceptable to the user request.
   set(_Boost_KNOWN_VERSIONS ${Boost_ADDITIONAL_VERSIONS}
-    "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"
+    "1.46.0" "1.46" "1.45.0" "1.45" "1.44.0" "1.44" "1.43.0" "1.43" "1.42.0" "1.42"
     "1.41.0" "1.41" "1.40.0" "1.40" "1.39.0" "1.39" "1.38.0" "1.38" "1.37.0" "1.37"
     "1.36.1" "1.36.0" "1.36" "1.35.1" "1.35.0" "1.35" "1.34.1" "1.34.0"
     "1.34" "1.33.1" "1.33.0" "1.33")
@@ -412,9 +413,7 @@ IF(Boost_INCLUDE_DIR)
   # On versions < 1.35, remove the System library from the considered list
   # since it wasn't added until 1.35.
   if(Boost_VERSION AND Boost_FIND_COMPONENTS)
-     math(EXPR _boost_maj "${Boost_VERSION} / 100000")
-     math(EXPR _boost_min "${Boost_VERSION} / 100 % 1000")
-     if(${_boost_maj}.${_boost_min} VERSION_LESS 1.35)
+     if(Boost_VERSION LESS 103500)
        list(REMOVE_ITEM Boost_FIND_COMPONENTS system)
      endif()
   endif()
@@ -477,16 +476,16 @@ ELSE (_boost_IN_CACHE)
     # BOOST_WHATEVER_DYN_LINK to force Boost library "whatever" to be
     # linked dynamically.  Alternatively you can force all Boost
     # libraries to dynamic link by defining BOOST_ALL_DYN_LINK.
-  
+
     # This feature can be disabled for Boost library "whatever" by
     # defining BOOST_WHATEVER_NO_LIB, or for all of Boost by defining
     # BOOST_ALL_NO_LIB.
-  
+
     # If you want to observe which libraries are being linked against
     # then defining BOOST_LIB_DIAGNOSTIC will cause the auto-linking
     # code to emit a #pragma message each time a library is selected
     # for linking.
-    SET(Boost_LIB_DIAGNOSTIC_DEFINITIONS 
+    SET(Boost_LIB_DIAGNOSTIC_DEFINITIONS
       "-DBOOST_LIB_DIAGNOSTIC" CACHE STRING "Boost diagnostic define")
   ENDIF(WIN32)
 
@@ -519,12 +518,12 @@ ELSE (_boost_IN_CACHE)
   IF( NOT $ENV{BOOST_INCLUDEDIR} STREQUAL "" )
     set(BOOST_INCLUDEDIR $ENV{BOOST_INCLUDEDIR})
   ENDIF( NOT $ENV{BOOST_INCLUDEDIR} STREQUAL "" )
-  
+
   # If BOOST_LIBRARYDIR was defined in the environment, use it.
   IF( NOT $ENV{BOOST_LIBRARYDIR} STREQUAL "" )
     set(BOOST_LIBRARYDIR $ENV{BOOST_LIBRARYDIR})
   ENDIF( NOT $ENV{BOOST_LIBRARYDIR} STREQUAL "" )
-  
+
   IF( BOOST_ROOT )
     file(TO_CMAKE_PATH ${BOOST_ROOT} BOOST_ROOT)
   ENDIF( BOOST_ROOT )
@@ -563,7 +562,7 @@ ELSE (_boost_IN_CACHE)
   endif( BOOST_INCLUDEDIR )
 
   # ------------------------------------------------------------------------
-  #  Search for Boost include DIR 
+  #  Search for Boost include DIR
   # ------------------------------------------------------------------------
   # Try to find Boost by stepping backwards through the Boost versions
   # we know about.
@@ -578,18 +577,18 @@ ELSE (_boost_IN_CACHE)
 
       # Transform 1.35 => 1_35 and 1.36.0 => 1_36_0
       IF(_boost_VER MATCHES "[0-9]+\\.[0-9]+\\.[0-9]+")
-          STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1_\\2_\\3" 
+          STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)\\.([0-9]+)" "\\1_\\2_\\3"
             _boost_BOOSTIFIED_VERSION ${_boost_VER})
       ELSEIF(_boost_VER MATCHES "[0-9]+\\.[0-9]+")
-          STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)" "\\1_\\2" 
+          STRING(REGEX REPLACE "([0-9]+)\\.([0-9]+)" "\\1_\\2"
             _boost_BOOSTIFIED_VERSION ${_boost_VER})
       ENDIF()
-      
+
       list(APPEND _boost_PATH_SUFFIXES "boost-${_boost_BOOSTIFIED_VERSION}")
       list(APPEND _boost_PATH_SUFFIXES "boost_${_boost_BOOSTIFIED_VERSION}")
 
     ENDFOREACH(_boost_VER)
-      
+
     if(Boost_DEBUG)
       message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
                      "Include debugging info:")
@@ -607,7 +606,7 @@ ELSE (_boost_IN_CACHE)
       ${_boost_FIND_OPTIONS}
       )
   ENDIF( NOT Boost_INCLUDE_DIR )
-  
+
   # ------------------------------------------------------------------------
   #  Extract version information from version.hpp
   # ------------------------------------------------------------------------
@@ -623,13 +622,13 @@ ELSE (_boost_IN_CACHE)
       message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] "
                      "location of version.hpp: ${Boost_INCLUDE_DIR}/boost/version.hpp")
     endif()
-  
+
     STRING(REGEX REPLACE ".*#define BOOST_VERSION ([0-9]+).*" "\\1" Boost_VERSION "${_boost_VERSION_HPP_CONTENTS}")
     STRING(REGEX REPLACE ".*#define BOOST_LIB_VERSION \"([0-9_]+)\".*" "\\1" Boost_LIB_VERSION "${_boost_VERSION_HPP_CONTENTS}")
-  
+
     SET(Boost_LIB_VERSION ${Boost_LIB_VERSION} CACHE INTERNAL "The library version string for boost libraries")
     SET(Boost_VERSION ${Boost_VERSION} CACHE INTERNAL "The version number for boost libraries")
-    
+
     IF(NOT "${Boost_VERSION}" STREQUAL "0")
       MATH(EXPR Boost_MAJOR_VERSION "${Boost_VERSION} / 100000")
       MATH(EXPR Boost_MINOR_VERSION "${Boost_VERSION} / 100 % 1000")
@@ -647,7 +646,7 @@ ELSE (_boost_IN_CACHE)
     set(Boost_ERROR_REASON
       "${Boost_ERROR_REASON}Unable to find the Boost header files. Please set BOOST_ROOT to the root directory containing Boost or BOOST_INCLUDEDIR to the directory containing Boost's headers.")
   ENDIF(Boost_INCLUDE_DIR)
-  
+
   # ------------------------------------------------------------------------
   #  Suffix initialization and compiler suffix detection.
   # ------------------------------------------------------------------------
@@ -670,7 +669,7 @@ ELSE (_boost_IN_CACHE)
     # please report them and use the Boost_COMPILER variable
     # to work around the problems.
     if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel"
-        OR "${CMAKE_CXX_COMPILER}" MATCHES "icl" 
+        OR "${CMAKE_CXX_COMPILER}" MATCHES "icl"
         OR "${CMAKE_CXX_COMPILER}" MATCHES "icpc")
       if(WIN32)
         set (_boost_COMPILER "-iw")
@@ -916,6 +915,7 @@ ELSE (_boost_IN_CACHE)
       ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_COMPILER}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}-${Boost_LIB_VERSION}
       ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_COMPILER}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}
       ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}-${Boost_LIB_VERSION}
+      ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED}${_boost_DEBUG_ABI_TAG}
       ${Boost_LIB_PREFIX}boost_${COMPONENT}${_boost_MULTITHREADED}
       ${Boost_LIB_PREFIX}boost_${COMPONENT} )
     if(_boost_STATIC_RUNTIME_WORKAROUND)
@@ -998,7 +998,7 @@ ELSE (_boost_IN_CACHE)
       if (NOT Boost_FIND_VERSION_PATCH)
         set(Boost_FIND_VERSION_PATCH 0)
       endif (NOT Boost_FIND_VERSION_PATCH)
-      
+
       # We'll set Boost_FOUND true again if we have an exact version match.
       set(Boost_FOUND FALSE)
       _Boost_MARK_COMPONENTS_FOUND(OFF)
@@ -1017,7 +1017,7 @@ ELSE (_boost_IN_CACHE)
       set(Boost_ERROR_REASON
         "${Boost_ERROR_REASON}\nDetected version of Boost is too ${_Boost_VERSION_AGE}. Requested version was ${Boost_FIND_VERSION_MAJOR}.${Boost_FIND_VERSION_MINOR}")
       if (Boost_FIND_VERSION_PATCH)
-        set(Boost_ERROR_REASON 
+        set(Boost_ERROR_REASON
           "${Boost_ERROR_REASON}.${Boost_FIND_VERSION_PATCH}")
       endif (Boost_FIND_VERSION_PATCH)
       if (NOT Boost_FIND_VERSION_EXACT)
@@ -1072,16 +1072,16 @@ ELSE (_boost_IN_CACHE)
       # Note that the user may not have installed any libraries
       # so it is quite possible the Boost_LIBRARY_PATH may not exist.
       SET(_boost_LIB_DIR ${Boost_INCLUDE_DIR})
-    
+
       IF("${_boost_LIB_DIR}" MATCHES "boost-[0-9]+")
         GET_FILENAME_COMPONENT(_boost_LIB_DIR ${_boost_LIB_DIR} PATH)
       ENDIF ("${_boost_LIB_DIR}" MATCHES "boost-[0-9]+")
-    
+
       IF("${_boost_LIB_DIR}" MATCHES "/include$")
         # Strip off the trailing "/include" in the path.
         GET_FILENAME_COMPONENT(_boost_LIB_DIR ${_boost_LIB_DIR} PATH)
       ENDIF("${_boost_LIB_DIR}" MATCHES "/include$")
-    
+
       IF(EXISTS "${_boost_LIB_DIR}/lib")
         SET (_boost_LIB_DIR ${_boost_LIB_DIR}/lib)
       ELSE(EXISTS "${_boost_LIB_DIR}/lib")
@@ -1091,7 +1091,7 @@ ELSE (_boost_IN_CACHE)
           SET(_boost_LIB_DIR "")
         ENDIF(EXISTS "${_boost_LIB_DIR}/stage/lib")
       ENDIF(EXISTS "${_boost_LIB_DIR}/lib")
-    
+
       IF(_boost_LIB_DIR AND EXISTS "${_boost_LIB_DIR}")
         SET(Boost_LIBRARY_DIRS ${_boost_LIB_DIR} CACHE FILEPATH "Boost library directory")
       ENDIF(_boost_LIB_DIR AND EXISTS "${_boost_LIB_DIR}")
@@ -1142,4 +1142,3 @@ ELSE (_boost_IN_CACHE)
       Boost_LIBRARY_DIRS
   )
 ENDIF(_boost_IN_CACHE)
-

Modules/FindBullet.cmake

@@ -31,7 +31,7 @@ macro(_FIND_BULLET_LIBRARY _var)
   find_library(${_var}
      NAMES 
         ${ARGN}
-     PATHS
+     HINTS
         ${BULLET_ROOT}
         ${BULLET_ROOT}/out/release8/libs
         ${BULLET_ROOT}/out/debug8/libs
@@ -50,9 +50,10 @@ macro(_BULLET_APPEND_LIBRARIES _list _release)
 endmacro()
 
 find_path(BULLET_INCLUDE_DIR NAMES btBulletCollisionCommon.h
-  PATHS
+  HINTS
     ${BULLET_ROOT}/include
     ${BULLET_ROOT}/src
+  PATH_SUFFIXES bullet
 )
 
 # Find the libraries

Modules/FindCxxTest.cmake

@@ -97,6 +97,11 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
+# Version 1.4 (11/18/10) (CMake 2.8.4)
+#     Issue 11384: Added support to the CXX_ADD_TEST macro so header
+#                  files (containing the tests themselves) show up in
+#                  Visual Studio and other IDEs.
+#
 # Version 1.3 (8/19/10) (CMake 2.8.3)
 #     Included patch by Simone Rossetto to check if either Python or Perl
 #     are present in the system.  Whichever intepreter that is detected
@@ -131,7 +136,7 @@ macro(CXXTEST_ADD_TEST _cxxtest_testname _cxxtest_outfname)
     )
 
     set_source_files_properties(${_cxxtest_real_outfname} PROPERTIES GENERATED true)
-    add_executable(${_cxxtest_testname} ${_cxxtest_real_outfname})
+    add_executable(${_cxxtest_testname} ${_cxxtest_real_outfname} ${ARGN})
 
     if(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
         add_test(${_cxxtest_testname} ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/${_cxxtest_testname})

Modules/FindFLEX.cmake

@@ -36,8 +36,8 @@
 #   find_package(BISON)
 #   find_package(FLEX)
 #
-#   BISON_TARGET(MyParser parser.y ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp
-#   FLEX_TARGET(MyScanner lexer.l  ${CMAKE_CURRENT_BIANRY_DIR}/lexer.cpp)
+#   BISON_TARGET(MyParser parser.y ${CMAKE_CURRENT_BINARY_DIR}/parser.cpp)
+#   FLEX_TARGET(MyScanner lexer.l  ${CMAKE_CURRENT_BINARY_DIR}/lexer.cpp)
 #   ADD_FLEX_BISON_DEPENDENCY(MyScanner MyParser)
 #
 #   include_directories(${CMAKE_CURRENT_BINARY_DIR})

Modules/FindGTK2.cmake

@@ -66,6 +66,10 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
+# Version 1.3 (11/9/2010) (CMake 2.8.4)
+#   * 11429: Add support for detecting GTK2 built with Visual Studio 10.
+#            Thanks to Vincent Levesque for the patch.
+
 # Version 1.2 (8/30/2010) (CMake 2.8.3)
 #   * Merge patch for detecting gdk-pixbuf library (split off
 #     from core GTK in 2.21).  Thanks to Vincent Untz for the patch
@@ -237,15 +241,16 @@ function(_GTK2_FIND_LIBRARY _var _lib _expand_vc _append_version)
 
     set(_library ${_lib})
 
-    if(_expand_vc)
-        # Add vc80/vc90 midfixes
+    if(_expand_vc AND MSVC)
+        # Add vc80/vc90/vc100 midfixes
         if(MSVC80)
             set(_library   ${_library}-vc80)
-            set(_library_d ${_library}-d)
         elseif(MSVC90)
             set(_library   ${_library}-vc90)
-            set(_library_d ${_library}-d)
+        elseif(MSVC10)
+            set(_library ${_library}-vc100)
         endif()
+        set(_library_d ${_library}-d)
     endif()
 
     if(GTK2_DEBUG)

Modules/FindITK.cmake

@@ -21,7 +21,7 @@
 #                 instead.
 
 #=============================================================================
-# Copyright 2001-2009 Kitware, Inc.
+# Copyright 2001-2010 Kitware, Inc.
 #
 # Distributed under the OSI-approved BSD License (the "License");
 # see accompanying file Copyright.txt for details.
@@ -33,67 +33,23 @@
 # (To distribute this file outside of CMake, substitute the full
 #  License text for the above reference.)
 
-SET(ITK_DIR_STRING "directory containing ITKConfig.cmake.  This is either the root of the build tree, or PREFIX/lib/InsightToolkit for an installation.")
+# Use the Config mode of the find_package() command to find ITKConfig.
+# If this succeeds (possibly because ITK_DIR is already set), the
+# command will have already loaded ITKConfig.cmake and set ITK_FOUND.
+IF(NOT ITK_FOUND)
+  FIND_PACKAGE(ITK QUIET NO_MODULE
+    NAMES ITK InsightToolkit
+    CONFIGS ITKConfig.cmake
+    )
+ENDIF()
 
-# Search only if the location is not already known.
-IF(NOT ITK_DIR)
-  # Get the system search path as a list.
-  IF(UNIX)
-    STRING(REGEX MATCHALL "[^:]+" ITK_DIR_SEARCH1 "$ENV{PATH}")
-  ELSE(UNIX)
-    STRING(REGEX REPLACE "\\\\" "/" ITK_DIR_SEARCH1 "$ENV{PATH}")
-  ENDIF(UNIX)
-  STRING(REGEX REPLACE "/;" ";" ITK_DIR_SEARCH2 ${ITK_DIR_SEARCH1})
-
-  # Construct a set of paths relative to the system search path.
-  SET(ITK_DIR_SEARCH "")
-  FOREACH(dir ${ITK_DIR_SEARCH2})
-    SET(ITK_DIR_SEARCH ${ITK_DIR_SEARCH} "${dir}/../lib/InsightToolkit")
-  ENDFOREACH(dir)
-
-  #
-  # Look for an installation or build tree.
-  #
-  FIND_PATH(ITK_DIR ITKConfig.cmake
-    # Look for an environment variable ITK_DIR.
-    $ENV{ITK_DIR}
-
-    # Look in places relative to the system executable search path.
-    ${ITK_DIR_SEARCH}
-
-    # Look in standard UNIX install locations.
-    /usr/local/lib/InsightToolkit
-    /usr/lib/InsightToolkit
-
-    # Read from the CMakeSetup registry entries.  It is likely that
-    # ITK will have been recently built.
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild1]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild2]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild3]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild4]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild5]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild6]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild7]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild8]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild9]
-    [HKEY_CURRENT_USER\\Software\\Kitware\\CMakeSetup\\Settings\\StartPath;WhereBuild10]
-
-    # Help the user find it if we cannot.
-    DOC "The ${ITK_DIR_STRING}"
-  )
-ENDIF(NOT ITK_DIR)
-
-# If ITK was found, load the configuration file to get the rest of the
-# settings.
-IF(ITK_DIR)
-  SET(ITK_FOUND 1)
-  INCLUDE(${ITK_DIR}/ITKConfig.cmake)
+SET(ITK_DIR_MESSAGE "Please set ITK_DIR to the directory containing ITKConfig.cmake.  This is either the root of the build tree, or PREFIX/lib/InsightToolkit for an installation.")
 
+IF(ITK_FOUND)
   # Set USE_ITK_FILE for backward-compatability.
   SET(USE_ITK_FILE ${ITK_USE_FILE})
-ELSE(ITK_DIR)
-  SET(ITK_FOUND 0)
-  IF(ITK_FIND_REQUIRED)
-    MESSAGE(FATAL_ERROR "Please set ITK_DIR to the ${ITK_DIR_STRING}")
-  ENDIF(ITK_FIND_REQUIRED)
-ENDIF(ITK_DIR)
+ELSEIF(ITK_FIND_REQUIRED)
+  MESSAGE(FATAL_ERROR ${ITK_DIR_MESSAGE})
+ELSEIF(NOT ITK_FIND_QUIETLY)
+  MESSAGE(STATUS ${ITK_DIR_MESSAGE})
+ENDIF()

Modules/FindPerlLibs.cmake

@@ -147,6 +147,32 @@ if (PERL_EXECUTABLE)
     string(REGEX REPLACE "install[a-z]+='([^']+)'.*" "\\1" PERL_VENDORLIB ${PERL_VENDORLIB_OUTPUT_VARIABLE})
   endif (NOT PERL_VENDORLIB_RESULT_VARIABLE)
 
+  macro(perl_adjust_darwin_lib_variable varname)
+    string( TOUPPER PERL_${varname} FINDPERL_VARNAME )
+    string( TOLOWER install${varname} PERL_VARNAME )
+
+    if (NOT PERL_MINUSV_OUTPUT_VARIABLE)
+      execute_process(
+        COMMAND
+        ${PERL_EXECUTABLE} -V
+        OUTPUT_VARIABLE
+        PERL_MINUSV_OUTPUT_VARIABLE
+        RESULT_VARIABLE
+        PERL_MINUSV_RESULT_VARIABLE
+        )
+    endif()
+
+    if (NOT PERL_MINUSV_RESULT_VARIABLE)
+      string(REGEX MATCH "(${PERL_VARNAME}.*points? to the Updates directory)"
+        PERL_NEEDS_ADJUSTMENT ${PERL_MINUSV_OUTPUT_VARIABLE})
+
+      if (PERL_NEEDS_ADJUSTMENT)
+        string(REGEX REPLACE "(.*)/Updates/" "/System/\\1/" ${FINDPERL_VARNAME} ${${FINDPERL_VARNAME}})
+      endif (PERL_NEEDS_ADJUSTMENT)
+
+    endif (NOT PERL_MINUSV_RESULT_VARIABLE)
+  endmacro()
+
   ### PERL_ARCHLIB
   execute_process(
     COMMAND
@@ -158,6 +184,7 @@ if (PERL_EXECUTABLE)
   )
   if (NOT PERL_ARCHLIB_RESULT_VARIABLE)
     string(REGEX REPLACE "install[a-z]+='([^']+)'.*" "\\1" PERL_ARCHLIB ${PERL_ARCHLIB_OUTPUT_VARIABLE})
+    perl_adjust_darwin_lib_variable( ARCHLIB )
   endif (NOT PERL_ARCHLIB_RESULT_VARIABLE)
 
   ### PERL_PRIVLIB
@@ -171,6 +198,7 @@ if (PERL_EXECUTABLE)
   )
   if (NOT PERL_PRIVLIB_RESULT_VARIABLE)
     string(REGEX REPLACE "install[a-z]+='([^']+)'.*" "\\1" PERL_PRIVLIB ${PERL_PRIVLIB_OUTPUT_VARIABLE})
+    perl_adjust_darwin_lib_variable( PRIVLIB )
   endif (NOT PERL_PRIVLIB_RESULT_VARIABLE)
 
 

Modules/FindQt3.cmake

@@ -242,9 +242,9 @@ IF (QT_MIN_VERSION)
 ENDIF (QT_MIN_VERSION)
 
 # if the include a library are found then we have it
-IF(QT_INCLUDE_DIR AND QT_QT_LIBRARY)
-  SET( QT_FOUND "YES" )
-ENDIF(QT_INCLUDE_DIR AND QT_QT_LIBRARY)
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(Qt3  DEFAULT_MSG  QT_QT_LIBRARY QT_INCLUDE_DIR QT_MOC_EXECUTABLE)
+SET(QT_FOUND ${QT3_FOUND} )
 
 IF(QT_FOUND)
   SET( QT_LIBRARIES ${QT_LIBRARIES} ${QT_QT_LIBRARY} )

Modules/FindQt4.cmake

@@ -482,7 +482,7 @@ IF (QT_QMAKE_EXECUTABLE)
   _qt4_query_qmake(QT_VERSION QTVERSION)
 
   # check for qt3 qmake and then try and find qmake4 or qmake-qt4 in the path
-  IF("${QTVERSION}" MATCHES "Unknown")
+  IF(NOT QTVERSION)
     SET(QT_QMAKE_EXECUTABLE NOTFOUND CACHE FILEPATH "" FORCE)
     FIND_PROGRAM(QT_QMAKE_EXECUTABLE NAMES qmake4 qmake-qt4 PATHS
       "[HKEY_CURRENT_USER\\Software\\Trolltech\\Qt3Versions\\4.0.0;InstallDir]/bin"
@@ -493,7 +493,7 @@ IF (QT_QMAKE_EXECUTABLE)
     IF(QT_QMAKE_EXECUTABLE)
       _qt4_query_qmake(QT_VERSION QTVERSION)
     ENDIF(QT_QMAKE_EXECUTABLE)
-  ENDIF("${QTVERSION}" MATCHES "Unknown")
+  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}")

Modules/FindTCL.cmake

@@ -104,7 +104,7 @@ ENDIF(WIN32)
 FIND_LIBRARY(TCL_LIBRARY
   NAMES 
   tcl   
-  tcl${TK_LIBRARY_VERSION} tcl${TCL_TCLSH_VERSION} tcl${TK_WISH_VERSION}
+  tcl${TCL_LIBRARY_VERSION} tcl${TCL_TCLSH_VERSION} tcl${TK_WISH_VERSION}
   tcl86 tcl8.6 
   tcl85 tcl8.5 
   tcl84 tcl8.4 
@@ -117,7 +117,7 @@ FIND_LIBRARY(TCL_LIBRARY
 FIND_LIBRARY(TK_LIBRARY 
   NAMES 
   tk
-  tk${TCL_LIBRARY_VERSION} tk${TCL_TCLSH_VERSION} tk${TK_WISH_VERSION}
+  tk${TK_LIBRARY_VERSION} tk${TCL_TCLSH_VERSION} tk${TK_WISH_VERSION}
   tk86 tk8.6
   tk85 tk8.5 
   tk84 tk8.4 

Modules/FortranCInterface/CMakeLists.txt

@@ -45,10 +45,12 @@ set(module_symbols
   my_module_mp_my_sub_    # Intel
   MY_MODULE_mp_MY_SUB     # Intel on Windows
   my_module_my_sub_       # PGI
+  my_module_MP_my_sub     # NAG
   mymodule$mysub          # HP
   mymodule_mp_mysub_      # Intel
   MYMODULE_mp_MYSUB       # Intel on Windows
   mymodule_mysub_         # PGI
+  mymodule_MP_mysub       # NAG
   ${FortranCInterface_MODULE_SYMBOLS}
   )
 list(REMOVE_DUPLICATES module_symbols)

Modules/Platform/CYGWIN.cmake

@@ -3,7 +3,7 @@ SET(CYGWIN 1)
 
 SET(CMAKE_SHARED_LIBRARY_PREFIX "cyg")
 SET(CMAKE_SHARED_LIBRARY_SUFFIX ".dll")
-SET(CMAKE_SHARED_MODULE_PREFIX "lib")
+SET(CMAKE_SHARED_MODULE_PREFIX "cyg")
 SET(CMAKE_SHARED_MODULE_SUFFIX ".dll")
 SET(CMAKE_IMPORT_LIBRARY_PREFIX "lib")
 SET(CMAKE_IMPORT_LIBRARY_SUFFIX ".dll.a")

Modules/Platform/Darwin-NAG-Fortran.cmake

@@ -0,0 +1,5 @@
+set(CMAKE_Fortran_VERBOSE_FLAG "-Wl,-v") # Runs gcc under the hood.
+
+# Need -fpp explicitly on case-insensitive filesystem.
+set(CMAKE_Fortran_COMPILE_OBJECT
+  "<CMAKE_Fortran_COMPILER> -fpp -o <OBJECT> <DEFINES> <FLAGS> -c <SOURCE>")

Modules/Platform/Darwin.cmake

@@ -33,8 +33,8 @@ SET(CMAKE_C_OSX_CURRENT_VERSION_FLAG "-current_version ")
 SET(CMAKE_CXX_OSX_COMPATIBILITY_VERSION_FLAG "${CMAKE_C_OSX_COMPATIBILITY_VERSION_FLAG}")
 SET(CMAKE_CXX_OSX_CURRENT_VERSION_FLAG "${CMAKE_C_OSX_CURRENT_VERSION_FLAG}")
 
-SET(CMAKE_C_LINK_FLAGS "-headerpad_max_install_names")
-SET(CMAKE_CXX_LINK_FLAGS "-headerpad_max_install_names")
+SET(CMAKE_C_LINK_FLAGS "-Wl,-headerpad_max_install_names")
+SET(CMAKE_CXX_LINK_FLAGS "-Wl,-headerpad_max_install_names")
 
 IF(HAVE_FLAG_SEARCH_PATHS_FIRST)
   SET(CMAKE_C_LINK_FLAGS "-Wl,-search_paths_first ${CMAKE_C_LINK_FLAGS}")
@@ -42,8 +42,8 @@ IF(HAVE_FLAG_SEARCH_PATHS_FIRST)
 ENDIF(HAVE_FLAG_SEARCH_PATHS_FIRST)
 
 SET(CMAKE_PLATFORM_HAS_INSTALLNAME 1)
-SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -headerpad_max_install_names")
-SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -headerpad_max_install_names")
+SET(CMAKE_SHARED_LIBRARY_CREATE_C_FLAGS "-dynamiclib -Wl,-headerpad_max_install_names")
+SET(CMAKE_SHARED_MODULE_CREATE_C_FLAGS "-bundle -Wl,-headerpad_max_install_names")
 SET(CMAKE_SHARED_MODULE_LOADER_C_FLAG "-Wl,-bundle_loader,")
 SET(CMAKE_SHARED_MODULE_LOADER_CXX_FLAG "-Wl,-bundle_loader,")
 SET(CMAKE_FIND_LIBRARY_SUFFIXES ".dylib" ".so" ".a")

Modules/Platform/Linux-NAG-Fortran.cmake

@@ -0,0 +1,10 @@
+set(CMAKE_Fortran_VERBOSE_FLAG "-Wl,-v") # Runs gcc under the hood.
+
+# Need one "-Wl," level to send flag through to gcc.
+# Use "-Xlinker" to get through gcc to real linker.
+set(CMAKE_SHARED_LIBRARY_CREATE_Fortran_FLAGS "-Wl,-shared")
+set(CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG "-Wl,-Xlinker,-rpath,-Xlinker,")
+set(CMAKE_SHARED_LIBRARY_RUNTIME_Fortran_FLAG_SEP ":")
+set(CMAKE_SHARED_LIBRARY_RPATH_LINK_Fortran_FLAG "-Wl,-Xlinker,-rpath-link,-Xlinker,")
+set(CMAKE_SHARED_LIBRARY_SONAME_Fortran_FLAG "-Wl,-Xlinker,-soname,-Xlinker,")
+set(CMAKE_SHARED_LIBRARY_LINK_Fortran_FLAGS "-Wl,-rdynamic")

Modules/Platform/Windows-cl.cmake

@@ -212,6 +212,8 @@ SET (CMAKE_EXE_LINKER_FLAGS_INIT
 SET( MSVC_INCREMENTAL_YES_FLAG "")
 IF(NOT MSVC_INCREMENTAL_DEFAULT)
   SET( MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL:YES")
+ELSE()
+  SET(  MSVC_INCREMENTAL_YES_FLAG "/INCREMENTAL" )
 ENDIF()
 
 IF (CMAKE_COMPILER_SUPPORTS_PDBTYPE)

Modules/Qt4ConfigDependentSettings.cmake

@@ -35,10 +35,10 @@ SET(QT_QTHELP_LIB_DEPENDENCIES ${QT_QTCLUCENE_LIBRARY})
 
 
 IF(Q_WS_WIN)
-  # On Windows, qconfig.pri has "static" for static library builds
-  IF(QT_CONFIG MATCHES "static")
+  # On Windows, qconfig.pri has "shared" for shared library builds
+  IF(NOT QT_CONFIG MATCHES "shared")
     SET(QT_IS_STATIC 1)
-  ENDIF(QT_CONFIG MATCHES "static")
+  ENDIF(NOT QT_CONFIG MATCHES "shared")
 ELSE(Q_WS_WIN)
   # On other platforms, check file extension to know if its static
   IF(QT_QTCORE_LIBRARY_RELEASE)
@@ -75,6 +75,23 @@ IF(QT_QCONFIG MATCHES "system-png")
   SET(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${PNG_LIBRARY})
 ENDIF(QT_QCONFIG MATCHES "system-png")
 
+## system jpeg
+IF(QT_QCONFIG MATCHES "system-jpeg")
+  find_package(JPEG)
+  SET(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${JPEG_LIBRARIES})
+ENDIF(QT_QCONFIG MATCHES "system-jpeg")
+
+## system tiff
+IF(QT_QCONFIG MATCHES "system-tiff")
+  find_package(TIFF)
+  SET(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${TIFF_LIBRARIES})
+ENDIF(QT_QCONFIG MATCHES "system-tiff")
+
+## system mng
+IF(QT_QCONFIG MATCHES "system-mng")
+  find_library(MNG_LIBRARY NAMES mng)
+  SET(QT_QTGUI_LIB_DEPENDENCIES ${QT_QTGUI_LIB_DEPENDENCIES} ${MNG_LIBRARY})
+ENDIF(QT_QCONFIG MATCHES "system-mng")
 
 # for X11, get X11 library directory
 IF(Q_WS_X11)

Modules/Qt4Macros.cmake

@@ -71,12 +71,12 @@ MACRO (QT4_GET_MOC_FLAGS _moc_flags)
   GET_DIRECTORY_PROPERTY(_inc_DIRS INCLUDE_DIRECTORIES)
 
   FOREACH(_current ${_inc_DIRS})
-    IF("${_current}" MATCHES ".framework/?$")
-      STRING(REGEX REPLACE "/[^/]+.framework" "" framework_path "${_current}")
+    IF("${_current}" MATCHES "\\.framework/?$")
+      STRING(REGEX REPLACE "/[^/]+\\.framework" "" framework_path "${_current}")
       SET(${_moc_flags} ${${_moc_flags}} "-F${framework_path}")
-    ELSE("${_current}" MATCHES ".framework/?$")
+    ELSE("${_current}" MATCHES "\\.framework/?$")
       SET(${_moc_flags} ${${_moc_flags}} "-I${_current}")
-    ENDIF("${_current}" MATCHES ".framework/?$")
+    ENDIF("${_current}" MATCHES "\\.framework/?$")
   ENDFOREACH(_current ${_inc_DIRS})
 
   GET_DIRECTORY_PROPERTY(_defines COMPILE_DEFINITIONS)
@@ -196,11 +196,16 @@ MACRO (QT4_ADD_RESOURCES outfiles )
       ENDIF(NOT IS_ABSOLUTE "${_RC_FILE}")
       SET(_RC_DEPENDS ${_RC_DEPENDS} "${_RC_FILE}")
     ENDFOREACH(_RC_FILE)
+    # Since this cmake macro is doing the dependency scanning for these files,
+    # let's make a configured file and add it as a dependency so cmake is run
+    # again when dependencies need to be recomputed.
+    QT4_MAKE_OUTPUT_FILE("${infile}" "" "qrc.depends" out_depends)
+    CONFIGURE_FILE("${infile}" "${out_depends}" COPY_ONLY)
     ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
       COMMAND ${QT_RCC_EXECUTABLE}
       ARGS ${rcc_options} -name ${outfilename} -o ${outfile} ${infile}
       MAIN_DEPENDENCY ${infile}
-      DEPENDS ${_RC_DEPENDS})
+      DEPENDS ${_RC_DEPENDS} "${out_depends}")
     SET(${outfiles} ${${outfiles}} ${outfile})
   ENDFOREACH (it)
 

Source/CPack/cmCPackArchiveGenerator.cxx

@@ -105,12 +105,12 @@ if (!archive) \
   }
 
 //----------------------------------------------------------------------
-int cmCPackArchiveGenerator::PackageComponents(bool ignoreComponentGroup)
+int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup)
 {
   packageFileNames.clear();
   // The default behavior is to have one package by component group
   // unless CPACK_COMPONENTS_IGNORE_GROUP is specified.
-  if (!ignoreComponentGroup)
+  if (!ignoreGroup)
     {
     std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
     for (compGIt=this->ComponentGroups.begin();
@@ -170,7 +170,7 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreComponentGroup)
 }
 
 //----------------------------------------------------------------------
-int cmCPackArchiveGenerator::PackageComponentsAllInOne(bool allComponentInOne)
+int cmCPackArchiveGenerator::PackageComponentsAllInOne(bool allComponent)
 {
   // reset the package file names
   packageFileNames.clear();
@@ -185,7 +185,7 @@ int cmCPackArchiveGenerator::PackageComponentsAllInOne(bool allComponentInOne)
   DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
 
   // The ALL GROUP in ONE package case
-  if (! allComponentInOne) {
+  if (! allComponent) {
     // iterate over the component groups
     std::map<std::string, cmCPackComponentGroup>::iterator compGIt;
     for (compGIt=this->ComponentGroups.begin();
@@ -226,79 +226,28 @@ int cmCPackArchiveGenerator::PackageFiles()
   cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
                 << toplevel << std::endl);
 
-  // The default behavior is to create 1 package by component group
-  // unless the user asked to put all COMPONENTS in a single package
-  bool allGroupInOne = (NULL !=
-                        (this->GetOption(
-                          "CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE")));
-  bool allComponentInOne = (NULL !=
-                            (this->GetOption(
-                              "CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE")));
-  bool ignoreComponentGroup = ( NULL !=
-                                (this->GetOption(
-                                  "CPACK_COMPONENTS_IGNORE_GROUPS")));
+  PrepareGroupingKind();
 
-  std::string groupingType;
-
-  // Second way to specify grouping
-  if (NULL != this->GetOption("CPACK_COMPONENTS_GROUPING")) {
-     groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING");
+  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);
+      }
   }
 
-  if (groupingType.length()>0)
-    {
-    cmCPackLogger(cmCPackLog::LOG_VERBOSE,  "["
-        << this->Name << "]"
-        << " requested component grouping = "<< groupingType <<std::endl);
-    if (groupingType == "ALL_GROUP_IN_ONE")
-      {
-      allGroupInOne = true;
-      }
-    else if (groupingType == "ALL_COMPONENT_IN_ONE")
-      {
-      allComponentInOne = true;
-      }
-    else if (groupingType == "IGNORE")
-      {
-      ignoreComponentGroup = true;
-      }
-    else
-      {
-      cmCPackLogger(cmCPackLog::LOG_WARNING, "["
-              << this->Name << "]"
-              << " requested component grouping type <"<< groupingType
-              << "> UNKNOWN not in (ALL_GROUP_IN_ONE,"
-                    "ALL_COMPONENT_IN_ONE,IGNORE)" <<std::endl);
-      }
-    }
-
-  // Some components were defined but NO group
-  // force ignoreGroups
-  if (this->ComponentGroups.empty() && (!this->Components.empty())
-      && (!ignoreComponentGroup)) {
-    cmCPackLogger(cmCPackLog::LOG_WARNING, "["
-              << this->Name << "]"
-              << " Some Components defined but NO component group:"
-              << " Ignoring component group."
-              << std::endl);
-    ignoreComponentGroup = true;
-  }
-  // 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.
   DECLARE_AND_OPEN_ARCHIVE(packageFileNames[0],archive);
   std::vector<std::string>::const_iterator fileIt;
@@ -333,5 +282,15 @@ int cmCPackArchiveGenerator::GenerateHeader(std::ostream*)
 }
 
 bool cmCPackArchiveGenerator::SupportsComponentInstallation() const {
-  return true;
+  // The Component installation support should only
+  // be activated if explicitly requested by the user
+  // (for backward compatibility reason)
+  if (IsOn("CPACK_ARCHIVE_COMPONENT_INSTALL"))
+    {
+    return true;
+    }
+  else
+    {
+    return false;
+    }
 }

Source/CPack/cmCPackArchiveGenerator.h

@@ -60,12 +60,12 @@ protected:
    * install is used. This will create one
    * archive for each component group.
    */
-  int PackageComponents(bool ignoreComponentGroup);
+  int PackageComponents(bool ignoreGroup);
   /**
    * Special case of component install where all
    * components will be put in a single installer.
    */
-  int PackageComponentsAllInOne(bool allComponentInOne);
+  int PackageComponentsAllInOne(bool allComponent);
   virtual const char* GetOutputExtension() = 0;
   cmArchiveWrite::Compress Compress;
   cmArchiveWrite::Type Archive;

Source/CPack/cmCPackGenerator.cxx

@@ -35,6 +35,9 @@ cmCPackGenerator::cmCPackGenerator()
   this->GeneratorVerbose = false;
   this->MakefileMap = 0;
   this->Logger = 0;
+  this->allGroupInOne = false;
+  this->allComponentInOne = false;
+  this->ignoreComponentGroup = false;
 }
 
 //----------------------------------------------------------------------
@@ -220,7 +223,7 @@ int cmCPackGenerator::InstallProject()
 
   // If the CPackConfig file sets CPACK_INSTALLED_DIRECTORIES
   // then glob it and copy it to CPACK_TEMPORARY_DIRECTORY
-  // This is used in Source packageing
+  // This is used in Source packaging
   if ( !this->InstallProjectViaInstalledDirectories(
       setDestDir, tempInstallDirectory) )
     {
@@ -548,7 +551,14 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
       std::vector<std::string> componentsVector;
 
       bool componentInstall = false;
-      if (this->SupportsComponentInstallation())
+      /*
+       * We do a component install iff
+       *    - the CPack generator support component
+       *    - the user did not request Monolithic install
+       *      (this works at CPack time too)
+       */
+      if (this->SupportsComponentInstallation() &
+          !(this->IsSet("CPACK_MONOLITHIC_INSTALL")))
         {
         // Determine the installation types for this project (if provided).
         std::string installTypesVar = "CPACK_" 
@@ -691,7 +701,7 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
           //
           // If DESTDIR has been 'internally set ON' this means that
           // the underlying CPack specific generator did ask for that
-          // In this case we may overrode CPACK_INSTALL_PREFIX with
+          // In this case we may override CPACK_INSTALL_PREFIX with
           // CPACK_PACKAGING_INSTALL_PREFIX
           // I know this is tricky and awkward but it's the price for
           // CPACK_SET_DESTDIR backward compatibility.
@@ -727,7 +737,20 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
             {
             dir = tempInstallDirectory + "/" + dir;
             }
-
+          /*
+           *  We must re-set DESTDIR for each component
+           *  We must not add the CPACK_INSTALL_PREFIX part because
+           *  it will be added using the override of CMAKE_INSTALL_PREFIX
+           *  The main reason for this awkward trick is that
+           *  are using DESTDIR for 2 different reasons:
+           *     - Because it was asked by the CPack Generator or the user
+           *       using CPACK_SET_DESTDIR
+           *     - Because it was already used for component install
+           *       in order to put things in subdirs...
+           */
+          cmSystemTools::PutEnv(
+              (std::string("DESTDIR=")+tempInstallDirectory).c_str()
+                               );
           cmCPackLogger(cmCPackLog::LOG_DEBUG,
                         "- Creating directory: '" << dir << "'" << std::endl);
 
@@ -1047,7 +1070,13 @@ bool cmCPackGenerator::IsSet(const char* name) const
 }
 
 //----------------------------------------------------------------------
-const char* cmCPackGenerator::GetOption(const char* op)
+bool cmCPackGenerator::IsOn(const char* name) const
+{
+  return cmSystemTools::IsOn(GetOption(name));
+}
+
+//----------------------------------------------------------------------
+const char* cmCPackGenerator::GetOption(const char* op) const
 { 
   const char* ret = this->MakefileMap->GetDefinition(op);
   if(!ret)
@@ -1195,6 +1224,70 @@ int cmCPackGenerator::CleanTemporaryDirectory()
   return 1;
 }
 
+//----------------------------------------------------------------------
+int cmCPackGenerator::PrepareGroupingKind()
+{
+  // The default behavior is to create 1 package by component group
+  // unless the user asked to put all COMPONENTS in a single package
+  allGroupInOne = (NULL !=
+                    (this->GetOption(
+                      "CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE")));
+  allComponentInOne = (NULL !=
+                        (this->GetOption(
+                          "CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE")));
+  ignoreComponentGroup = (NULL !=
+                           (this->GetOption(
+                             "CPACK_COMPONENTS_IGNORE_GROUPS")));
+
+  std::string groupingType;
+
+  // Second way to specify grouping
+  if (NULL != this->GetOption("CPACK_COMPONENTS_GROUPING")) {
+     groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING");
+  }
+
+  if (groupingType.length()>0)
+    {
+    cmCPackLogger(cmCPackLog::LOG_VERBOSE,  "["
+        << this->Name << "]"
+        << " requested component grouping = "<< groupingType <<std::endl);
+    if (groupingType == "ALL_GROUP_IN_ONE")
+      {
+      allGroupInOne = true;
+      }
+    else if (groupingType == "ALL_COMPONENT_IN_ONE")
+      {
+      allComponentInOne = true;
+      }
+    else if (groupingType == "IGNORE")
+      {
+      ignoreComponentGroup = true;
+      }
+    else
+      {
+      cmCPackLogger(cmCPackLog::LOG_WARNING, "["
+              << this->Name << "]"
+              << " requested component grouping type <"<< groupingType
+              << "> UNKNOWN not in (ALL_GROUP_IN_ONE,"
+                    "ALL_COMPONENT_IN_ONE,IGNORE)" <<std::endl);
+      }
+    }
+
+  // Some components were defined but NO group
+  // force ignoreGroups
+  if (this->ComponentGroups.empty() && (!this->Components.empty())
+      && (!ignoreComponentGroup)) {
+    cmCPackLogger(cmCPackLog::LOG_WARNING, "["
+              << this->Name << "]"
+              << " Some Components defined but NO component group:"
+              << " Ignoring component group."
+              << std::endl);
+    ignoreComponentGroup = true;
+  }
+
+  return 1;
+}
+
 //----------------------------------------------------------------------
 bool cmCPackGenerator::SupportsComponentInstallation() const
 {

Source/CPack/cmCPackGenerator.h

@@ -88,8 +88,9 @@ public:
   //! Set and get the options
   void SetOption(const char* op, const char* value);
   void SetOptionIfNotSet(const char* op, const char* value);
-  const char* GetOption(const char* op);
+  const char* GetOption(const char* op) const;
   bool IsSet(const char* name) const;
+  bool IsOn(const char* name) const;
 
   //! Set all the variables
   int SetCMakeRoot();
@@ -119,6 +120,17 @@ protected:
   virtual const char* GetOutputExtension() { return ".cpack"; }
   virtual const char* GetOutputPostfix() { return 0; }
 
+  /**
+   * Prepare requested grouping kind from CPACK_xxx vars
+   * CPACK_COMPONENTS_ALL_GROUPS_IN_ONE_PACKAGE
+   * CPACK_COMPONENTS_ALL_IN_ONE_PACKAGE
+   * CPACK_COMPONENTS_IGNORE_GROUPS
+   * or
+   * CPACK_COMPONENTS_GROUPING
+   * @return 1 on success 0 on failure.
+   */
+  virtual int PrepareGroupingKind();
+
   /**
    * Package the list of files and/or components which
    * has been prepared by the beginning of DoPackage.
@@ -200,6 +212,20 @@ protected:
    */
   std::map<std::string, cmCPackComponent> Components;
   std::map<std::string, cmCPackComponentGroup> ComponentGroups;
+  /**
+   * If true All component groups will be put in a single package.
+   */
+  bool allGroupInOne;
+  /**
+   * If true All component will be put in a single package.
+   */
+  bool allComponentInOne;
+  /**
+   * If true component grouping will be ignored.
+   * You will still get 1 package for each component unless
+   * allComponentInOne is true.
+   */
+  bool ignoreComponentGroup;
 
   cmCPackLog* Logger;
 private:

Source/CPack/cmCPackRPMGenerator.cxx

@@ -37,13 +37,84 @@ int cmCPackRPMGenerator::InitializeInternal()
 //----------------------------------------------------------------------
 int cmCPackRPMGenerator::PackageFiles()
 {
-  this->ReadListFile("CPackRPM.cmake");
+  int retval = 1;
+  /* Digest Component grouping specification */
+  retval = PrepareGroupingKind();
+  cmCPackLogger(cmCPackLog::LOG_DEBUG, "Toplevel: "
+                  << toplevel << std::endl);
+
+  /* Are we in the component packaging case */
+  if (SupportsComponentInstallation() & (!this->ComponentGroups.empty()))
+    {
+    /* 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 )
+      {
+      std::string localToplevel(initialTopLevel);
+      std::string packageFileName(
+          cmSystemTools::GetParentDirectory(toplevel.c_str())
+                                 );
+      std::string outputFileName(
+          std::string(this->GetOption("CPACK_PACKAGE_FILE_NAME")
+                                )
+        +"-"+compIt->first + this->GetOutputExtension());
+
+      localToplevel += "/"+ compIt->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());
+
+      this->SetOption("CPACK_RPM_PACKAGE_COMPONENT",compIt->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);
+      }
+    }
+  /* This is the non component case */
+  else
+    {
+    if (!this->ReadListFile("CPackRPM.cmake"))
+      {
+      cmCPackLogger(cmCPackLog::LOG_ERROR,
+                    "Error while execution CPackRPM.cmake" << std::endl);
+      retval = 0;
+      }
+    }
+
   if (!this->IsSet("RPMBUILD_EXECUTABLE")) 
     {
     cmCPackLogger(cmCPackLog::LOG_ERROR, "Cannot find rpmbuild" << std::endl);
-    return 0;
+    retval = 0;
     }
-  return 1;
+  return retval;
 }
 
+bool cmCPackRPMGenerator::SupportsComponentInstallation() const
+  {
+  if (IsOn("CPACK_RPM_COMPONENT_INSTALL"))
+    {
+      return true;
+    }
+  else
+    {
+      return false;
+    }
+  }
 

Source/CPack/cmCPackRPMGenerator.h

@@ -39,6 +39,7 @@ protected:
   virtual int InitializeInternal();
   virtual int PackageFiles();
   virtual const char* GetOutputExtension() { return ".rpm"; }
+  virtual bool SupportsComponentInstallation() const;
 
 };
 

Source/CTest/cmCTestMultiProcessHandler.cxx

@@ -275,12 +275,6 @@ void cmCTestMultiProcessHandler::StartNextTests()
         }
       numToStart -= processors;
       }
-    else
-      {
-      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, std::endl
-                 << "Test did not start waiting on depends to finish: "
-                 << *test << "\n");
-      }
     if(numToStart == 0)
       {
       return;

Source/CTest/cmCTestSleepCommand.h

@@ -63,11 +63,10 @@ public:
   virtual const char* GetFullDocumentation()
     {
     return
-      "  ctest_sleep( seconds )\n"
-      "  ctest_sleep( time1 duration time2 )\n"
-      "With one argument it will sleep for a given number of seconds. "
-      "With three arguments it will wait for time2 - time1 - duration "
-      "seconds.";
+      "  ctest_sleep(<seconds>)\n"
+      "Sleep for given number of seconds.\n"
+      "  ctest_sleep(<time1> <duration> <time2>)\n"
+      "Sleep for t=(time1 + duration - time2) seconds if t > 0.";
     }
 
   cmTypeMacro(cmCTestSleepCommand, cmCTestCommand);

Source/CTest/cmCTestTestHandler.cxx

@@ -2190,7 +2190,6 @@ bool cmCTestTestHandler::SetTestsProperties(
               {
               rtit->Labels.push_back(*crit);
               }
-            
             }
           if ( key == "MEASUREMENT" )
             {
@@ -2219,6 +2218,10 @@ bool cmCTestTestHandler::SetTestsProperties(
                   std::string(crit->c_str())));
               }
             }
+          if ( key == "WORKING_DIRECTORY" )
+            {
+            rtit->Directory = val;
+            }
           }
         }
       }

Source/QtDialog/CMakeIngestOSXBundleLibraries.cmake

@@ -1,347 +0,0 @@
-#
-# CMakeIngestOSXBundleLibraries.cmake
-#
-# Only for the Mac build.
-#
-# Depends on OS tools:
-#   otool
-#   install_name_tool
-#
-# This script ingests libraries and frameworks into an existing .app bundle and
-# then uses install_name_tool to fixup the references to the newly embedded
-# libraries so that they all refer to each other via "@executable_path."
-#
-# The main intent (and simplifying assumption used for developing the script)
-# is to have a single executable .app bundle that becomes "self-contained" by
-# copying all non-system libs that it depends on into itself. The further
-# assumption is that all such dependencies are simple .dylib shared library
-# files or Mac Framework libraries.
-#
-# This script can be used as part of the build via ADD_CUSTOM_COMMAND, or used
-# only during make install via INSTALL SCRIPT.
-#
-if(NOT DEFINED input_file)
-  message(FATAL_ERROR "
-${CMAKE_CURRENT_LIST_FILE}(${CMAKE_CURRENT_LIST_LINE}): error: Variable input_file is not defined.
-
-Use a command line like this to use this script:
-  cmake \"-Dinput_file=filename\" \"-Dextra_libs=/path/to/lib1;/path/to/lib2\" \"-Dlib_path=/path/to/unqualified/libs\" -P \"${CMAKE_CURRENT_LIST_FILE}\"
-
-'input_file' should be the main executable inside a Mac bundle directory structure.
-For example, use 'bin/paraview.app/Contents/MacOS/paraview' from a ParaView binary dir.
-
-'extra_libs' should be a semi-colon separated list of full path names to extra libraries
-to copy into the bundle that cannot be derived from otool -L output. For example, you may
-also want to fixup dynamically loaded plugins from your build tree and copy them into the
-bundle.
-
-'lib_path' should be the path where to find libraries referenced without a path name in
-otool -L output.
-
-")
-endif(NOT DEFINED input_file)
-message("ingest ${input_file}")
-set(eol_char "E")
-
-if(APPLE)
-  set(dep_tool "otool")
-  set(dep_cmd_args "-L")
-  set(dep_regex "^\t([^\t]+) \\(compatibility version ([0-9]+.[0-9]+.[0-9]+), current version ([0-9]+.[0-9]+.[0-9]+)\\)${eol_char}$")
-endif(APPLE)
-
-message("")
-message("# Script \"${CMAKE_CURRENT_LIST_FILE}\" running...")
-message("")
-message("input_file: '${input_file}'")
-message("extra_libs: '${extra_libs}'")
-message("lib_path: '${lib_path}'")
-message("")
-
-get_filename_component(input_file_full "${input_file}" ABSOLUTE)
-message("input_file_full: '${input_file_full}'")
-
-get_filename_component(bundle "${input_file_full}/../../.." ABSOLUTE)
-message("bundle: '${bundle}'")
-
-
-find_program(dep_cmd ${dep_tool})
-
-# find the full path to the framework in path set the result
-# in pathout
-macro(find_framework_full_path path pathout)
-  set(${pathout} "${path}")
-  if(NOT EXISTS "${path}")
-    set(FRAMEWORK_SEARCH "/Library/Frameworks"
-      "/System/Library/Frameworks" )
-    set(__FOUND FALSE)
-    foreach(f ${FRAMEWORK_SEARCH})
-      set(newd "${f}/${path}")
-      if(EXISTS "${newd}" AND NOT __FOUND)
-        set(${pathout} "${newd}")
-        set(__FOUND TRUE)
-      endif(EXISTS "${newd}" AND NOT __FOUND)
-    endforeach(f)
-  endif(NOT EXISTS "${path}")
-endmacro(find_framework_full_path)
-
-
-macro(append_unique au_list_var au_value)
-  set(${au_list_var} ${${au_list_var}} "${au_value}")
-endmacro(append_unique)
-
-
-macro(gather_dependents gd_target gd_dependents_var)
-  execute_process(
-    COMMAND ${dep_cmd} ${dep_cmd_args} ${gd_target}
-    OUTPUT_VARIABLE dep_tool_ov
-    )
-
-  string(REGEX REPLACE ";" "\\\\;" dep_candidates "${dep_tool_ov}")
-  string(REGEX REPLACE "\n" "${eol_char};" dep_candidates "${dep_candidates}")
-
-  set(${gd_dependents_var} "")
-
-  foreach(candidate ${dep_candidates})
-  if("${candidate}" MATCHES "${dep_regex}")
-    string(REGEX REPLACE "${dep_regex}" "\\1" raw_item "${candidate}")
-    string(REGEX REPLACE "${dep_regex}" "\\2" raw_compat_version "${candidate}")
-    string(REGEX REPLACE "${dep_regex}" "\\3" raw_current_version "${candidate}")
-
-    set(item "${raw_item}")
-
-    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" compat_major_version "${raw_compat_version}")
-    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" compat_minor_version "${raw_compat_version}")
-    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" compat_patch_version "${raw_compat_version}")
-
-    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" current_major_version "${raw_current_version}")
-    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" current_minor_version "${raw_current_version}")
-    string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" current_patch_version "${raw_current_version}")
-
-    #message("${raw_item} - compat ${raw_compat_version} - current ${raw_current_version}")
-    append_unique("${gd_dependents_var}" "${item}")
-  else("${candidate}" MATCHES "${dep_regex}")
-    if("${candidate}" STREQUAL "${gd_target}:${eol_char}")
-      #message("info: ignoring target name...")
-    else("${candidate}" STREQUAL "${gd_target}:${eol_char}")
-      message("error: candidate='${candidate}'")
-    endif("${candidate}" STREQUAL "${gd_target}:${eol_char}")
-  endif("${candidate}" MATCHES "${dep_regex}")
-  endforeach(candidate)
-endmacro(gather_dependents)
-
-
-message("Gathering dependent libraries for '${input_file_full}'...")
-gather_dependents("${input_file_full}" deps)
-message("")
-
-
-# Order lexicographically:
-#
-list(SORT deps)
-
-
-# Split into separate lists, "system" "embedded" and "nonsystem" libraries.
-# System libs are assumed to be available on all target runtime Macs and do not
-# need to be copied/fixed-up by this script. Embedded libraries are assumed to
-# be in the bundle and fixed-up already. Only non-system, non-embedded libs
-# need copying and fixing up...
-#
-set(system_deps "")
-set(embedded_deps "")
-set(nonsystem_deps "")
-
-foreach(d ${deps})
-  set(d_is_embedded_lib 0)
-  set(d_is_system_lib 0)
-
-  if("${d}" MATCHES "^(/System/Library|/usr/lib)")
-    set(d_is_system_lib 1)
-  else("${d}" MATCHES "^(/System/Library|/usr/lib)")
-    if("${d}" MATCHES "^@executable_path")
-      set(d_is_embedded_lib 1)
-    endif("${d}" MATCHES "^@executable_path")
-  endif("${d}" MATCHES "^(/System/Library|/usr/lib)")
-
-  if(d_is_system_lib)
-    set(system_deps ${system_deps} "${d}")
-  else(d_is_system_lib)
-    if(d_is_embedded_lib)
-      set(embedded_deps ${embedded_deps} "${d}")
-    else(d_is_embedded_lib)
-      set(nonsystem_deps ${nonsystem_deps} "${d}")
-    endif(d_is_embedded_lib)
-  endif(d_is_system_lib)
-endforeach(d)
-
-message("")
-message("system_deps:")
-foreach(d ${system_deps})
-  message("${d}")
-endforeach(d ${system_deps})
-
-message("")
-message("embedded_deps:")
-foreach(d ${embedded_deps})
-  message("${d}")
-endforeach(d ${embedded_deps})
-
-message("")
-message("nonsystem_deps:")
-foreach(d ${nonsystem_deps})
-  message("${d}")
-endforeach(d ${nonsystem_deps})
-
-message("")
-
-
-macro(copy_library_into_bundle clib_bundle clib_libsrc clib_dstlibs clib_fixups)
-  #
-  # If the source library is a framework, copy just the shared lib bit of the framework
-  # into the bundle under "${clib_bundle}/Contents/Frameworks" - if it is just a dylib
-  # copy it into the same directory with the main bundle executable under
-  # "${clib_bundle}/Contents/MacOS"
-  #
-  if("${clib_libsrc}" MATCHES ".framework/.*/.*/.*")
-    # make sure clib_libsrc is a full path to the framework as a framework
-    # maybe linked in with relative paths in some cases
-    find_framework_full_path("${clib_libsrc}" fw_full_src)
-    get_filename_component(fw_src "${fw_full_src}" ABSOLUTE)
-    get_filename_component(fw_srcdir "${clib_libsrc}/../../.." ABSOLUTE)
-    get_filename_component(fwdirname "${fw_srcdir}" NAME)
-    string(REGEX REPLACE "^(.*)\\.framework$" "\\1" fwname "${fwdirname}")
-    string(REGEX REPLACE "^.*/${fwname}\\.framework/(.*)$" "\\1" fwlibname "${clib_libsrc}")
-    set(fw_dstdir "${clib_bundle}/Contents/Frameworks")
-
-#     message("")
-#     message("fwdirname: '${fwdirname}'")
-#     message("fwname: '${fwname}'")
-#     message("fwlibname: '${fwlibname}'")
-#     message("fw_src: '${fw_src}'")
-#     message("fw_srcdir: '${fw_srcdir}'")
-#     message("fw_dstdir: '${fw_dstdir}'")
-#     message("new_name: '@executable_path/../Frameworks/${fwdirname}/${fwlibname}'")
-#     message("")
-
-    message("Copying ${fw_srcdir} into bundle...")
-
-    # This command copies the *entire* framework recursively:
-    #
-#    execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory
-#      "${fw_srcdir}" "${fw_dstdir}"
-#    )
-
-    # This command copies just the main shared lib of the framework:
-    # (This technique will not work for frameworks that have necessary
-    # resource or auxiliary files...)
-    #
-    message("fw_src = [${fw_src}]   fw_full_src = [${fw_full_src}]")
-    message("Copy: ${CMAKE_COMMAND} -E copy \"${fw_src}\"  \"${fw_dstdir}/${fwlibname}\"")
-    execute_process(COMMAND ${CMAKE_COMMAND} -E copy
-      "${fw_src}" "${fw_dstdir}/${fwlibname}"
-    )
-
-    get_filename_component(fw_src_path "${fw_src}" PATH)
-    message("Checking ${fw_src_path}/Resources")
-    if(EXISTS "${fw_src_path}/Resources")
-      message("Copy: ${CMAKE_COMMAND} -E copy_directory \"${fw_src_path}/Resources/\"  \"${fw_dstdir}/Resources/\"")
-      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory
-        "${fw_src_path}/Resources/" "${fw_dstdir}/${fwdirname}/Resources/")
-    endif(EXISTS "${fw_src_path}/Resources")
-
-    execute_process(COMMAND install_name_tool
-      -id "@executable_path/../Frameworks/${fwlibname}"
-      "${clib_bundle}/Contents/Frameworks/${fwlibname}"
-    )
-    set(${clib_dstlibs} ${${clib_dstlibs}}
-      "${clib_bundle}/Contents/Frameworks/${fwlibname}"
-    )
-    set(${clib_fixups} ${${clib_fixups}}
-      "-change"
-      "${clib_libsrc}"
-      "@executable_path/../Frameworks/${fwlibname}"
-    )
-  else("${clib_libsrc}" MATCHES ".framework/.*/.*/.*")
-    if("${clib_libsrc}" MATCHES "/")
-      set(clib_libsrcfull "${clib_libsrc}")
-    else("${clib_libsrc}" MATCHES "/")
-      set(clib_libsrcfull "${lib_path}/${clib_libsrc}")
-      if(NOT EXISTS "${clib_libsrcfull}")
-        message(FATAL_ERROR "error: '${clib_libsrcfull}' does not exist...")
-      endif(NOT EXISTS "${clib_libsrcfull}")
-    endif("${clib_libsrc}" MATCHES "/")
-
-    get_filename_component(dylib_src "${clib_libsrcfull}" ABSOLUTE)
-    get_filename_component(dylib_name "${dylib_src}" NAME)
-    set(dylib_dst "${clib_bundle}/Contents/MacOS/${dylib_name}")
-
-#    message("dylib_src: ${dylib_src}")
-#    message("dylib_dst: ${dylib_dst}")
-#    message("new_name: '@executable_path/${dylib_name}'")
-
-    message("Copying ${dylib_src} into bundle...")
-    execute_process(COMMAND ${CMAKE_COMMAND} -E copy
-      "${dylib_src}" "${dylib_dst}")
-    execute_process(COMMAND install_name_tool
-      -id "@executable_path/${dylib_name}"
-      "${dylib_dst}"
-    )
-    set(${clib_dstlibs} ${${clib_dstlibs}}
-      "${dylib_dst}"
-    )
-    set(${clib_fixups} ${${clib_fixups}}
-      "-change"
-      "${clib_libsrc}"
-      "@executable_path/${dylib_name}"
-    )
-  endif("${clib_libsrc}" MATCHES ".framework/.*/.*/.*")
-endmacro(copy_library_into_bundle)
-
-
-# Copy dependent "nonsystem" libraries into the bundle:
-#
-message("Copying dependent libraries into bundle...")
-set(srclibs ${nonsystem_deps} ${extra_libs})
-set(dstlibs "")
-set(fixups "")
-foreach(d ${srclibs})
-  message("copy it --- ${d}")
-  copy_library_into_bundle("${bundle}" "${d}" dstlibs fixups)
-endforeach(d)
-
-message("")
-message("dstlibs='${dstlibs}'")
-message("")
-message("fixups='${fixups}'")
-message("")
-
-
-# Fixup references to copied libraries in the main bundle executable and in the
-# copied libraries themselves:
-#
-if(NOT "${fixups}" STREQUAL "")
-  message("Fixing up references...")
-  foreach(d ${dstlibs} "${input_file_full}")
-    message("fixing up references in: '${d}'")
-    execute_process(COMMAND install_name_tool ${fixups} "${d}")
-  endforeach(d)
-  message("")
-endif(NOT "${fixups}" STREQUAL "")
-
-
-# List all references to eyeball them and make sure they look right:
-#
-message("Listing references...")
-foreach(d ${dstlibs} "${input_file_full}")
-  execute_process(COMMAND otool -L "${d}")
-  message("")
-endforeach(d)
-message("")
-
-
-# Output file:
-#
-#get_filename_component(script_name "${CMAKE_CURRENT_LIST_FILE}" NAME)
-#file(WRITE "${input_file_full}_${script_name}" "# Script \"${CMAKE_CURRENT_LIST_FILE}\" completed.\n")
-message("")
-message("# Script \"${CMAKE_CURRENT_LIST_FILE}\" completed.")
-message("")

Source/QtDialog/CMakeLists.txt

@@ -19,13 +19,6 @@ ELSE(NOT QT4_FOUND)
 
   INCLUDE(${QT_USE_FILE})
   SET(CMAKE_PACKAGE_QTGUI TRUE)
-  # i don't want to install or package the qt gui on windows 
-  # unless qt is static
-  IF(WIN32 AND NOT QT_CONFIG MATCHES "static")
-    SET(CMAKE_PACKAGE_QTGUI FALSE)
-    MESSAGE(STATUS 
-      "WARNING: QtDialog requires a static built qt for installation.")
-  ENDIF(WIN32 AND NOT QT_CONFIG MATCHES "static")
   SET(SRCS
     AddCacheEntry.cxx
     AddCacheEntry.h
@@ -86,12 +79,8 @@ ELSE(NOT QT4_FOUND)
     SET(CMAKE_INSTALL_DESTINATION_ARGS 
       BUNDLE DESTINATION "${CMAKE_BUNDLE_LOCATION}")
   ENDIF(${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION} GREATER 2.4)
-  # if qt is not static and we are on windows then skip the install
-  # I don't want to distribute qt dlls
-  IF(CMAKE_PACKAGE_QTGUI)
-    INSTALL(TARGETS cmake-gui RUNTIME DESTINATION bin
-    ${CMAKE_INSTALL_DESTINATION_ARGS})
-  ENDIF(CMAKE_PACKAGE_QTGUI)
+
+  INSTALL(TARGETS cmake-gui RUNTIME DESTINATION bin ${CMAKE_INSTALL_DESTINATION_ARGS})
 
   IF(UNIX)
     # install a desktop file so CMake appears in the application start menu
@@ -112,10 +101,21 @@ ELSE(NOT QT4_FOUND)
       "${CMake_BINARY_DIR}/Source/QtDialog/postupgrade.sh")
     INSTALL(CODE "execute_process(COMMAND ln -s \"../MacOS/${CMAKE_BUNDLE_NAME}\" cmake-gui
                   WORKING_DIRECTORY \$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/bin)")
-    INSTALL(CODE "set(input_file
-       \"\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/MacOS/${CMAKE_BUNDLE_NAME}\")")
-    INSTALL(SCRIPT "${CMake_SOURCE_DIR}/Source/QtDialog/CMakeIngestOSXBundleLibraries.cmake")
   ENDIF(APPLE)
+
+  if(APPLE OR WIN32)
+    # install rules for including 3rd party libs such as Qt
+    # if a system Qt is used (e.g. installed in /usr/lib/), it will not be included in the installation
+    set(fixup_exe "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/bin/cmake-gui${CMAKE_EXECUTABLE_SUFFIX}")
+    if(APPLE)
+      set(fixup_exe "\$ENV{DESTDIR}\${CMAKE_INSTALL_PREFIX}/MacOS/${CMAKE_BUNDLE_NAME}")
+    endif(APPLE)
+    install(CODE "
+      include(\"${CMake_SOURCE_DIR}/Modules/BundleUtilities.cmake\")
+      fixup_bundle(\"${fixup_exe}\" \"\" \"${QT_LIBRARY_DIR};${QT_BINARY_DIR}\")
+    ")
+  endif(APPLE OR WIN32)
+
   CONFIGURE_FILE("${QtDialog_SOURCE_DIR}/QtDialogCPack.cmake.in"
     "${QtDialog_BINARY_DIR}/QtDialogCPack.cmake" @ONLY)    
 ENDIF(NOT QT4_FOUND)

Source/QtDialog/CMakeSetup.cxx

@@ -165,13 +165,25 @@ int main(int argc, char** argv)
     if(args.count() == 2)
       {
       cmsys_stl::string filePath = cmSystemTools::CollapseFullPath(args[1].toAscii().data());
+
+      // check if argument is a directory containing CMakeCache.txt
       cmsys_stl::string buildFilePath =
         cmSystemTools::CollapseFullPath("CMakeCache.txt", filePath.c_str());
+
+      // check if argument is a CMakeCache.txt file
+      if(cmSystemTools::GetFilenameName(filePath) == "CMakeCache.txt" &&
+         cmSystemTools::FileExists(filePath.c_str()))
+        {
+        buildFilePath = filePath;
+        }
+
+      // check if argument is a directory containing CMakeLists.txt
       cmsys_stl::string srcFilePath =
         cmSystemTools::CollapseFullPath("CMakeLists.txt", filePath.c_str());
+
       if(cmSystemTools::FileExists(buildFilePath.c_str()))
         {
-        dialog.setBinaryDirectory(filePath.c_str());
+        dialog.setBinaryDirectory(cmSystemTools::GetFilenamePath(buildFilePath).c_str());
         }
       else if(cmSystemTools::FileExists(srcFilePath.c_str()))
         {

Source/cmAddCustomCommandCommand.cxx

@@ -161,6 +161,7 @@ bool cmAddCustomCommandCommand
             filename += "/";
             }
           filename += copy;
+          cmSystemTools::ConvertToUnixSlashes(filename);
           break;
         case doing_source:
           // We do not want to convert the argument to SOURCE because

Source/cmAddCustomCommandCommand.h

@@ -152,6 +152,9 @@ public:
       "If any dependency is an OUTPUT of another custom command in the "
       "same directory (CMakeLists.txt file) CMake automatically brings the "
       "other custom command into the target in which this command is built.  "
+      "If DEPENDS is not specified the command will run whenever the OUTPUT "
+      "is missing; if the command does not actually create the OUTPUT then "
+      "the rule will always run.  "
       "If DEPENDS specifies any target (created by an ADD_* command) "
       "a target-level dependency is created to make sure the target is "
       "built before any target using this custom command.  Additionally, "

Source/cmAddDependenciesCommand.cxx

@@ -24,11 +24,7 @@ bool cmAddDependenciesCommand
     }
 
   std::string target_name = args[0];
-
-  cmTarget* target = 
-    this->GetMakefile()->GetLocalGenerator()->
-    GetGlobalGenerator()->FindTarget(0, target_name.c_str());
-  if(target)
+  if(cmTarget* target = this->Makefile->FindTargetToUse(target_name.c_str()))
     {
     std::vector<std::string>::const_iterator s = args.begin();
     ++s; // skip over target_name

Source/cmAddDependenciesCommand.h

@@ -62,6 +62,8 @@ public:
       "top-level target is one created by ADD_EXECUTABLE, ADD_LIBRARY, "
       "or ADD_CUSTOM_TARGET.  Adding dependencies with this command "
       "can be used to make sure one target is built before another target.  "
+      "Dependencies added to an IMPORTED target are followed transitively "
+      "in its place since the target itself does not build.  "
       "See the DEPENDS option of ADD_CUSTOM_TARGET "
       "and ADD_CUSTOM_COMMAND for adding file-level dependencies in custom "
       "rules.  See the OBJECT_DEPENDS option in "

Source/cmCacheManager.cxx

@@ -93,14 +93,14 @@ bool cmCacheManager::LoadCache(const char* path,
   return this->LoadCache(path, internal, emptySet, emptySet);
 }
 
-bool cmCacheManager::ParseEntry(const char* entry,
-                                std::string& var,
-                                std::string& value)
+static bool ParseEntryWithoutType(const char* entry,
+                                  std::string& var,
+                                  std::string& value)
 {
-  // input line is:         key:type=value
+  // input line is:         key=value
   static cmsys::RegularExpression reg(
-    "^([^:]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
-  // input line is:         "key":type=value
+    "^([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
+  // input line is:         "key"=value
   static cmsys::RegularExpression regQuoted(
     "^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
   bool flag = false;
@@ -169,6 +169,11 @@ bool cmCacheManager::ParseEntry(const char* entry,
                          value.size() - 2);
     }
 
+  if (!flag)
+    {
+    return ParseEntryWithoutType(entry, var, value);
+    }
+
   return flag;
 }
 
@@ -336,7 +341,7 @@ bool cmCacheManager::LoadCache(const char* path,
         std::string("The current CMakeCache.txt directory ") +
         currentcwd + std::string(" is different than the directory ") +
         std::string(this->GetCacheValue("CMAKE_CACHEFILE_DIR")) +
-        std::string(" where CMackeCache.txt was created. This may result "
+        std::string(" where CMakeCache.txt was created. This may result "
                     "in binaries being created in the wrong place. If you "
                     "are not sure, reedit the CMakeCache.txt");
       cmSystemTools::Error(message.c_str());

Source/cmCacheManager.h

@@ -139,10 +139,6 @@ public:
                          std::string& value,
                          CacheEntryType& type);
 
-  static bool ParseEntry(const char* entry, 
-                         std::string& var,
-                         std::string& value);
-
   ///! Get a value from the cache given a key
   const char* GetCacheValue(const char* key) const;
 

Source/cmComputeLinkInformation.cxx

@@ -923,7 +923,7 @@ void cmComputeLinkInformation::ComputeItemParserInfo()
 //----------------------------------------------------------------------------
 void cmComputeLinkInformation::AddLinkPrefix(const char* p)
 {
-  if(p)
+  if(p && *p)
     {
     this->LinkPrefixes.insert(p);
     }

Source/cmComputeTargetDepends.cxx

@@ -144,7 +144,7 @@ bool cmComputeTargetDepends::Compute()
 //----------------------------------------------------------------------------
 void
 cmComputeTargetDepends::GetTargetDirectDepends(cmTarget* t,
-                                               std::set<cmTarget*>& deps)
+                                               cmTargetDependSet& deps)
 {
   // Lookup the index for this target.  All targets should be known by
   // this point.
@@ -156,7 +156,9 @@ cmComputeTargetDepends::GetTargetDirectDepends(cmTarget* t,
   EdgeList const& nl = this->FinalGraph[i];
   for(EdgeList::const_iterator ni = nl.begin(); ni != nl.end(); ++ni)
     {
-    deps.insert(this->Targets[*ni]);
+    cmTarget* dep = this->Targets[*ni];
+    cmTargetDependSet::iterator di = deps.insert(dep).first;
+    di->SetType(ni->IsStrong());
     }
 }
 
@@ -244,13 +246,7 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
 
   // Check the target's makefile first.
   cmTarget* dependee =
-    depender->GetMakefile()->FindTarget(dependee_name);
-
-  // Then search globally.
-  if(!dependee)
-    {
-    dependee = this->GlobalGenerator->FindTarget(0, dependee_name);
-    }
+    depender->GetMakefile()->FindTargetToUse(dependee_name);
 
   // Skip targets that will not really be linked.  This is probably a
   // name conflict between an external library and an executable
@@ -262,25 +258,42 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index,
     dependee = 0;
     }
 
-  // If not found then skip then the dependee.
-  if(!dependee)
+  if(dependee)
     {
-    return;
+    this->AddTargetDepend(depender_index, dependee, linking);
     }
+}
 
-  // No imported targets should have been found.
-  assert(!dependee->IsImported());
+//----------------------------------------------------------------------------
+void cmComputeTargetDepends::AddTargetDepend(int depender_index,
+                                             cmTarget* dependee,
+                                             bool linking)
+{
+  if(dependee->IsImported())
+    {
+    // Skip imported targets but follow their utility dependencies.
+    std::set<cmStdString> const& utils = dependee->GetUtilities();
+    for(std::set<cmStdString>::const_iterator i = utils.begin();
+        i != utils.end(); ++i)
+      {
+      cmTarget* transitive_dependee =
+        dependee->GetMakefile()->FindTargetToUse(i->c_str());
+      this->AddTargetDepend(depender_index, transitive_dependee, false);
+      }
+    }
+  else
+    {
+    // Lookup the index for this target.  All targets should be known by
+    // this point.
+    std::map<cmTarget*, int>::const_iterator tii =
+      this->TargetIndex.find(dependee);
+    assert(tii != this->TargetIndex.end());
+    int dependee_index = tii->second;
 
-  // Lookup the index for this target.  All targets should be known by
-  // this point.
-  std::map<cmTarget*, int>::const_iterator tii =
-    this->TargetIndex.find(dependee);
-  assert(tii != this->TargetIndex.end());
-  int dependee_index = tii->second;
-
-  // Add this entry to the dependency graph.
-  this->InitialGraph[depender_index].push_back(
-    cmGraphEdge(dependee_index, !linking));
+    // Add this entry to the dependency graph.
+    this->InitialGraph[depender_index].push_back(
+      cmGraphEdge(dependee_index, !linking));
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -445,7 +458,7 @@ cmComputeTargetDepends
       int j = *ei;
       if(cmap[j] == c && ei->IsStrong())
         {
-        this->FinalGraph[i].push_back(j);
+        this->FinalGraph[i].push_back(cmGraphEdge(j, true));
         if(!this->IntraComponent(cmap, c, j, head, emitted, visited))
           {
           return false;
@@ -456,7 +469,7 @@ cmComputeTargetDepends
     // Prepend to a linear linked-list of intra-component edges.
     if(*head >= 0)
       {
-      this->FinalGraph[i].push_back(*head);
+      this->FinalGraph[i].push_back(cmGraphEdge(*head, false));
       }
     else
       {
@@ -515,7 +528,7 @@ cmComputeTargetDepends
       int dependee_component = *ni;
       int dependee_component_head = this->ComponentHead[dependee_component];
       this->FinalGraph[depender_component_tail]
-        .push_back(dependee_component_head);
+        .push_back(cmGraphEdge(dependee_component_head, ni->IsStrong()));
       }
     }
   return true;

Source/cmComputeTargetDepends.h

@@ -21,6 +21,7 @@
 class cmComputeComponentGraph;
 class cmGlobalGenerator;
 class cmTarget;
+class cmTargetDependSet;
 
 /** \class cmComputeTargetDepends
  * \brief Compute global interdependencies among targets.
@@ -38,13 +39,14 @@ public:
   bool Compute();
 
   std::vector<cmTarget*> const& GetTargets() const { return this->Targets; }
-  void GetTargetDirectDepends(cmTarget* t, std::set<cmTarget*>& deps);
+  void GetTargetDirectDepends(cmTarget* t, cmTargetDependSet& deps);
 private:
   void CollectTargets();
   void CollectDepends();
   void CollectTargetDepends(int depender_index);
   void AddTargetDepend(int depender_index, const char* dependee_name,
                        bool linking);
+  void AddTargetDepend(int depender_index, cmTarget* dependee, bool linking);
   bool ComputeFinalDepends(cmComputeComponentGraph const& ccg);
 
   cmGlobalGenerator* GlobalGenerator;

Source/cmCoreTryCompile.cxx

@@ -169,8 +169,9 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
     const char* lang =(this->Makefile->GetCMakeInstance()->GetGlobalGenerator()
                         ->GetLanguageFromExtension(ext.c_str()));
     const char* def = this->Makefile->GetDefinition("CMAKE_MODULE_PATH");
-    fprintf(fout, "cmake_minimum_required(VERSION %u.%u)\n",
-            cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion());
+    fprintf(fout, "cmake_minimum_required(VERSION %u.%u.%u.%u)\n",
+            cmVersion::GetMajorVersion(), cmVersion::GetMinorVersion(),
+            cmVersion::GetPatchVersion(), cmVersion::GetTweakVersion());
     if(def)
       {
       fprintf(fout, "SET(CMAKE_MODULE_PATH %s)\n", def);
@@ -394,28 +395,18 @@ void cmCoreTryCompile::CleanupFiles(const char* binDir)
           }
         else
           {
-          if(!cmSystemTools::RemoveFile(fullPath.c_str()))
+          // Sometimes anti-virus software hangs on to new files so we
+          // cannot delete them immediately.  Try a few times.
+          int tries = 5;
+          while(!cmSystemTools::RemoveFile(fullPath.c_str()) &&
+                --tries && cmSystemTools::FileExists(fullPath.c_str()))
             {
-            bool removed = false;
-            int numAttempts = 0;
-            // sometimes anti-virus software hangs on to
-            // new files and we can not delete them, so try
-            // 5 times with .5 second delay between tries.
-            while(!removed && numAttempts < 5)
-              {
-              cmSystemTools::Delay(500);
-              if(cmSystemTools::RemoveFile(fullPath.c_str()))
-                {
-                removed = true;
-                }
-              numAttempts++;
-              }
-            if(!removed)
-              {
-              std::string m = "Remove failed on file: ";
-              m += fullPath;
-              cmSystemTools::ReportLastSystemError(m.c_str());
-              }
+            cmSystemTools::Delay(500);
+            }
+          if(tries == 0)
+            {
+            std::string m = "Remove failed on file: " + fullPath;
+            cmSystemTools::ReportLastSystemError(m.c_str());
             }
           }
         }

Source/cmDocumentVariables.cxx

@@ -1336,6 +1336,29 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
     "this variable is defined to 1.",
     false,"Variables for Languages");
 
+  cm->DefineProperty(
+    "CMAKE_Fortran_MODDIR_FLAG", cmProperty::VARIABLE,
+    "Fortran flag for module output directory.",
+    "This stores the flag needed to pass the value of the "
+    "Fortran_MODULE_DIRECTORY target property to the compiler.",
+    false,"Variables for Languages");
+
+  cm->DefineProperty(
+    "CMAKE_Fortran_MODDIR_DEFAULT", cmProperty::VARIABLE,
+    "Fortran default module output directory.",
+    "Most Fortran compilers write .mod files to the current working "
+    "directory.  "
+    "For those that do not, this is set to \".\" and used when the "
+    "Fortran_MODULE_DIRECTORY target property is not set.",
+    false,"Variables for Languages");
+
+  cm->DefineProperty(
+    "CMAKE_Fortran_MODOUT_FLAG", cmProperty::VARIABLE,
+    "Fortran flag to enable module output.",
+    "Most Fortran compilers write .mod files out by default.  "
+    "For others, this stores the flag needed to enable module output.",
+    false,"Variables for Languages");
+
   // variables that are used by cmake but not to be documented
   cm->DefineProperty("CMAKE_MATCH_0", cmProperty::VARIABLE,0,0);
   cm->DefineProperty("CMAKE_MATCH_1", cmProperty::VARIABLE,0,0);

Source/cmExtraCodeBlocksGenerator.cxx

@@ -23,7 +23,7 @@
 #include <cmsys/SystemTools.hxx>
 
 /* Some useful URLs:
-Homepage: 
+Homepage:
 http://www.codeblocks.org
 
 File format docs:
@@ -63,16 +63,6 @@ cmExtraCodeBlocksGenerator::cmExtraCodeBlocksGenerator()
 }
 
 
-void cmExtraCodeBlocksGenerator::SetGlobalGenerator(
-                                                  cmGlobalGenerator* generator)
-{
-  cmExternalMakefileProjectGenerator::SetGlobalGenerator(generator);
-  cmGlobalUnixMakefileGenerator3* mf = (cmGlobalUnixMakefileGenerator3*)
-                                                                     generator;
-  mf->SetToolSupportsColor(false);
-  mf->SetForceVerboseMakefiles(true);
-}
-
 void cmExtraCodeBlocksGenerator::Generate()
 {
   // for each sub project in the project create a codeblocks project
@@ -107,7 +97,7 @@ void cmExtraCodeBlocksGenerator::CreateProjectFile(
 /* Tree is used to create a "Virtual Folder" in CodeBlocks, in which all
  CMake files this project depends on will be put. This means additionally
  to the "Sources" and "Headers" virtual folders of CodeBlocks, there will
- now also be a "CMake Files" virtual folder. 
+ now also be a "CMake Files" virtual folder.
  Patch by Daniel Teske <daniel.teske AT nokia.com> (which use C::B project
  files in QtCreator).*/
 struct Tree
@@ -115,24 +105,24 @@ struct Tree
   std::string path; //only one component of the path
   std::vector<Tree> folders;
   std::vector<std::string> files;
-  void InsertPath(const std::vector<std::string>& splitted, 
-                  std::vector<std::string>::size_type start, 
+  void InsertPath(const std::vector<std::string>& splitted,
+                  std::vector<std::string>::size_type start,
                   const std::string& fileName);
   void BuildVirtualFolder(std::string& virtualFolders) const;
-  void BuildVirtualFolderImpl(std::string& virtualFolders, 
+  void BuildVirtualFolderImpl(std::string& virtualFolders,
                               const std::string& prefix) const;
   void BuildUnit(std::string& unitString, const std::string& fsPath) const;
-  void BuildUnitImpl(std::string& unitString, 
-                     const std::string& virtualFolderPath, 
+  void BuildUnitImpl(std::string& unitString,
+                     const std::string& virtualFolderPath,
                      const std::string& fsPath) const;
 };
 
 
-void Tree::InsertPath(const std::vector<std::string>& splitted, 
-                      std::vector<std::string>::size_type start, 
+void Tree::InsertPath(const std::vector<std::string>& splitted,
+                      std::vector<std::string>::size_type start,
                       const std::string& fileName)
 {
-  if (start == splitted.size()) 
+  if (start == splitted.size())
     {
     files.push_back(fileName);
     return;
@@ -301,7 +291,7 @@ void cmExtraCodeBlocksGenerator
     }
 
   // Now build a virtual tree string
-  std::string virtualFolders;  
+  std::string virtualFolders;
   tree.BuildVirtualFolder(virtualFolders);
   // And one for <Unit>
   std::string unitFiles;
@@ -323,7 +313,7 @@ void cmExtraCodeBlocksGenerator
 
   this->AppendTarget(fout, "all", 0, make.c_str(), mf, compiler.c_str());
 
-  // add all executable and library targets and some of the GLOBAL 
+  // add all executable and library targets and some of the GLOBAL
   // and UTILITY targets
   for (std::vector<cmLocalGenerator*>::const_iterator lg=lgs.begin();
        lg!=lgs.end(); lg++)
@@ -338,9 +328,9 @@ void cmExtraCodeBlocksGenerator
         case cmTarget::GLOBAL_TARGET:
           {
           bool insertTarget = false;
-          // Only add the global targets from CMAKE_BINARY_DIR, 
+          // Only add the global targets from CMAKE_BINARY_DIR,
           // not from the subdirs
-          if (strcmp(makefile->GetStartOutputDirectory(), 
+          if (strcmp(makefile->GetStartOutputDirectory(),
                      makefile->GetHomeOutputDirectory())==0)
             {
             insertTarget = true;
@@ -362,7 +352,7 @@ void cmExtraCodeBlocksGenerator
             }
           if (insertTarget)
             {
-            this->AppendTarget(fout, ti->first.c_str(), 0, 
+            this->AppendTarget(fout, ti->first.c_str(), 0,
                                make.c_str(), makefile, compiler.c_str());
             }
           }
@@ -372,13 +362,13 @@ void cmExtraCodeBlocksGenerator
           // Experimental-"sub"targets as e.g. NightlyStart
           if (((ti->first.find("Nightly")==0)   &&(ti->first!="Nightly"))
              || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
-             || ((ti->first.find("Experimental")==0) 
+             || ((ti->first.find("Experimental")==0)
                                                && (ti->first!="Experimental")))
             {
             break;
             }
 
-          this->AppendTarget(fout, ti->first.c_str(), 0, 
+          this->AppendTarget(fout, ti->first.c_str(), 0,
                                  make.c_str(), makefile, compiler.c_str());
           break;
         case cmTarget::EXECUTABLE:
@@ -386,11 +376,11 @@ void cmExtraCodeBlocksGenerator
         case cmTarget::SHARED_LIBRARY:
         case cmTarget::MODULE_LIBRARY:
           {
-          this->AppendTarget(fout, ti->first.c_str(), &ti->second, 
+          this->AppendTarget(fout, ti->first.c_str(), &ti->second,
                              make.c_str(), makefile, compiler.c_str());
           std::string fastTarget = ti->first;
           fastTarget += "/fast";
-          this->AppendTarget(fout, fastTarget.c_str(), &ti->second, 
+          this->AppendTarget(fout, fastTarget.c_str(), &ti->second,
                              make.c_str(), makefile, compiler.c_str());
           }
           break;
@@ -437,7 +427,7 @@ void cmExtraCodeBlocksGenerator
               {
               for(std::vector<std::string>::const_iterator
                   ext = mf->GetSourceExtensions().begin();
-                  ext !=  mf->GetSourceExtensions().end(); 
+                  ext !=  mf->GetSourceExtensions().end();
                   ++ext)
                 {
                 if ((*si)->GetExtension() == *ext)
@@ -467,11 +457,11 @@ void cmExtraCodeBlocksGenerator
 
   // The following loop tries to add header files matching to implementation
   // files to the project. It does that by iterating over all source files,
-  // replacing the file name extension with ".h" and checks whether such a 
+  // replacing the file name extension with ".h" and checks whether such a
   // file exists. If it does, it is inserted into the map of files.
   // A very similar version of that code exists also in the kdevelop
   // project generator.
-  for (std::map<std::string, cmSourceFile*>::const_iterator 
+  for (std::map<std::string, cmSourceFile*>::const_iterator
        sit=cFiles.begin();
        sit!=cFiles.end();
        ++sit)
@@ -483,7 +473,7 @@ void cmExtraCodeBlocksGenerator
     // check if there's a matching header around
     for(std::vector<std::string>::const_iterator
         ext = mf->GetHeaderExtensions().begin();
-        ext !=  mf->GetHeaderExtensions().end(); 
+        ext !=  mf->GetHeaderExtensions().end();
         ++ext)
       {
       std::string hname=headerBasename;
@@ -506,7 +496,7 @@ void cmExtraCodeBlocksGenerator
 
   // insert all source files in the CodeBlocks project
   // first the C/C++ implementation files, then all others
-  for (std::map<std::string, cmSourceFile*>::const_iterator 
+  for (std::map<std::string, cmSourceFile*>::const_iterator
        sit=cFiles.begin();
        sit!=cFiles.end();
        ++sit)
@@ -514,7 +504,7 @@ void cmExtraCodeBlocksGenerator
     fout<<"      <Unit filename=\""<< sit->first <<"\">\n"
           "      </Unit>\n";
     }
-  for (std::set<std::string>::const_iterator 
+  for (std::set<std::string>::const_iterator
        sit=otherFiles.begin();
        sit!=otherFiles.end();
        ++sit)
@@ -577,7 +567,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
           "         <Option compiler=\"" << compiler << "\" />\n"
           "         <Compiler>\n";
       // the include directories for this target
-      const std::vector<std::string>& incDirs = 
+      const std::vector<std::string>& incDirs =
           target->GetMakefile()->GetIncludeDirectories();
       for(std::vector<std::string>::const_iterator dirIt=incDirs.begin();
           dirIt != incDirs.end();
@@ -589,27 +579,27 @@ void cmExtraCodeBlocksGenerator::AppendTarget(cmGeneratedFileStream& fout,
       }
     else // e.g. all and the GLOBAL and UTILITY targets
     {
-    fout<<"         <Option working_dir=\"" 
+    fout<<"         <Option working_dir=\""
                             << makefile->GetStartOutputDirectory() << "\" />\n"
         <<"         <Option type=\"" << 4 << "\" />\n";
     }
 
   fout<<"         <MakeCommands>\n"
-        "            <Build command=\"" 
+        "            <Build command=\""
       << this->BuildMakeCommand(make, makefileName.c_str(), targetName)
       << "\" />\n"
-        "            <CompileFile command=\"" 
+        "            <CompileFile command=\""
       << this->BuildMakeCommand(make, makefileName.c_str(),"&quot;$file&quot;")
       << "\" />\n"
-        "            <Clean command=\"" 
-      << this->BuildMakeCommand(make, makefileName.c_str(), "clean") 
+        "            <Clean command=\""
+      << this->BuildMakeCommand(make, makefileName.c_str(), "clean")
       << "\" />\n"
-        "            <DistClean command=\"" 
-      << this->BuildMakeCommand(make, makefileName.c_str(), "clean") 
+        "            <DistClean command=\""
+      << this->BuildMakeCommand(make, makefileName.c_str(), "clean")
       << "\" />\n"
         "         </MakeCommands>\n"
         "      </Target>\n";
-  
+
 }
 
 
@@ -675,7 +665,7 @@ int cmExtraCodeBlocksGenerator::GetCBTargetType(cmTarget* target)
     {
     return 2;
     }
-  else if ((target->GetType()==cmTarget::SHARED_LIBRARY) 
+  else if ((target->GetType()==cmTarget::SHARED_LIBRARY)
            || (target->GetType()==cmTarget::MODULE_LIBRARY))
     {
     return 3;
@@ -695,16 +685,18 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
     command += " /NOLOGO /f &quot;";
     command += makefileName;
     command += "&quot; ";
+    command += " VERBOSE=1 ";
     command += target;
     }
   else if (strcmp(this->GlobalGenerator->GetName(), "MinGW Makefiles")==0)
     {
-    // no escaping of spaces in this case, see 
+    // no escaping of spaces in this case, see
     // http://public.kitware.com/Bug/view.php?id=10014
-    std::string makefileName = makefile; 
+    std::string makefileName = makefile;
     command += " -f &quot;";
     command += makefileName;
     command += "&quot; ";
+    command += " VERBOSE=1 ";
     command += target;
     }
   else
@@ -713,6 +705,7 @@ std::string cmExtraCodeBlocksGenerator::BuildMakeCommand(
     command += " -f &quot;";
     command += makefileName;
     command += "&quot; ";
+    command += " VERBOSE=1 ";
     command += target;
     }
   return command;

Source/cmExtraCodeBlocksGenerator.h

@@ -22,22 +22,19 @@ class cmGeneratedFileStream;
 
 /** \class cmExtraCodeBlocksGenerator
  * \brief Write CodeBlocks project files for Makefile based projects
- *
- * This generator is in early alpha stage.
  */
 class cmExtraCodeBlocksGenerator : public cmExternalMakefileProjectGenerator
 {
 public:
   cmExtraCodeBlocksGenerator();
-  virtual void SetGlobalGenerator(cmGlobalGenerator* generator);
 
   virtual const char* GetName() const
                          { return cmExtraCodeBlocksGenerator::GetActualName();}
   static const char* GetActualName()                    { return "CodeBlocks";}
-  static cmExternalMakefileProjectGenerator* New() 
+  static cmExternalMakefileProjectGenerator* New()
                                      { return new cmExtraCodeBlocksGenerator; }
   /** Get the documentation entry for this generator.  */
-  virtual void GetDocumentation(cmDocumentationEntry& entry, 
+  virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const char* fullName) const;
 
   virtual void Generate();
@@ -49,7 +46,7 @@ private:
                                 const std::string& filename);
   std::string GetCBCompilerId(const cmMakefile* mf);
   int GetCBTargetType(cmTarget* target);
-  std::string BuildMakeCommand(const std::string& make, const char* makefile, 
+  std::string BuildMakeCommand(const std::string& make, const char* makefile,
                                const char* target);
   void AppendTarget(cmGeneratedFileStream& fout,
                     const char* targetName,

Source/cmExtraEclipseCDT4Generator.cxx

@@ -51,16 +51,6 @@ void cmExtraEclipseCDT4Generator
     "the default make target. A \"make install\" target is also provided.";
 }
 
-//----------------------------------------------------------------------------
-void cmExtraEclipseCDT4Generator
-::SetGlobalGenerator(cmGlobalGenerator* generator)
-{
-  cmExternalMakefileProjectGenerator::SetGlobalGenerator(generator);
-  cmGlobalUnixMakefileGenerator3* mf
-    = static_cast<cmGlobalUnixMakefileGenerator3*>(generator);
-  mf->SetToolSupportsColor(true);
-}
-
 //----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator::Generate()
 {
@@ -73,7 +63,7 @@ void cmExtraEclipseCDT4Generator::Generate()
 
   this->IsOutOfSourceBuild = (this->HomeDirectory!=this->HomeOutputDirectory);
 
-  this->GenerateSourceProject = (this->IsOutOfSourceBuild && 
+  this->GenerateSourceProject = (this->IsOutOfSourceBuild &&
                             mf->IsOn("ECLIPSE_CDT4_GENERATE_SOURCE_PROJECT"));
 
   // NOTE: This is not good, since it pollutes the source tree. However,
@@ -109,7 +99,7 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() const
     return;
     }
 
-  fout << 
+  fout <<
     "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     "<projectDescription>\n"
     "\t<name>" << name << "</name>\n"
@@ -129,7 +119,7 @@ void cmExtraEclipseCDT4Generator::CreateSourceProjectFile() const
 void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
                                             const char* envVar, cmMakefile* mf)
 {
-  // get the variables from the environment and from the cache and then 
+  // get the variables from the environment and from the cache and then
   // figure out which one to use:
 
   const char* envVarValue = getenv(envVar);
@@ -148,7 +138,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
     }
   else if (envVarValue!=0 && cacheValue==0)
     {
-    // The variable is in the env, but not in the cache. Use it and put it 
+    // The variable is in the env, but not in the cache. Use it and put it
     // in the cache
     valueToUse = envVarValue;
     mf->AddCacheDefinition(cacheEntryName.c_str(), valueToUse.c_str(),
@@ -206,7 +196,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     compilerId = mf->GetSafeDefinition("CMAKE_CXX_COMPILER_ID");
     }
 
-  fout << 
+  fout <<
     "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
     "<projectDescription>\n"
     "\t<name>" <<
@@ -225,7 +215,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     ;
 
   // use clean target
-  fout << 
+  fout <<
     "\t\t\t\t<dictionary>\n"
     "\t\t\t\t\t<key>org.eclipse.cdt.make.core.cleanBuildTarget</key>\n"
     "\t\t\t\t\t<value>clean</value>\n"
@@ -246,7 +236,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
 
   // set the make command
   std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
-  fout << 
+  fout <<
     "\t\t\t\t<dictionary>\n"
     "\t\t\t\t\t<key>org.eclipse.cdt.make.core.enabledIncrementalBuild</key>\n"
     "\t\t\t\t\t<value>true</value>\n"
@@ -296,7 +286,7 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
   else if (compilerId == "Intel")
     {
     // if the env.var is set, use this one and put it in the cache
-    // if the env.var is not set, but the value is in the cache, 
+    // if the env.var is not set, but the value is in the cache,
     // use it from the cache:
     AddEnvVar(fout, "INTEL_LICENSE_FILE", mf);
     }
@@ -392,9 +382,9 @@ void cmExtraEclipseCDT4Generator::CreateProjectFile()
     {
     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 
-    // actually quite confusing in bigger projects with many directories and 
+    // (this is not done anymore for each project because of
+    // http://public.kitware.com/Bug/view.php?id=9978 and because I found it
+    // actually quite confusing in bigger projects with many directories and
     // projects, Alex
 
     std::string sourceLinkedResourceName = "[Source directory]";
@@ -440,7 +430,7 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
       if(emittedDirs.find(dir) == emittedDirs.end())
         {
         emittedDirs.insert(dir);
-        fout << "<pathentry include=\"" 
+        fout << "<pathentry include=\""
              << cmExtraEclipseCDT4Generator::GetEclipsePath(dir)
              << "\" kind=\"inc\" path=\"\" system=\"true\"/>\n";
         }
@@ -452,7 +442,7 @@ void cmExtraEclipseCDT4Generator::AppendIncludeDirectories(
 void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
 {
   std::set<std::string> emmited;
-  
+
   const cmMakefile* mf
     = this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile();
 
@@ -465,7 +455,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     }
 
   // add header
-  fout << 
+  fout <<
     "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n"
     "<?fileVersion 4.0.0?>\n\n"
     "<cproject>\n"
@@ -475,7 +465,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   fout << "<cconfiguration id=\"org.eclipse.cdt.core.default.config.1\">\n";
 
   // Configuration settings...
-  fout << 
+  fout <<
     "<storageModule"
     " buildSystemId=\"org.eclipse.cdt.core.defaultConfigDataProvider\""
     " id=\"org.eclipse.cdt.core.default.config.1\""
@@ -536,9 +526,9 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   fout << "</extensions>\n"
           "</storageModule>\n"
           ;
-  
+
   // ???
-  fout << 
+  fout <<
     "<storageModule moduleId=\"org.eclipse.cdt.core.language.mapping\">\n"
     "<project-mappings/>\n"
     "</storageModule>\n"
@@ -619,13 +609,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           // we have -DFOO
           def = *di;
           }
-          
+
         // insert the definition if not already added.
         if(emmited.find(def) == emmited.end())
           {
           emmited.insert(def);
           fout << "<pathentry kind=\"mac\" name=\"" << def
-               << "\" path=\"\" value=\"" << this->EscapeForXML(val) 
+               << "\" path=\"\" value=\"" << this->EscapeForXML(val)
                << "\"/>\n";
           }
         }
@@ -712,8 +702,8 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
       = (*it)->GetMakefile()->GetIncludeDirectories();
     this->AppendIncludeDirectories(fout, includeDirs, emmited);
     }
-  // now also the system include directories, in case we found them in 
-  // CMakeSystemSpecificInformation.cmake. This makes Eclipse find the 
+  // now also the system include directories, in case we found them in
+  // CMakeSystemSpecificInformation.cmake. This makes Eclipse find the
   // standard headers.
   mf->GetDefinition("CMAKE_ECLIPSE_C_SYSTEM_INCLUDE_DIRS");
   std::string compiler = mf->GetSafeDefinition("CMAKE_C_COMPILER");
@@ -738,15 +728,17 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
   fout << "</storageModule>\n";
 
   // add build targets
-  fout << 
+  fout <<
     "<storageModule moduleId=\"org.eclipse.cdt.make.core.buildtargets\">\n"
     "<buildTargets>\n"
     ;
   emmited.clear();
   const std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM");
+  const std::string makeArgs = mf->GetSafeDefinition(
+                                               "CMAKE_ECLIPSE_MAKE_ARGUMENTS");
   cmGlobalGenerator* generator
     = const_cast<cmGlobalGenerator*>(this->GlobalGenerator);
-  
+
   std::string allTarget;
   std::string cleanTarget;
   if (generator->GetAllTargetName())
@@ -758,7 +750,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
     cleanTarget = generator->GetCleanTargetName();
     }
 
-  // add all executable and library targets and some of the GLOBAL 
+  // add all executable and library targets and some of the GLOBAL
   // and UTILITY targets
   for (std::vector<cmLocalGenerator*>::const_iterator
         it = this->GlobalGenerator->GetLocalGenerators().begin();
@@ -781,7 +773,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
         case cmTarget::GLOBAL_TARGET:
           {
           bool insertTarget = false;
-          // Only add the global targets from CMAKE_BINARY_DIR, 
+          // Only add the global targets from CMAKE_BINARY_DIR,
           // not from the subdirs
           if (subdir.empty())
            {
@@ -804,7 +796,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
            }
          if (insertTarget)
            {
-           this->AppendTarget(fout, ti->first, make, subdir, ": ");
+           this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": ");
            }
          }
          break;
@@ -813,13 +805,13 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
          // Experimental-"sub"targets as e.g. NightlyStart
          if (((ti->first.find("Nightly")==0)   &&(ti->first!="Nightly"))
           || ((ti->first.find("Continuous")==0)&&(ti->first!="Continuous"))
-          || ((ti->first.find("Experimental")==0) 
+          || ((ti->first.find("Experimental")==0)
                                             && (ti->first!="Experimental")))
            {
            break;
            }
 
-         this->AppendTarget(fout, ti->first, make, subdir, ": ");
+         this->AppendTarget(fout, ti->first, make, makeArgs, subdir, ": ");
          break;
        case cmTarget::EXECUTABLE:
        case cmTarget::STATIC_LIBRARY:
@@ -828,10 +820,10 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
          {
          const char* prefix = (ti->second.GetType()==cmTarget::EXECUTABLE ?
                                                           "[exe] " : "[lib] ");
-         this->AppendTarget(fout, ti->first, make, subdir, prefix);
+         this->AppendTarget(fout, ti->first, make, makeArgs, subdir, prefix);
          std::string fastTarget = ti->first;
          fastTarget += "/fast";
-         this->AppendTarget(fout, fastTarget, make, subdir, prefix);
+         this->AppendTarget(fout, fastTarget, make, makeArgs, subdir, prefix);
          }
          break;
         // ignore these:
@@ -842,15 +834,15 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
           break;
         }
       }
-      
+
     // insert the all and clean targets in every subdir
     if (!allTarget.empty())
       {
-      this->AppendTarget(fout, allTarget, make, subdir, ": ");
+      this->AppendTarget(fout, allTarget, make, makeArgs, subdir, ": ");
       }
     if (!cleanTarget.empty())
       {
-      this->AppendTarget(fout, cleanTarget, make, subdir, ": ");
+      this->AppendTarget(fout, cleanTarget, make, makeArgs, subdir, ": ");
       }
 
     //insert rules for compiling, preprocessing and assembling individual files
@@ -870,7 +862,7 @@ void cmExtraEclipseCDT4Generator::CreateCProjectFile() const
         {
         prefix = "[pre] ";
         }
-      this->AppendTarget(fout, *fit, make, subdir, prefix);
+      this->AppendTarget(fout, *fit, make, makeArgs, subdir, prefix);
       }
     }
 
@@ -955,7 +947,7 @@ std::string cmExtraEclipseCDT4Generator::EscapeForXML(const std::string& value)
 // Helper functions
 //----------------------------------------------------------------------------
 void cmExtraEclipseCDT4Generator
-::AppendStorageScanners(cmGeneratedFileStream& fout, 
+::AppendStorageScanners(cmGeneratedFileStream& fout,
                         const cmMakefile& makefile)
 {
   // we need the "make" and the C (or C++) compiler which are used, Alex
@@ -972,7 +964,7 @@ void cmExtraEclipseCDT4Generator
 
 
   // the following right now hardcodes gcc behaviour :-/
-  fout << 
+  fout <<
     "<storageModule moduleId=\"scannerConfiguration\">\n"
     "<autodiscovery enabled=\"true\" problemReportingEnabled=\"true\""
     " selectedProfileId="
@@ -996,24 +988,25 @@ void cmExtraEclipseCDT4Generator
 // of that is to sort the targets in the view of Eclipse, so that at first
 // the global/utility/all/clean targets appear ": ", then the executable
 // targets "[exe] ", then the libraries "[lib]", then the rules for the
-// object files "[obj]", then for preprocessing only "[pre] " and 
-// finally the assembly files "[to asm] ". Note the "to" in "to asm", 
+// object files "[obj]", then for preprocessing only "[pre] " and
+// finally the assembly files "[to asm] ". Note the "to" in "to asm",
 // without it, "asm" would be the first targets in the list, with the "to"
 // they are the last targets, which makes more sense.
 void cmExtraEclipseCDT4Generator::AppendTarget(cmGeneratedFileStream& fout,
                                                const std::string&     target,
                                                const std::string&     make,
+                                               const std::string&     makeArgs,
                                                const std::string&     path,
                                                const char* prefix)
 {
-  fout << 
+  fout <<
     "<target name=\"" << prefix << target << "\""
     " path=\"" << path.c_str() << "\""
     " targetID=\"org.eclipse.cdt.make.MakeTargetBuilder\">\n"
     "<buildCommand>"
     << cmExtraEclipseCDT4Generator::GetEclipsePath(make)
     << "</buildCommand>\n"
-    "<buildArguments/>\n"
+    "<buildArguments>"  << makeArgs << "</buildArguments>\n"
     "<buildTarget>" << target << "</buildTarget>\n"
     "<stopOnError>true</stopOnError>\n"
     "<useDefaultCommand>false</useDefaultCommand>\n"
@@ -1033,7 +1026,7 @@ void cmExtraEclipseCDT4Generator
                        bool                   runActionUseDefault,
                        bool                   sipParserEnabled)
 {
-  fout << 
+  fout <<
     "<profile id=\"" << profileID << "\">\n"
     "<buildOutputProvider>\n"
     "<openAction enabled=\"" << (openActionEnabled ? "true" : "false")

Source/cmExtraEclipseCDT4Generator.h

@@ -21,8 +21,6 @@ class cmGeneratedFileStream;
 
 /** \class cmExtraEclipseCDT4Generator
  * \brief Write Eclipse project files for Makefile based projects
- *
- * This generator is in early alpha stage.
  */
 class cmExtraEclipseCDT4Generator : public cmExternalMakefileProjectGenerator
 {
@@ -42,8 +40,6 @@ public:
   virtual void GetDocumentation(cmDocumentationEntry& entry,
                                 const char*           fullName) const;
 
-  virtual void SetGlobalGenerator(cmGlobalGenerator* generator);
-
   virtual void Generate();
 
 private:
@@ -70,11 +66,12 @@ private:
   static std::string EscapeForXML(const std::string& value);
 
   // Helper functions
-  static void AppendStorageScanners(cmGeneratedFileStream& fout, 
+  static void AppendStorageScanners(cmGeneratedFileStream& fout,
                                     const cmMakefile& makefile);
   static void AppendTarget         (cmGeneratedFileStream& fout,
                                     const std::string&     target,
                                     const std::string&     make,
+                                    const std::string&     makeArguments,
                                     const std::string&     path,
                                     const char* prefix = "");
   static void AppendScannerProfile (cmGeneratedFileStream& fout,
@@ -100,7 +97,7 @@ private:
                                    const std::vector<std::string>& includeDirs,
                                    std::set<std::string>& emittedDirs);
 
-  static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar, 
+  static void AddEnvVar(cmGeneratedFileStream& fout, const char* envVar,
                         cmMakefile* mf);
 
   std::vector<std::string> SrcLinkedResources;

Source/cmFindBase.cxx

@@ -13,11 +13,17 @@
   
 cmFindBase::cmFindBase()
 {
-  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
-                               "FIND_ARGS_XXX", "<VAR> NAMES name");
   this->AlreadyInCache = false;
   this->AlreadyInCacheWithoutMetaInfo = false;
-  this->GenericDocumentation = 
+}
+
+//----------------------------------------------------------------------------
+void cmFindBase::GenerateDocumentation()
+{
+  this->cmFindCommon::GenerateDocumentation();
+  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
+                               "FIND_ARGS_XXX", "<VAR> NAMES name");
+  this->GenericDocumentation =
     "   FIND_XXX(<VAR> name1 [path1 path2 ...])\n"
     "This is the short-hand signature for the command that "
     "is sufficient in many cases.  It is the same "
@@ -97,7 +103,18 @@ cmFindBase::cmFindBase()
   this->GenericDocumentation += this->GenericDocumentationRootPath;
   this->GenericDocumentation += this->GenericDocumentationPathsOrder;
 }
-  
+
+//----------------------------------------------------------------------------
+const char* cmFindBase::GetFullDocumentation()
+{
+  if(this->GenericDocumentation.empty())
+    {
+    this->GenerateDocumentation();
+    }
+  return this->GenericDocumentation.c_str();
+}
+
+//----------------------------------------------------------------------------
 bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
 {
   if(argsIn.size() < 2 )
@@ -147,6 +164,11 @@ bool cmFindBase::ParseArguments(std::vector<std::string> const& argsIn)
         }
       }
     }
+  if(args.size() < 2 )
+    {
+    this->SetError("called with incorrect number of arguments");
+    return false;
+    }
   this->VariableName = args[0];
   if(this->CheckForVariableInCache())
     {

Source/cmFindBase.h

@@ -31,10 +31,10 @@ public:
   virtual bool ParseArguments(std::vector<std::string> const& args);
   cmTypeMacro(cmFindBase, cmFindCommon);
   
-  virtual const char* GetFullDocumentation()
-    {return this->GenericDocumentation.c_str();}
+  virtual const char* GetFullDocumentation();
 
 protected:
+  virtual void GenerateDocumentation();
   void PrintFindStuff();
   void ExpandPaths();
   void AddPathSuffixes();

Source/cmFindCommon.cxx

@@ -34,7 +34,11 @@ cmFindCommon::cmFindCommon()
   this->SearchFrameworkLast = false;
   this->SearchAppBundleOnly = false;
   this->SearchAppBundleLast = false;
+}
 
+//----------------------------------------------------------------------------
+void cmFindCommon::GenerateDocumentation()
+{
   // Documentation components.
   this->GenericDocumentationMacPolicy =
     "On Darwin or systems supporting OS X Frameworks, the cmake variable"

Source/cmFindCommon.h

@@ -56,6 +56,8 @@ protected:
   /** Compute the current default bundle/framework search policy.  */
   void SelectDefaultMacMode();
 
+  virtual void GenerateDocumentation();
+
   cmStdString CMakePathName;
   RootPathMode FindRootPathMode;
 

Source/cmFindFileCommand.cxx

@@ -15,11 +15,16 @@
 cmFindFileCommand::cmFindFileCommand()
 {
   this->IncludeFileInPath = true;
+}
+
+void cmFindFileCommand::GenerateDocumentation()
+{
+  this->cmFindPathCommand::GenerateDocumentation();
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "find_path", "find_file");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "directory containing the named file", 
+                               "directory containing the named file",
                                "full path to named file");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                                "file in a directory", "full path to a file");
+                               "file in a directory", "full path to a file");
 }

Source/cmFindFileCommand.h

@@ -44,6 +44,8 @@ public:
     }
   
   cmTypeMacro(cmFindFileCommand, cmFindPathCommand);
+protected:
+  virtual void GenerateDocumentation();
 };
 
 

Source/cmFindLibraryCommand.cxx

@@ -16,6 +16,13 @@
 
 cmFindLibraryCommand::cmFindLibraryCommand()
 { 
+  this->EnvironmentPath = "LIB";
+}
+
+//----------------------------------------------------------------------------
+void cmFindLibraryCommand::GenerateDocumentation()
+{
+  this->cmFindBase::GenerateDocumentation();
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "FIND_XXX", "find_library");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
@@ -29,7 +36,7 @@ cmFindLibraryCommand::cmFindLibraryCommand()
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SYSTEM", "LIB");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_PATH", 
+                               "CMAKE_SYSTEM_XXX_PATH",
                                "CMAKE_SYSTEM_LIBRARY_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "SEARCH_XXX_DESC", "library");
@@ -38,11 +45,9 @@ cmFindLibraryCommand::cmFindLibraryCommand()
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SUBDIR", "lib");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX", 
+                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
                                "CMAKE_FIND_ROOT_PATH_MODE_LIBRARY");
-
-  this->EnvironmentPath = "LIB";
-  this->GenericDocumentation += 
+  this->GenericDocumentation +=
     "\n"
     "If the library found is a framework, then VAR will be set to "
     "the full path to the framework <fullPath>/A.framework. "

Source/cmFindLibraryCommand.h

@@ -64,6 +64,7 @@ protected:
   void AddArchitecturePaths(const char* suffix);
   void AddLib64Paths();
   std::string FindLibrary();
+  virtual void GenerateDocumentation();
 private:
   std::string FindNormalLibrary();
   std::string FindFrameworkLibrary();

Source/cmFindPackageCommand.cxx

@@ -51,13 +51,6 @@ void cmFindPackageNeedBackwardsCompatibility(const std::string& variable,
 //----------------------------------------------------------------------------
 cmFindPackageCommand::cmFindPackageCommand()
 {
-  cmSystemTools::ReplaceString(this->GenericDocumentationRootPath,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
-                               "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE");
-  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
-                               "FIND_ARGS_XXX", "<package>");
-  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
-                               "FIND_XXX", "find_package");
   this->CMakePathName = "PACKAGE";
   this->Quiet = false;
   this->Required = false;
@@ -78,6 +71,19 @@ cmFindPackageCommand::cmFindPackageCommand()
   this->VersionFoundPatch = 0;
   this->VersionFoundTweak = 0;
   this->VersionFoundCount = 0;
+}
+
+//----------------------------------------------------------------------------
+void cmFindPackageCommand::GenerateDocumentation()
+{
+  this->cmFindCommon::GenerateDocumentation();
+  cmSystemTools::ReplaceString(this->GenericDocumentationRootPath,
+                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
+                               "CMAKE_FIND_ROOT_PATH_MODE_PACKAGE");
+  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
+                               "FIND_ARGS_XXX", "<package>");
+  cmSystemTools::ReplaceString(this->GenericDocumentationPathsOrder,
+                               "FIND_XXX", "find_package");
   this->CommandDocumentation =
     "  find_package(<package> [version] [EXACT] [QUIET]\n"
     "               [[REQUIRED|COMPONENTS] [components...]]\n"
@@ -318,6 +324,10 @@ cmFindPackageCommand::cmFindPackageCommand()
 //----------------------------------------------------------------------------
 const char* cmFindPackageCommand::GetFullDocumentation()
 {
+  if(this->CommandDocumentation.empty())
+    {
+    this->GenerateDocumentation();
+    }
   return this->CommandDocumentation.c_str();
 }
 

Source/cmFindPackageCommand.h

@@ -65,6 +65,8 @@ public:
   virtual const char* GetFullDocumentation();
 
   cmTypeMacro(cmFindPackageCommand, cmFindCommon);
+protected:
+  virtual void GenerateDocumentation();
 private:
   void AppendSuccessInformation();
   void AppendToProperty(const char* propertyName);

Source/cmFindPathCommand.cxx

@@ -18,6 +18,11 @@ cmFindPathCommand::cmFindPathCommand()
 {
   this->EnvironmentPath = "INCLUDE";
   this->IncludeFileInPath = false;
+}
+
+void cmFindPathCommand::GenerateDocumentation()
+{
+  this->cmFindBase::GenerateDocumentation();
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "FIND_XXX", "find_path");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
@@ -31,27 +36,21 @@ cmFindPathCommand::cmFindPathCommand()
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SYSTEM", "INCLUDE");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_PATH", 
-                               "CMAKE_SYSTEM_INCLUDE_PATH"); 
+                               "CMAKE_SYSTEM_XXX_PATH",
+                               "CMAKE_SYSTEM_INCLUDE_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "SEARCH_XXX_DESC", 
+                               "SEARCH_XXX_DESC",
                                "directory containing the named file");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "SEARCH_XXX", "file in a directory");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SUBDIR", "include");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX", 
+                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
                                "CMAKE_FIND_ROOT_PATH_MODE_INCLUDE");
-
-  this->ExtraDocAdded = false;
-}
-
-const char* cmFindPathCommand::GetFullDocumentation()
-{
-  if(!this->ExtraDocAdded && !this->IncludeFileInPath)
+  if(!this->IncludeFileInPath)
     {
-    this->GenericDocumentation += 
+    this->GenericDocumentation +=
       "\n"
       "When searching for frameworks, if the file is specified as "
       "A/b.h, then the framework search will look for "
@@ -59,9 +58,7 @@ const char* cmFindPathCommand::GetFullDocumentation()
       "If that is found the path will be set to the path to the framework. "
       "CMake will convert this to the correct -F option to include the "
       "file. ";
-    this->ExtraDocAdded = true;
     }
-  return this->GenericDocumentation.c_str();
 }
 
 // cmFindPathCommand

Source/cmFindPathCommand.h

@@ -59,10 +59,10 @@ public:
     return "Find the directory containing a file.";
     }
 
-  virtual const char* GetFullDocumentation();
   cmTypeMacro(cmFindPathCommand, cmFindBase);
   bool IncludeFileInPath;
-  bool ExtraDocAdded;
+protected:
+  virtual void GenerateDocumentation();
 private:
   std::string FindHeaderInFramework(std::string const& file,
                                     std::string const& dir);

Source/cmFindProgramCommand.cxx

@@ -16,9 +16,10 @@
 #if defined(__APPLE__)
 #include <CoreFoundation/CoreFoundation.h>
 #endif
-  
-cmFindProgramCommand::cmFindProgramCommand()
+
+void cmFindProgramCommand::GenerateDocumentation()
 {
+  this->cmFindBase::GenerateDocumentation();
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "FIND_XXX", "find_program");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
@@ -32,8 +33,8 @@ cmFindProgramCommand::cmFindProgramCommand()
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SYSTEM", "");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_SYSTEM_XXX_PATH", 
-                               "CMAKE_SYSTEM_PROGRAM_PATH"); 
+                               "CMAKE_SYSTEM_XXX_PATH",
+                               "CMAKE_SYSTEM_PROGRAM_PATH");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "SEARCH_XXX_DESC", "program");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
@@ -41,7 +42,7 @@ cmFindProgramCommand::cmFindProgramCommand()
   cmSystemTools::ReplaceString(this->GenericDocumentation,
                                "XXX_SUBDIR", "[s]bin");
   cmSystemTools::ReplaceString(this->GenericDocumentation,
-                               "CMAKE_FIND_ROOT_PATH_MODE_XXX", 
+                               "CMAKE_FIND_ROOT_PATH_MODE_XXX",
                                "CMAKE_FIND_ROOT_PATH_MODE_PROGRAM");
 }
 

Source/cmFindProgramCommand.h

@@ -25,7 +25,6 @@
 class cmFindProgramCommand : public cmFindBase
 {
 public:
-  cmFindProgramCommand();
   /**
    * This is a virtual constructor for the command.
    */
@@ -63,6 +62,7 @@ public:
 
 protected:
   std::string FindProgram(std::vector<std::string> names);
+  virtual void GenerateDocumentation();
 
 private:
   std::string FindAppBundle(std::vector<std::string> names);

Source/cmGlobalGenerator.cxx

@@ -699,9 +699,8 @@ bool cmGlobalGenerator::IsDependedOn(const char* project,
          l != targets.end(); l++)
       {
       cmTarget& target = l->second;
-      std::set<cmStdString>::const_iterator pos =
-        target.GetUtilities().find(targetIn->GetName());
-      if(pos != target.GetUtilities().end())
+      TargetDependSet const& tgtdeps = this->GetTargetDirectDepends(target);
+      if(tgtdeps.count(targetIn))
         {
         return true;
         }
@@ -815,22 +814,9 @@ void cmGlobalGenerator::Generate()
   // For each existing cmLocalGenerator
   unsigned int i;
 
-  // Consolidate global targets
+  // Put a copy of each global target in every directory.
   cmTargets globalTargets;
   this->CreateDefaultGlobalTargets(&globalTargets);
-  for (i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    cmTargets* targets =
-      &(this->LocalGenerators[i]->GetMakefile()->GetTargets());
-    cmTargets::iterator tarIt;
-    for ( tarIt = targets->begin(); tarIt != targets->end(); ++ tarIt )
-      {
-      if ( tarIt->second.GetType() == cmTarget::GLOBAL_TARGET )
-        {
-        globalTargets[tarIt->first] = tarIt->second;
-        }
-      }
-    }
   for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
     cmMakefile* mf = this->LocalGenerators[i]->GetMakefile();
@@ -1884,8 +1870,7 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(
   const char* name, const char* message,
   const cmCustomCommandLines* commandLines,
   std::vector<std::string> depends,
-  const char* workingDirectory,
-  bool depends_on_all /* = false */)
+  const char* workingDirectory)
 {
   // Package
   cmTarget target;
@@ -1900,10 +1885,6 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget(
                      workingDirectory);
   target.GetPostBuildCommands().push_back(cc);
   target.SetProperty("EchoString", message);
-  if ( depends_on_all )
-    {
-    target.AddUtility("all");
-    }
   std::vector<std::string>::iterator dit;
   for ( dit = depends.begin(); dit != depends.end(); ++ dit )
     {

Source/cmGlobalGenerator.h

@@ -16,6 +16,7 @@
 #include "cmStandardIncludes.h"
 
 #include "cmTarget.h" // For cmTargets
+#include "cmTargetDepend.h" // For cmTargetDependSet
 
 class cmake;
 class cmMakefile;
@@ -38,31 +39,31 @@ public:
   ///! Free any memory allocated with the GlobalGenerator
   cmGlobalGenerator();
   virtual ~cmGlobalGenerator();
-  
+
   ///! Create a local generator appropriate to this Global Generator
   virtual cmLocalGenerator *CreateLocalGenerator();
 
   ///! Get the name for this generator
   virtual const char *GetName() const { return "Generic"; };
-  
+
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry) const;
-  
+
   /**
    * Create LocalGenerators and process the CMakeLists files. This does not
-   * actually produce any makefiles, DSPs, etc.  
+   * actually produce any makefiles, DSPs, etc.
    */
   virtual void Configure();
 
   /**
    * Generate the all required files for building this project/tree. This
    * basically creates a series of LocalGenerators for each directory and
-   * requests that they Generate.  
+   * requests that they Generate.
    */
   virtual void Generate();
 
   /**
-   * Set/Get and Clear the enabled languages.  
+   * Set/Get and Clear the enabled languages.
    */
   void SetLanguageEnabled(const char*, cmMakefile* mf);
   bool GetLanguageEnabled(const char*) const;
@@ -70,7 +71,7 @@ public:
   void GetEnabledLanguages(std::vector<std::string>& lang);
   /**
    * Try to determine system infomation such as shared library
-   * extension, pthreads, byte order etc.  
+   * extension, pthreads, byte order etc.
    */
   virtual void EnableLanguage(std::vector<std::string>const& languages,
                               cmMakefile *, bool optional);
@@ -88,7 +89,7 @@ public:
                          const char *projectName, const char *targetName,
                          bool fast, std::string *output, cmMakefile* mf);
 
-  
+
   /**
    * Build a file given the following information. This is a more direct call
    * that is used by both CTest and TryCompile. If target name is NULL or
@@ -104,28 +105,28 @@ public:
             const char* extraOptions = 0,
             std::vector<std::string> const& nativeOptions =
             std::vector<std::string>());
-  
+
   virtual std::string GenerateBuildCommand(
     const char* makeProgram,
-    const char *projectName, const char* additionalOptions, 
+    const char *projectName, const char* additionalOptions,
     const char *targetName,
     const char* config, bool ignoreErrors, bool fast);
-  
+
 
   ///! Set the CMake instance
   void SetCMakeInstance(cmake *cm);
-  
+
   ///! Get the CMake instance
   cmake *GetCMakeInstance() { return this->CMakeInstance; };
 
   void SetConfiguredFilesPath(cmGlobalGenerator* gen);
-  const std::vector<cmLocalGenerator *>& GetLocalGenerators() const { 
+  const std::vector<cmLocalGenerator *>& GetLocalGenerators() const {
     return this->LocalGenerators;}
 
-  cmLocalGenerator* GetCurrentLocalGenerator() 
+  cmLocalGenerator* GetCurrentLocalGenerator()
                                           {return this->CurrentLocalGenerator;}
 
-  void SetCurrentLocalGenerator(cmLocalGenerator* lg) 
+  void SetCurrentLocalGenerator(cmLocalGenerator* lg)
                                             {this->CurrentLocalGenerator = lg;}
 
   void AddLocalGenerator(cmLocalGenerator *lg);
@@ -138,11 +139,11 @@ public:
 
   void AddInstallComponent(const char* component);
 
-  const std::set<cmStdString>* GetInstallComponents() const 
+  const std::set<cmStdString>* GetInstallComponents() const
   { return &InstallComponents; }
 
   ///! Add one installed target to the sets of the exports
-  void AddTargetToExports(const char* exportSet, cmTarget* target, 
+  void AddTargetToExports(const char* exportSet, cmTarget* target,
                           cmInstallTargetGenerator* archive,
                           cmInstallTargetGenerator* runTime,
                           cmInstallTargetGenerator* library,
@@ -158,10 +159,9 @@ public:
   void EnableInstallTarget();
 
   int TryCompileTimeout;
-  
+
   bool GetForceUnixPaths() {return this->ForceUnixPaths;}
   bool GetToolSupportsColor() { return this->ToolSupportsColor; }
-  void SetToolSupportsColor(bool enable) { this->ToolSupportsColor = enable; }
 
   ///! return the language for the given extension
   const char* GetLanguageFromExtension(const char* ext);
@@ -234,7 +234,7 @@ public:
   virtual const char* GetCleanTargetName()        { return 0; }
 
   // Class to track a set of dependencies.
-  class TargetDependSet: public std::set<cmTarget*> {};
+  typedef cmTargetDependSet TargetDependSet;
 
   // what targets does the specified target depend on directly
   // via a target_link_libraries or add_dependencies
@@ -254,7 +254,7 @@ public:
   bool BinaryDirectoryIsNew(const char* dir)
     {
     return this->BinaryDirectories.insert(dir).second;
-    } 
+    }
   /** Supported systems creates a GUID for the given name */
   virtual void CreateGUID(const char*) {}
 
@@ -281,7 +281,7 @@ protected:
 
   bool CheckTargets();
 
-  // Fill the ProjectMap, this must be called after LocalGenerators 
+  // Fill the ProjectMap, this must be called after LocalGenerators
   // has been populated.
   void FillProjectMap();
   void CheckLocalGenerators();
@@ -291,8 +291,7 @@ protected:
   void CreateDefaultGlobalTargets(cmTargets* targets);
   cmTarget CreateGlobalTarget(const char* name, const char* message,
     const cmCustomCommandLines* commandLines,
-    std::vector<std::string> depends, const char* workingDir,
-                              bool depends_on_all = false);
+    std::vector<std::string> depends, const char* workingDir);
 
   bool NeedSymbolicMark;
   bool UseLinkScript;
@@ -328,13 +327,13 @@ protected:
 private:
   float FirstTimeProgress;
   // If you add a new map here, make sure it is copied
-  // in EnableLanguagesFromGenerator 
+  // in EnableLanguagesFromGenerator
   std::map<cmStdString, bool> IgnoreExtensions;
   std::map<cmStdString, bool> LanguageEnabled;
   std::map<cmStdString, cmStdString> OutputExtensions;
   std::map<cmStdString, cmStdString> LanguageToOutputExtension;
   std::map<cmStdString, cmStdString> ExtensionToLanguage;
-  std::map<cmStdString, int> LanguageToLinkerPreference; 
+  std::map<cmStdString, int> LanguageToLinkerPreference;
 
   // Record hashes for rules and outputs.
   struct RuleHash { char Data[32]; };

Source/cmGlobalUnixMakefileGenerator3.cxx

@@ -24,7 +24,7 @@ cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3()
   this->ForceUnixPaths = true;
   this->FindMakeProgramFile = "CMakeUnixFindMake.cmake";
   this->ToolSupportsColor = true;
-  this->ForceVerboseMakefiles = false;
+  this->NoRuleMessages = false;
 
 #if defined(_WIN32) || defined(__VMS)
   this->UseLinkScript = false;
@@ -34,8 +34,8 @@ cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3()
 }
 
 void cmGlobalUnixMakefileGenerator3
-::EnableLanguage(std::vector<std::string>const& languages, 
-                 cmMakefile *mf, 
+::EnableLanguage(std::vector<std::string>const& languages,
+                 cmMakefile *mf,
                  bool optional)
 {
   this->cmGlobalGenerator::EnableLanguage(languages, mf, optional);
@@ -51,17 +51,17 @@ void cmGlobalUnixMakefileGenerator3
     std::string langComp = "CMAKE_";
     langComp += lang;
     langComp += "_COMPILER";
-    
+
     if(!mf->GetDefinition(langComp.c_str()))
       {
       if(!optional)
         {
-        cmSystemTools::Error(langComp.c_str(), 
+        cmSystemTools::Error(langComp.c_str(),
                              " not set, after EnableLanguage");
         }
       continue;
       }
-    const char* name = mf->GetRequiredDefinition(langComp.c_str()); 
+    const char* name = mf->GetRequiredDefinition(langComp.c_str());
     if(!cmSystemTools::FileIsFullPath(name))
       {
       path = cmSystemTools::FindProgram(name);
@@ -70,7 +70,7 @@ void cmGlobalUnixMakefileGenerator3
       {
       path = name;
       }
-    if((path.size() == 0 || !cmSystemTools::FileExists(path.c_str())) 
+    if((path.size() == 0 || !cmSystemTools::FileExists(path.c_str()))
         && (optional==false))
       {
       std::string message = "your ";
@@ -96,8 +96,8 @@ void cmGlobalUnixMakefileGenerator3
       cmSystemTools::ConvertToUnixSlashes(cnameString);
       cmSystemTools::ConvertToUnixSlashes(pathString);
       if (cnameString != pathString)
-        { 
-        const char* cvars = 
+        {
+        const char* cvars =
           this->GetCMakeInstance()->GetProperty(
             "__CMAKE_DELETE_CACHE_CHANGE_VARS_");
         if(cvars)
@@ -139,44 +139,53 @@ void cmGlobalUnixMakefileGenerator3
 }
 
 //----------------------------------------------------------------------------
-void cmGlobalUnixMakefileGenerator3::Generate() 
+void cmGlobalUnixMakefileGenerator3::Generate()
 {
   // first do superclass method
   this->cmGlobalGenerator::Generate();
 
-  // initialize progress
-  unsigned long total = 0;
-  for(ProgressMapType::const_iterator pmi = this->ProgressMap.begin();
-      pmi != this->ProgressMap.end(); ++pmi)
+  cmake* cm = this->GetCMakeInstance();
+  if(const char* ruleStatus = cm->GetProperty("RULE_MESSAGES"))
     {
-    total += pmi->second.NumberOfActions;
+    this->NoRuleMessages = cmSystemTools::IsOff(ruleStatus);
     }
 
-  // write each target's progress.make this loop is done twice. Bascially the
-  // Generate pass counts all the actions, the first loop below determines
-  // how many actions have progress updates for each target and writes to
-  // corrrect variable values for everything except the all targets. The
-  // second loop actually writes out correct values for the all targets as
-  // well. This is because the all targets require more information that is
-  // computed in the first loop.
-  unsigned long current = 0;
-  for(ProgressMapType::iterator pmi = this->ProgressMap.begin();
-      pmi != this->ProgressMap.end(); ++pmi)
+  if(!this->NoRuleMessages)
     {
-    pmi->second.WriteProgressVariables(total, current);
+    // initialize progress
+    unsigned long total = 0;
+    for(ProgressMapType::const_iterator pmi = this->ProgressMap.begin();
+        pmi != this->ProgressMap.end(); ++pmi)
+      {
+      total += pmi->second.NumberOfActions;
+      }
+
+    // write each target's progress.make this loop is done twice. Bascially the
+    // Generate pass counts all the actions, the first loop below determines
+    // how many actions have progress updates for each target and writes to
+    // corrrect variable values for everything except the all targets. The
+    // second loop actually writes out correct values for the all targets as
+    // well. This is because the all targets require more information that is
+    // computed in the first loop.
+    unsigned long current = 0;
+    for(ProgressMapType::iterator pmi = this->ProgressMap.begin();
+        pmi != this->ProgressMap.end(); ++pmi)
+      {
+      pmi->second.WriteProgressVariables(total, current);
+      }
+    for(unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
+      {
+      cmLocalUnixMakefileGenerator3 *lg =
+        static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
+      std::string markFileName = lg->GetMakefile()->GetStartOutputDirectory();
+      markFileName += "/";
+      markFileName += cmake::GetCMakeFilesDirectory();
+      markFileName += "/progress.marks";
+      cmGeneratedFileStream markFile(markFileName.c_str());
+      markFile << this->CountProgressMarksInAll(lg) << "\n";
+      }
     }
-  for(unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
-    {
-    cmLocalUnixMakefileGenerator3 *lg = 
-      static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
-    std::string markFileName = lg->GetMakefile()->GetStartOutputDirectory();
-    markFileName += "/";
-    markFileName += cmake::GetCMakeFilesDirectory();
-    markFileName += "/progress.marks";
-    cmGeneratedFileStream markFile(markFileName.c_str());
-    markFile << this->CountProgressMarksInAll(lg) << "\n";
-    }
-  
+
   // write the main makefile
   this->WriteMainMakefile2();
   this->WriteMainCMakefile();
@@ -187,7 +196,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
   // Open the output file.  This should not be copy-if-different
   // because the check-build-system step compares the makefile time to
   // see if the build system must be regenerated.
-  std::string makefileName = 
+  std::string makefileName =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
   makefileName += cmake::GetCMakeFilesDirectory();
   makefileName += "/Makefile2";
@@ -196,11 +205,11 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
     {
     return;
     }
- 
+
   // get a local generator for some useful methods
-  cmLocalUnixMakefileGenerator3 *lg = 
+  cmLocalUnixMakefileGenerator3 *lg =
     static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
-    
+
   // Write the do not edit header.
   lg->WriteDisclaimer(makefileStream);
 
@@ -229,8 +238,8 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
     }
 
   // Write and empty all:
-  lg->WriteMakeRule(makefileStream, 
-                    "The main recursive all target", "all", 
+  lg->WriteMakeRule(makefileStream,
+                    "The main recursive all target", "all",
                     depends, no_commands, true);
 
   // Write an empty preinstall:
@@ -240,12 +249,12 @@ void cmGlobalUnixMakefileGenerator3::WriteMainMakefile2()
 
   // Write out the "special" stuff
   lg->WriteSpecialTargetsTop(makefileStream);
-  
+
   // write the target convenience rules
   unsigned int i;
   for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = 
+    lg =
       static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     this->WriteConvenienceRules2(makefileStream,lg);
     }
@@ -261,7 +270,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   // Open the output file.  This should not be copy-if-different
   // because the check-build-system step compares the makefile time to
   // see if the build system must be regenerated.
-  std::string cmakefileName = 
+  std::string cmakefileName =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
   cmakefileName += cmake::GetCMakeFilesDirectory();
   cmakefileName += "/Makefile.cmake";
@@ -271,14 +280,14 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
     return;
     }
 
-  std::string makefileName = 
+  std::string makefileName =
     this->GetCMakeInstance()->GetHomeOutputDirectory();
   makefileName += "/Makefile";
-  
+
   // get a local generator for some useful methods
-  cmLocalUnixMakefileGenerator3 *lg = 
+  cmLocalUnixMakefileGenerator3 *lg =
     static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[0]);
-    
+
   // Write the do not edit header.
   lg->WriteDisclaimer(cmakefileStream);
 
@@ -291,9 +300,9 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   std::vector<std::string> lfiles;
   for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = 
+    lg =
       static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
-  
+
     // Get the list of files contributing to this generation step.
     lfiles.insert(lfiles.end(),lg->GetMakefile()->GetListFiles().begin(),
                   lg->GetMakefile()->GetListFiles().end());
@@ -301,7 +310,7 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   // Sort the list and remove duplicates.
   std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
 #if !defined(__VMS) // The Compaq STL on VMS crashes, so accept duplicates.
-  std::vector<std::string>::iterator new_end = 
+  std::vector<std::string>::iterator new_end =
     std::unique(lfiles.begin(),lfiles.end());
   lfiles.erase(new_end, lfiles.end());
 #endif
@@ -317,14 +326,14 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   cmakefileStream
     << "# The top level Makefile was generated from the following files:\n"
     << "SET(CMAKE_MAKEFILE_DEPENDS\n"
-    << "  \"" 
+    << "  \""
     << lg->Convert(cache.c_str(),
                    cmLocalGenerator::START_OUTPUT).c_str() << "\"\n";
   for(std::vector<std::string>::const_iterator i = lfiles.begin();
       i !=  lfiles.end(); ++i)
     {
     cmakefileStream
-      << "  \"" 
+      << "  \""
       << lg->Convert(i->c_str(), cmLocalGenerator::START_OUTPUT).c_str()
       << "\"\n";
     }
@@ -340,10 +349,10 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   cmakefileStream
     << "# The corresponding makefile is:\n"
     << "SET(CMAKE_MAKEFILE_OUTPUTS\n"
-    << "  \"" 
+    << "  \""
     << lg->Convert(makefileName.c_str(),
                    cmLocalGenerator::START_OUTPUT).c_str() << "\"\n"
-    << "  \"" 
+    << "  \""
     << lg->Convert(check.c_str(),
                    cmLocalGenerator::START_OUTPUT).c_str() << "\"\n";
   cmakefileStream << "  )\n\n";
@@ -367,19 +376,19 @@ void cmGlobalUnixMakefileGenerator3::WriteMainCMakefile()
   std::string tmpStr;
   for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg = 
+    lg =
       static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     tmpStr = lg->GetMakefile()->GetStartOutputDirectory();
     tmpStr += cmake::GetCMakeFilesDirectory();
     tmpStr += "/CMakeDirectoryInformation.cmake";
-    cmakefileStream << "  \"" << 
-      lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str() 
+    cmakefileStream << "  \"" <<
+      lg->Convert(tmpStr.c_str(),cmLocalGenerator::HOME_OUTPUT).c_str()
                     << "\"\n";
     }
   cmakefileStream << "  )\n\n";
   }
 
-  this->WriteMainCMakefileLanguageRules(cmakefileStream, 
+  this->WriteMainCMakefileLanguageRules(cmakefileStream,
                                         this->LocalGenerators);
 }
 
@@ -458,7 +467,7 @@ cmGlobalUnixMakefileGenerator3
 
   // The directory-level rule should depend on the directory-level
   // rules of the subdirectories.
-  for(std::vector<cmLocalGenerator*>::iterator sdi = 
+  for(std::vector<cmLocalGenerator*>::iterator sdi =
         lg->GetChildren().begin(); sdi != lg->GetChildren().end(); ++sdi)
     {
     cmLocalUnixMakefileGenerator3* slg =
@@ -518,7 +527,7 @@ cmGlobalUnixMakefileGenerator3
 
 
 std::string cmGlobalUnixMakefileGenerator3
-::GenerateBuildCommand(const char* makeProgram, const char *projectName, 
+::GenerateBuildCommand(const char* makeProgram, const char *projectName,
                        const char* additionalOptions, const char *targetName,
                        const char* config, bool ignoreErrors, bool fast)
 {
@@ -526,9 +535,9 @@ std::string cmGlobalUnixMakefileGenerator3
   (void)projectName;
   (void)config;
 
-  std::string makeCommand = 
+  std::string makeCommand =
     cmSystemTools::ConvertToUnixOutputPath(makeProgram);
-  
+
   // Since we have full control over the invocation of nmake, let us
   // make it quiet.
   if ( strcmp(this->GetName(), "NMake Makefiles") == 0 )
@@ -563,7 +572,7 @@ std::string cmGlobalUnixMakefileGenerator3
         (this->CMakeInstance->GetStartOutputDirectory());
       lg->GetMakefile()->MakeStartDirectoriesCurrent();
       }
-    
+
     makeCommand += " \"";
     std::string tname = targetName;
     if(fast)
@@ -585,14 +594,14 @@ std::string cmGlobalUnixMakefileGenerator3
 //----------------------------------------------------------------------------
 void
 cmGlobalUnixMakefileGenerator3
-::WriteConvenienceRules(std::ostream& ruleFileStream, 
+::WriteConvenienceRules(std::ostream& ruleFileStream,
                         std::set<cmStdString> &emitted)
 {
-  std::vector<std::string> depends;  
+  std::vector<std::string> depends;
   std::vector<std::string> commands;
 
   depends.push_back("cmake_check_build_system");
-  
+
   // write the target convenience rules
   unsigned int i;
   cmLocalUnixMakefileGenerator3 *lg;
@@ -622,7 +631,7 @@ cmGlobalUnixMakefileGenerator3
         ruleFileStream
           << "# Target rules for targets named "
           << t->second.GetName() << "\n\n";
-        
+
         // Write the rule.
         commands.clear();
         std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
@@ -631,16 +640,16 @@ cmGlobalUnixMakefileGenerator3
                             (tmp.c_str(),t->second.GetName()));
         depends.clear();
         depends.push_back("cmake_check_build_system");
-        lg->WriteMakeRule(ruleFileStream, 
+        lg->WriteMakeRule(ruleFileStream,
                           "Build rule for target.",
                           t->second.GetName(), depends, commands,
                           true);
-        
+
         // Add a fast rule to build the target
         std::string localName = lg->GetRelativeTargetDirectory(t->second);
         std::string makefileName;
         makefileName = localName;
-        makefileName += "/build.make";          
+        makefileName += "/build.make";
         depends.clear();
         commands.clear();
         std::string makeTargetName = localName;
@@ -677,10 +686,10 @@ cmGlobalUnixMakefileGenerator3
 //----------------------------------------------------------------------------
 void
 cmGlobalUnixMakefileGenerator3
-::WriteConvenienceRules2(std::ostream& ruleFileStream, 
+::WriteConvenienceRules2(std::ostream& ruleFileStream,
                          cmLocalUnixMakefileGenerator3 *lg)
 {
-  std::vector<std::string> depends;  
+  std::vector<std::string> depends;
   std::vector<std::string> commands;
   std::string localName;
   std::string makeTargetName;
@@ -688,7 +697,7 @@ cmGlobalUnixMakefileGenerator3
 
   // write the directory level rules for this local gen
   this->WriteDirectoryRules2(ruleFileStream,lg);
-  
+
   depends.push_back("cmake_check_build_system");
 
   // for each target Generate the rule files for each target.
@@ -708,15 +717,15 @@ cmGlobalUnixMakefileGenerator3
       localName = lg->GetRelativeTargetDirectory(t->second);
       makefileName = localName;
       makefileName += "/build.make";
-      
+
       bool needRequiresStep = this->NeedRequiresStep(t->second);
-      
+
       lg->WriteDivider(ruleFileStream);
       ruleFileStream
         << "# Target rules for target "
         << localName << "\n\n";
-    
-      commands.clear();        
+
+      commands.clear();
       makeTargetName = localName;
       makeTargetName += "/depend";
       commands.push_back(lg->GetRecursiveMakeCall
@@ -734,39 +743,43 @@ cmGlobalUnixMakefileGenerator3
       makeTargetName += "/build";
       commands.push_back(lg->GetRecursiveMakeCall
                           (makefileName.c_str(),makeTargetName.c_str()));
-      
+
       // Write the rule.
       localName += "/all";
       depends.clear();
+      std::string progressDir;
 
-      std::string progressDir =
-        lg->GetMakefile()->GetHomeOutputDirectory();
-      progressDir += cmake::GetCMakeFilesDirectory();
+      if(!this->NoRuleMessages)
         {
-        cmOStringStream progCmd;
-        progCmd << "$(CMAKE_COMMAND) -E cmake_progress_report "; 
-        // all target counts
-        progCmd << lg->Convert(progressDir.c_str(),
-                                cmLocalGenerator::FULL,
-                                cmLocalGenerator::SHELL);
-        progCmd << " ";
-        std::vector<unsigned long>& progFiles =
-          this->ProgressMap[&t->second].Marks;
-        for (std::vector<unsigned long>::iterator i = progFiles.begin();
-              i != progFiles.end(); ++i)
+        progressDir =
+          lg->GetMakefile()->GetHomeOutputDirectory();
+        progressDir += cmake::GetCMakeFilesDirectory();
           {
-          progCmd << " " << *i;
+          cmOStringStream progCmd;
+          progCmd << "$(CMAKE_COMMAND) -E cmake_progress_report ";
+          // all target counts
+          progCmd << lg->Convert(progressDir.c_str(),
+                                  cmLocalGenerator::FULL,
+                                  cmLocalGenerator::SHELL);
+          progCmd << " ";
+          std::vector<unsigned long>& progFiles =
+            this->ProgressMap[&t->second].Marks;
+          for (std::vector<unsigned long>::iterator i = progFiles.begin();
+                i != progFiles.end(); ++i)
+            {
+            progCmd << " " << *i;
+            }
+          commands.push_back(progCmd.str());
           }
-        commands.push_back(progCmd.str());
+        progressDir = "Built target ";
+        progressDir += t->first;
+        lg->AppendEcho(commands,progressDir.c_str());
         }
-      progressDir = "Built target ";
-      progressDir += t->first;
-      lg->AppendEcho(commands,progressDir.c_str());
-      
+
       this->AppendGlobalTargetDepends(depends,t->second);
       lg->WriteMakeRule(ruleFileStream, "All Build rule for target.",
                         localName.c_str(), depends, commands, true);
-      
+
       // add the all/all dependency
       if(!this->IsExcluded(this->LocalGenerators[0], t->second))
         {
@@ -776,54 +789,58 @@ cmGlobalUnixMakefileGenerator3
         lg->WriteMakeRule(ruleFileStream, "Include target in all.",
                           "all", depends, commands, true);
         }
-      
-      // Write the rule.
-      commands.clear();
-      progressDir = lg->GetMakefile()->GetHomeOutputDirectory();
-      progressDir += cmake::GetCMakeFilesDirectory();
-      
-      {
-      // TODO: Convert the total progress count to a make variable.
-      cmOStringStream progCmd;
-      progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; 
-      // # in target
-      progCmd << lg->Convert(progressDir.c_str(),
-                              cmLocalGenerator::FULL,
-                              cmLocalGenerator::SHELL);
-      //
-      std::set<cmTarget *> emitted;
-      progCmd << " " 
-              << this->CountProgressMarksInTarget(&t->second, emitted);
-      commands.push_back(progCmd.str());
-      }
+
+      if(!this->NoRuleMessages)
+        {
+        // Write the rule.
+        commands.clear();
+        progressDir = lg->GetMakefile()->GetHomeOutputDirectory();
+        progressDir += cmake::GetCMakeFilesDirectory();
+
+        {
+        // TODO: Convert the total progress count to a make variable.
+        cmOStringStream progCmd;
+        progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start ";
+        // # in target
+        progCmd << lg->Convert(progressDir.c_str(),
+                                cmLocalGenerator::FULL,
+                                cmLocalGenerator::SHELL);
+        //
+        std::set<cmTarget *> emitted;
+        progCmd << " "
+                << this->CountProgressMarksInTarget(&t->second, emitted);
+        commands.push_back(progCmd.str());
+        }
+        }
       std::string tmp = cmake::GetCMakeFilesDirectoryPostSlash();
       tmp += "Makefile2";
       commands.push_back(lg->GetRecursiveMakeCall
                           (tmp.c_str(),localName.c_str()));
-      {
-      cmOStringStream progCmd;
-      progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
-      progCmd << lg->Convert(progressDir.c_str(),
-                              cmLocalGenerator::FULL,
-                              cmLocalGenerator::SHELL);
-      progCmd << " 0";
-      commands.push_back(progCmd.str());
-      }
+      if(!this->NoRuleMessages)
+        {
+        cmOStringStream progCmd;
+        progCmd << "$(CMAKE_COMMAND) -E cmake_progress_start "; // # 0
+        progCmd << lg->Convert(progressDir.c_str(),
+                                cmLocalGenerator::FULL,
+                                cmLocalGenerator::SHELL);
+        progCmd << " 0";
+        commands.push_back(progCmd.str());
+        }
       depends.clear();
       depends.push_back("cmake_check_build_system");
       localName = lg->GetRelativeTargetDirectory(t->second);
       localName += "/rule";
-      lg->WriteMakeRule(ruleFileStream, 
+      lg->WriteMakeRule(ruleFileStream,
                         "Build rule for subdir invocation for target.",
                         localName.c_str(), depends, commands, true);
-      
+
       // Add a target with the canonical name (no prefix, suffix or path).
       commands.clear();
       depends.clear();
       depends.push_back(localName);
       lg->WriteMakeRule(ruleFileStream, "Convenience name for target.",
                         t->second.GetName(), depends, commands, true);
-      
+
       // Add rules to prepare the target for installation.
       if(t->second.NeedRelinkBeforeInstall(lg->ConfigurationName.c_str()))
         {
@@ -833,7 +850,7 @@ cmGlobalUnixMakefileGenerator3
         commands.clear();
         commands.push_back(lg->GetRecursiveMakeCall
                             (makefileName.c_str(), localName.c_str()));
-        lg->WriteMakeRule(ruleFileStream, 
+        lg->WriteMakeRule(ruleFileStream,
                           "Pre-install relink rule for target.",
                           localName.c_str(), depends, commands, true);
 
@@ -846,7 +863,7 @@ cmGlobalUnixMakefileGenerator3
                             "preinstall", depends, commands, true);
           }
         }
-      
+
       // add the clean rule
       localName = lg->GetRelativeTargetDirectory(t->second);
       makeTargetName = localName;
@@ -987,7 +1004,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
   lg->AppendEcho(commands,"... all (the default if no target is provided)");
   lg->AppendEcho(commands,"... clean");
   lg->AppendEcho(commands,"... depend");
-  
+
   // Keep track of targets already listed.
   std::set<cmStdString> emittedTargets;
 
@@ -996,7 +1013,7 @@ void cmGlobalUnixMakefileGenerator3::WriteHelpRule
   cmLocalUnixMakefileGenerator3 *lg2;
   for (i = 0; i < this->LocalGenerators.size(); ++i)
     {
-    lg2 = 
+    lg2 =
       static_cast<cmLocalUnixMakefileGenerator3 *>(this->LocalGenerators[i]);
     // for the passed in makefile or if this is the top Makefile wripte out
     // the targets

Source/cmGlobalUnixMakefileGenerator3.h

@@ -22,19 +22,19 @@ class cmLocalUnixMakefileGenerator3;
  * \brief Write a Unix makefiles.
  *
  * cmGlobalUnixMakefileGenerator3 manages UNIX build process for a tree
- 
- 
+
+
  The basic approach of this generator is to produce Makefiles that will all
  be run with the current working directory set to the Home Output
  directory. The one exception to this is the subdirectory Makefiles which are
  created as a convenience and just cd up to the Home Output directory and
- invoke the main Makefiles. 
- 
+ invoke the main Makefiles.
+
  The make process starts with Makefile. Makefile should only contain the
  targets the user is likely to invoke directly from a make command line. No
  internal targets should be in this file. Makefile2 contains the internal
  targets that are required to make the process work.
- 
+
  Makefile2 in turn will recursively make targets in the correct order. Each
  target has its own directory <target>.dir and its own makefile build.make in
  that directory. Also in that directory is a couple makefiles per source file
@@ -47,7 +47,7 @@ class cmLocalUnixMakefileGenerator3;
  rescanned.
 
  Rules for custom commands follow the same model as rules for source files.
- 
+
  */
 
 class cmGlobalUnixMakefileGenerator3 : public cmGlobalGenerator
@@ -64,13 +64,13 @@ public:
 
   /** Get the documentation entry for this generator.  */
   virtual void GetDocumentation(cmDocumentationEntry& entry) const;
-  
+
   ///! Create a local generator appropriate to this Global Generator3
   virtual cmLocalGenerator *CreateLocalGenerator();
 
   /**
    * Try to determine system infomation such as shared library
-   * extension, pthreads, byte order etc.  
+   * extension, pthreads, byte order etc.
    */
   virtual void EnableLanguage(std::vector<std::string>const& languages,
                               cmMakefile *, bool optional);
@@ -78,11 +78,11 @@ public:
   /**
    * Generate the all required files for building this project/tree. This
    * basically creates a series of LocalGenerators for each directory and
-   * requests that they Generate.  
+   * requests that they Generate.
    */
   virtual void Generate();
-  
-  
+
+
   void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream,
                                        std::vector<cmLocalGenerator *> &);
 
@@ -91,7 +91,7 @@ public:
                      cmLocalUnixMakefileGenerator3 *);
 
   // write the top lvel target rules
-  void WriteConvenienceRules(std::ostream& ruleFileStream, 
+  void WriteConvenienceRules(std::ostream& ruleFileStream,
                              std::set<cmStdString> &emitted);
 
   /** Get the command to use for a target that has no rule.  This is
@@ -105,23 +105,13 @@ public:
   // change the build command for speed
   virtual std::string GenerateBuildCommand
   (const char* makeProgram,
-   const char *projectName, const char* additionalOptions, 
+   const char *projectName, const char* additionalOptions,
    const char *targetName,
    const char* config, bool ignoreErrors, bool fast);
 
   /** Record per-target progress information.  */
   void RecordTargetProgress(cmMakefileTargetGenerator* tg);
 
-  /**
-   * If true, the CMake variable CMAKE_VERBOSE_MAKEFILES doesn't have effect
-   * anymore. Set it to true when writing a generator where short output
-   * doesn't make sense, e.g. because the full output is parsed by an
-   * IDE/editor.
-   */
-  bool GetForceVerboseMakefiles() { return this->ForceVerboseMakefiles; }
-  void SetForceVerboseMakefiles(bool enable) 
-    {this->ForceVerboseMakefiles=enable;}
-
 protected:
   void WriteMainMakefile2();
   void WriteMainCMakefile();
@@ -169,7 +159,7 @@ protected:
   // in the rule to satisfy the make program.
   std::string EmptyRuleHackCommand;
 
-  bool ForceVerboseMakefiles;
+  bool NoRuleMessages;
 
   // Store per-target progress counters.
   struct TargetProgress

Source/cmGlobalVisualStudio10Generator.cxx

@@ -19,6 +19,10 @@
 cmGlobalVisualStudio10Generator::cmGlobalVisualStudio10Generator()
 {
   this->FindMakeProgramFile = "CMakeVS10FindMake.cmake";
+  std::string vc10Express;
+  this->ExpressEdition = cmSystemTools::ReadRegistryValue(
+    "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VCExpress\\10.0\\Setup\\VC;"
+    "ProductDir", vc10Express, cmSystemTools::KeyWOW64_32);
 }
 
 //----------------------------------------------------------------------------
@@ -62,6 +66,16 @@ void cmGlobalVisualStudio10Generator
   cmGlobalVisualStudio8Generator::EnableLanguage(lang, mf, optional);
 }
 
+//----------------------------------------------------------------------------
+const char* cmGlobalVisualStudio10Generator::GetPlatformToolset()
+{
+  if(!this->PlatformToolset.empty())
+    {
+    return this->PlatformToolset.c_str();
+    }
+  return 0;
+}
+
 //----------------------------------------------------------------------------
 std::string cmGlobalVisualStudio10Generator::GetUserMacrosDirectory()
 {

Source/cmGlobalVisualStudio10Generator.h

@@ -54,6 +54,12 @@ public:
                               cmMakefile *, bool optional);
   virtual void WriteSLNHeader(std::ostream& fout);
 
+  /** Is the installed VS an Express edition?  */
+  bool IsExpressEdition() const { return this->ExpressEdition; }
+
+  /** The toolset name for the target platform.  */
+  const char* GetPlatformToolset();
+
   /**
    * Where does this version of Visual Studio look for macros for the
    * current user? Returns the empty string if this version of Visual
@@ -70,5 +76,9 @@ public:
     { return "$(Configuration)";}
 protected:
   virtual const char* GetIDEVersion() { return "10.0"; }
+
+  std::string PlatformToolset;
+private:
+  bool ExpressEdition;
 };
 #endif

Source/cmGlobalVisualStudio10Win64Generator.cxx

@@ -36,3 +36,52 @@ void cmGlobalVisualStudio10Win64Generator
   mf->AddDefinition("MSVC_C_ARCHITECTURE_ID", "x64");
   mf->AddDefinition("MSVC_CXX_ARCHITECTURE_ID", "x64");
 }
+
+//----------------------------------------------------------------------------
+bool cmGlobalVisualStudio10Win64Generator::Find64BitTools(cmMakefile* mf)
+{
+  if(!this->PlatformToolset.empty())
+    {
+    return true;
+    }
+  // This edition does not come with 64-bit tools.  Look for them.
+  //
+  // TODO: Detect available tools?  x64\v100 exists but does not work?
+  // KHLM\\SOFTWARE\\Microsoft\\MSBuild\\ToolsVersions\\4.0;VCTargetsPath
+  // c:/Program Files (x86)/MSBuild/Microsoft.Cpp/v4.0/Platforms/
+  //   {Itanium,Win32,x64}/PlatformToolsets/{v100,v90,Windows7.1SDK}
+  std::string winSDK_7_1;
+  if(cmSystemTools::ReadRegistryValue(
+       "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Microsoft SDKs\\"
+       "Windows\\v7.1;InstallationFolder", winSDK_7_1))
+    {
+    cmOStringStream m;
+    m << "Found Windows SDK v7.1: " << winSDK_7_1;
+    mf->DisplayStatus(m.str().c_str(), -1);
+    this->PlatformToolset = "Windows7.1SDK";
+    return true;
+    }
+  else
+    {
+    cmOStringStream e;
+    e << "Cannot enable 64-bit tools with Visual Studio 2010 Express.\n"
+      << "Install the Microsoft Windows SDK v7.1 to get 64-bit tools:\n"
+      << "  http://msdn.microsoft.com/en-us/windows/bb980924.aspx";
+    mf->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
+    cmSystemTools::SetFatalErrorOccured();
+    return false;
+    }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalVisualStudio10Win64Generator
+::EnableLanguage(std::vector<std::string> const& languages,
+                 cmMakefile* mf, bool optional)
+{
+  if(this->IsExpressEdition() && !this->Find64BitTools(mf))
+    {
+    return;
+    }
+  this->cmGlobalVisualStudio10Generator
+    ::EnableLanguage(languages, mf, optional);
+}

Source/cmGlobalVisualStudio10Win64Generator.h

@@ -34,5 +34,8 @@ public:
 
   virtual void AddPlatformDefinitions(cmMakefile* mf);
 
+  bool Find64BitTools(cmMakefile* mf);
+  virtual void EnableLanguage(std::vector<std::string>const& languages,
+                              cmMakefile *, bool optional);
 };
 #endif

Source/cmGlobalVisualStudio6Generator.cxx

@@ -197,8 +197,6 @@ void cmGlobalVisualStudio6Generator
   this->GetTargetSets(projectTargets, originalTargets, root, generators);
   OrderedTargetDependSet orderedProjectTargets(projectTargets);
 
-  std::string rootdir = root->GetMakefile()->GetStartOutputDirectory();
-  rootdir += "/";
   for(OrderedTargetDependSet::const_iterator
         tt = orderedProjectTargets.begin();
       tt != orderedProjectTargets.end(); ++tt)

Source/cmGlobalVisualStudio71Generator.cxx

@@ -110,7 +110,7 @@ void cmGlobalVisualStudio71Generator
   this->GetTargetSets(projectTargets, originalTargets, root, generators);
   OrderedTargetDependSet orderedProjectTargets(projectTargets);
 
-  this->WriteTargetsToSolution(fout, root, orderedProjectTargets);
+  this->WriteTargetsToSolution(fout, orderedProjectTargets);
 
   bool useFolderProperty = this->UseFolderProperty();
   if (useFolderProperty)