ENH: merge in from main tree RC 15

14 files changed, 368 insertions, 128 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 6f1977436b..3ec9d07728 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -354,7 +354,7 @@ ENDMACRO (CMAKE_BUILD_UTILITIES)
 SET(CMake_VERSION_MAJOR 2)
 SET(CMake_VERSION_MINOR 6)
 SET(CMake_VERSION_PATCH 1)
-SET(CMake_VERSION_RC 14)
+SET(CMake_VERSION_RC 15)
 # CVS versions are odd, if this is an odd minor version
 # then set the CMake_VERSION_DATE variable
 IF("${CMake_VERSION_MINOR}" MATCHES "[13579]$")
diff --git a/ChangeLog.manual b/ChangeLog.manual
index 689c075fb9..486f186425 100644
--- a/ChangeLog.manual
+++ b/ChangeLog.manual
@@ -1,6 +1,25 @@
+Changes in CMake 2.6.1 RC 15
+- Fix bug 7426 FindJPEG module causes error when setting JPEG_LIBRARY to blank
+- Fix bug 7414 PackageMaker generator crashes when given components
+  with circular dependencies
+- Fix source files to not add extra /, and look for extensions for
+  all enabled languages.
+- Change link line to preserve input given to target_link_libraries even
+  if a shared library is repeated.  
+- Fix for bug 7421, fortran did not get arch flags on the mac
+- For CMP0008 do not depend on the files that are not there, which
+  makes the Xcode generator delete executables after they are built.
+- Work around Boost 1.36.0 bug fix on Darwin by setting the mangled 
+  compiler name to -xgccVERSION
+- Updated FindImageMagick to:
+  - Find newer additions such as animate, compare, etc.
+  - Find development api: Magick++, MagickCore, MagickWand
+  - Use FindPackageHandleStandardArgs to output standard messages.
+
 Changes in CMake 2.6.1 RC 14
 - Change dashboard submission to go directly to CDash.
 - Add policy CMP0008- Full-path libraries must be a valid library file name
+
 Changes in CMake 2.6.1 RC 12
 - More find locations for FindJNI.
 - Fix bug with source files ending in .l and .l.cpp, causing cmake
diff --git a/Modules/FindBoost.cmake b/Modules/FindBoost.cmake
index 905e6720ad..448707cdde 100644
--- a/Modules/FindBoost.cmake
+++ b/Modules/FindBoost.cmake
@@ -364,25 +364,37 @@ ELSE (_boost_IN_CACHE)
     SET (_boost_COMPILER "-mgw${_boost_COMPILER_VERSION}")
   ENDIF(MINGW)
   IF (UNIX)
-    IF (APPLE)
-      # Due to a quirk in Boost.Build, there is no compiler name
-      # mangled into library names on Mac OS X/Darwin.
-      SET (_boost_COMPILER "")
-    ELSE (APPLE)
-      IF (NOT CMAKE_COMPILER_IS_GNUCC)
-        # We assume that we have the Intel compiler.
-        SET (_boost_COMPILER "-il")
-      ELSE (NOT CMAKE_COMPILER_IS_GNUCC)
-        # Determine which version of GCC we have.
-        EXEC_PROGRAM(${CMAKE_CXX_COMPILER}
-            ARGS -dumpversion
-            OUTPUT_VARIABLE _boost_COMPILER_VERSION
+    IF (NOT CMAKE_COMPILER_IS_GNUCC)
+      # We assume that we have the Intel compiler.
+      SET (_boost_COMPILER "-il")
+    ELSE (NOT CMAKE_COMPILER_IS_GNUCC)
+      # Determine which version of GCC we have.
+      EXEC_PROGRAM(${CMAKE_CXX_COMPILER}
+        ARGS -dumpversion
+        OUTPUT_VARIABLE _boost_COMPILER_VERSION
         )
-        STRING(REGEX REPLACE "([0-9])\\.([0-9])\\.[0-9]" "\\1\\2"
-               _boost_COMPILER_VERSION ${_boost_COMPILER_VERSION})
+      STRING(REGEX REPLACE "([0-9])\\.([0-9])\\.[0-9]" "\\1\\2"
+        _boost_COMPILER_VERSION ${_boost_COMPILER_VERSION})
+      IF(APPLE)
+        IF(Boost_MINOR_VERSION)
+          IF(${Boost_MINOR_VERSION} GREATER 35)
+            # In Boost 1.36.0 and newer, the mangled compiler name used
+            # on Mac OS X/Darwin is "xgcc".
+            SET(_boost_COMPILER "-xgcc${_boost_COMPILER_VERSION}")
+          ELSE(${Boost_MINOR_VERSION} GREATER 35)
+            # In Boost <= 1.35.0, there is no mangled compiler name for
+            # the Mac OS X/Darwin version of GCC.
+            SET(_boost_COMPILER "")
+          ENDIF(${Boost_MINOR_VERSION} GREATER 35)
+        ELSE(Boost_MINOR_VERSION)
+          # We don't know the Boost version, so assume it's
+          # pre-1.36.0.
+          SET(_boost_COMPILER "")
+        ENDIF(Boost_MINOR_VERSION)
+      ELSE()
         SET (_boost_COMPILER "-gcc${_boost_COMPILER_VERSION}")
-      ENDIF (NOT CMAKE_COMPILER_IS_GNUCC)
-    ENDIF (APPLE)
+      ENDIF()
+    ENDIF (NOT CMAKE_COMPILER_IS_GNUCC)
   ENDIF(UNIX)
 
   SET (_boost_MULTITHREADED "-mt")
diff --git a/Modules/FindImageMagick.cmake b/Modules/FindImageMagick.cmake
index 66e54bcfee..16abcf6f2f 100644
--- a/Modules/FindImageMagick.cmake
+++ b/Modules/FindImageMagick.cmake
@@ -1,77 +1,190 @@
-# - Find Image Magick
-# This module finds if ImageMagick tools are installed and determines 
-# where the executables are. This code sets the following variables:
+# - Find the ImageMagick binary suite.
+# This module will search for a set of ImageMagick tools specified
+# as components in the FIND_PACKAGE call. Typical components include,
+# but are not limited to (future versions of ImageMagick might have
+# additional components not listed here):
 #
-#  IMAGEMAGICK_CONVERT_EXECUTABLE   = 
-#     the full path to the 'convert' utility 
-#  IMAGEMAGICK_MOGRIFY_EXECUTABLE   = 
-#     the full path to the 'mogrify' utility 
-#  IMAGEMAGICK_IMPORT_EXECUTABLE    = 
-#     the full path to the 'import'  utility 
-#  IMAGEMAGICK_MONTAGE_EXECUTABLE   = 
-#     the full path to the 'montage' utility 
-#  IMAGEMAGICK_COMPOSITE_EXECUTABLE = 
-#     the full path to the 'composite' utility 
+#  animate
+#  compare
+#  composite
+#  conjure
+#  convert
+#  display
+#  identify
+#  import
+#  mogrify
+#  montage
+#  stream
 #
+# If no component is specified in the FIND_PACKAGE call, then it only
+# searches for the ImageMagick executable directory. This code defines
+# the following variables:
+#
+#  ImageMagick_FOUND                  - TRUE if all components are found.
+#  ImageMagick_EXECUTABLE_DIR         - Full path to executables directory.
+#  ImageMagick_<component>_FOUND      - TRUE if <component> is found.
+#  ImageMagick_<component>_EXECUTABLE - Full path to <component> executable.
+#
+# There are also components for the following ImageMagick APIs:
+#
+#  Magick++
+#  MagickWand
+#  Magick
+#
+# For these components the following variables are set:
+#
+#  ImageMagick_FOUND                    - TRUE if all components are found.
+#  ImageMagick_INCLUDE_DIRS             - Full paths to all include dirs.
+#  ImageMagick_LIBRARIES                - Full paths to all libraries.
+#  ImageMagick_<component>_FOUND        - TRUE if <component> is found.
+#  ImageMagick_<component>_INCLUDE_DIRS - Full path to <component> include dirs.
+#  ImageMagick_<component>_LIBRARIES    - Full path to <component> libraries.
+#
+# Example Usages:
+#  FIND_PACKAGE(ImageMagick)
+#  FIND_PACKAGE(ImageMagick COMPONENTS convert)
+#  FIND_PACKAGE(ImageMagick COMPONENTS convert mogrify display)
+#  FIND_PACKAGE(ImageMagick COMPONENTS Magick++)
+#  FIND_PACKAGE(ImageMagick COMPONENTS Magick++ convert)
+#
+# Note that the standard FIND_PACKAGE features are supported
+# (i.e., QUIET, REQUIRED, etc.).
 
-IF (WIN32)
+# Copyright (c) 2007-2008,
+#  Miguel A. Figueroa-Villanueva, miguelf at ieee dot org.
+#
+# Redistribution and use is allowed according to the terms of the BSD license.
+# For details see the accompanying COPYING-CMAKE-SCRIPTS file.
 
-  # Try to find the ImageMagick binary path.
+#---------------------------------------------------------------------
+# Helper functions
+#---------------------------------------------------------------------
+FUNCTION(FIND_IMAGEMAGICK_API component header)
+  SET(ImageMagick_${component}_FOUND FALSE PARENT_SCOPE)
 
-  FIND_PATH(IMAGEMAGICK_BINARY_PATH mogrify.exe
-    [HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]
-    DOC "Path to the ImageMagick binary directory where all executable should be found."
-  )
+  FIND_PATH(ImageMagick_${component}_INCLUDE_DIR
+    NAMES ${header}
+    PATHS
+      ${ImageMagick_INCLUDE_DIRS}
+      "[HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]/include"
+    PATH_SUFFIXES
+      ImageMagick
+    DOC "Path to the ImageMagick include dir."
+    )
+  FIND_LIBRARY(ImageMagick_${component}_LIBRARY
+    NAMES ${ARGN}
+    PATHS
+      "[HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]/lib"
+    DOC "Path to the ImageMagick Magick++ library."
+    )
 
-  # Be extra-careful here: we do NOT want CMake to look in the system's PATH
-  # env var to search for convert.exe, otherwise it is going to pick
-  # Window's own convert.exe, and you may say good-bye to your disk.
+  IF(ImageMagick_${component}_INCLUDE_DIR AND ImageMagick_${component}_LIBRARY)
+    SET(ImageMagick_${component}_FOUND TRUE PARENT_SCOPE)
 
-  FIND_PROGRAM(IMAGEMAGICK_CONVERT_EXECUTABLE
-    NAMES convert
-    PATHS ${IMAGEMAGICK_BINARY_PATH}
-    NO_SYSTEM_PATH
-    DOC "Path to ImageMagick's convert executable. WARNING: note that this tool, named convert.exe, conflicts with Microsoft Window's own convert.exe, which is used to convert FAT partitions to NTFS format ! Therefore, be extra-careful and make sure the right convert.exe has been picked."
-  )
+    LIST(APPEND ImageMagick_INCLUDE_DIRS
+      ${ImageMagick_${component}_INCLUDE_DIR}
+      )
+    LIST(REMOVE_DUPLICATES ImageMagick_INCLUDE_DIRS)
+    SET(ImageMagick_INCLUDE_DIRS ${ImageMagick_INCLUDE_DIRS} PARENT_SCOPE)
 
-ELSE (WIN32)
+    LIST(APPEND ImageMagick_LIBRARIES
+      ${ImageMagick_${component}_LIBRARY}
+      )
+    SET(ImageMagick_LIBRARIES ${ImageMagick_LIBRARIES} PARENT_SCOPE)
+  ENDIF(ImageMagick_${component}_INCLUDE_DIR AND ImageMagick_${component}_LIBRARY)
+ENDFUNCTION(FIND_IMAGEMAGICK_API)
 
-  SET (IMAGEMAGICK_BINARY_PATH "")
+FUNCTION(FIND_IMAGEMAGICK_EXE component)
+  SET(_IMAGEMAGICK_EXECUTABLE
+    ${ImageMagick_EXECUTABLE_DIR}/${component}${CMAKE_EXECUTABLE_SUFFIX})
+  IF(EXISTS ${_IMAGEMAGICK_EXECUTABLE})
+    SET(ImageMagick_${component}_EXECUTABLE
+      ${_IMAGEMAGICK_EXECUTABLE}
+       PARENT_SCOPE
+       )
+    SET(ImageMagick_${component}_FOUND TRUE PARENT_SCOPE)
+  ELSE(EXISTS ${_IMAGEMAGICK_EXECUTABLE})
+    SET(ImageMagick_${component}_FOUND FALSE PARENT_SCOPE)
+  ENDIF(EXISTS ${_IMAGEMAGICK_EXECUTABLE})
+ENDFUNCTION(FIND_IMAGEMAGICK_EXE)
 
-  FIND_PROGRAM(IMAGEMAGICK_CONVERT_EXECUTABLE
-    NAMES convert
-    PATHS ${IMAGEMAGICK_BINARY_PATH}
-    DOC "Path to ImageMagick's convert executable."
+#---------------------------------------------------------------------
+# Start Actual Work
+#---------------------------------------------------------------------
+# Try to find a ImageMagick installation binary path.
+FIND_PATH(ImageMagick_EXECUTABLE_DIR
+  NAMES mogrify${CMAKE_EXECUTABLE_SUFFIX}
+  PATHS
+    "[HKEY_LOCAL_MACHINE\\SOFTWARE\\ImageMagick\\Current;BinPath]"
+  DOC "Path to the ImageMagick binary directory."
+  NO_DEFAULT_PATH
+  )
+FIND_PATH(ImageMagick_EXECUTABLE_DIR
+  NAMES mogrify${CMAKE_EXECUTABLE_SUFFIX}
   )
 
-ENDIF (WIN32)
-
-# Find mogrify, import, montage, composite
-
-FIND_PROGRAM(IMAGEMAGICK_MOGRIFY_EXECUTABLE
-  NAMES mogrify
-  PATHS ${IMAGEMAGICK_BINARY_PATH}
-  DOC "Path to ImageMagick's mogrify executable."
-)
-
-FIND_PROGRAM(IMAGEMAGICK_IMPORT_EXECUTABLE
-  NAMES import
-  PATHS ${IMAGEMAGICK_BINARY_PATH}
-  DOC "Path to ImageMagick's import executable."
-)
+# Find each component. Search for all tools in same dir
+# <ImageMagick_EXECUTABLE_DIR>; otherwise they should be found
+# independently and not in a cohesive module such as this one.
+SET(ImageMagick_FOUND TRUE)
+FOREACH(component ${ImageMagick_FIND_COMPONENTS}
+    # DEPRECATED: forced components for backward compatibility
+    convert mogrify import montage composite
+    )
+  IF(component STREQUAL "Magick++")
+    FIND_IMAGEMAGICK_API(Magick++ Magick++.h
+      Magick++ CORE_RL_Magick++_
+      )
+  ELSEIF(component STREQUAL "MagickWand")
+    FIND_IMAGEMAGICK_API(MagickWand wand/MagickWand.h
+      Wand MagickWand CORE_RL_wand_
+      )
+  ELSEIF(component STREQUAL "MagickCore")
+    FIND_IMAGEMAGICK_API(MagickCore magick/MagickCore.h
+      Magick MagickCore CORE_RL_magick_
+      )
+  ELSE(component STREQUAL "Magick++")
+    IF(ImageMagick_EXECUTABLE_DIR)
+      FIND_IMAGEMAGICK_EXE(${component})
+    ENDIF(ImageMagick_EXECUTABLE_DIR)
+  ENDIF(component STREQUAL "Magick++")
+  
+  IF(NOT ImageMagick_${component}_FOUND)
+    LIST(FIND ImageMagick_FIND_COMPONENTS ${component} is_requested)
+    IF(is_requested GREATER -1)
+      SET(ImageMagick_FOUND FALSE)
+    ENDIF(is_requested GREATER -1)
+  ENDIF(NOT ImageMagick_${component}_FOUND)
+ENDFOREACH(component)
 
-FIND_PROGRAM(IMAGEMAGICK_MONTAGE_EXECUTABLE
-  NAMES montage
-  PATHS ${IMAGEMAGICK_BINARY_PATH}
-  DOC "Path to ImageMagick's montage executable."
-)
+SET(ImageMagick_INCLUDE_DIRS ${ImageMagick_INCLUDE_DIRS})
+SET(ImageMagick_LIBRARIES ${ImageMagick_LIBRARIES})
 
-FIND_PROGRAM(IMAGEMAGICK_COMPOSITE_EXECUTABLE
-  NAMES composite
-  PATHS ${IMAGEMAGICK_BINARY_PATH}
-  DOC "Path to ImageMagick's composite executable."
-)
+#---------------------------------------------------------------------
+# Standard Package Output
+#---------------------------------------------------------------------
+INCLUDE(FindPackageHandleStandardArgs)
+FIND_PACKAGE_HANDLE_STANDARD_ARGS(
+  ImageMagick DEFAULT_MSG ImageMagick_FOUND
+  )
+# Maintain consistency with all other variables.
+SET(ImageMagick_FOUND ${IMAGEMAGICK_FOUND})
 
+#---------------------------------------------------------------------
+# DEPRECATED: Setting variables for backward compatibility.
+#---------------------------------------------------------------------
+SET(IMAGEMAGICK_BINARY_PATH          ${ImageMagick_EXECUTABLE_DIR}
+    CACHE PATH "Path to the ImageMagick binary directory.")
+SET(IMAGEMAGICK_CONVERT_EXECUTABLE   ${ImageMagick_convert_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's convert executable.")
+SET(IMAGEMAGICK_MOGRIFY_EXECUTABLE   ${ImageMagick_mogrify_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's mogrify executable.")
+SET(IMAGEMAGICK_IMPORT_EXECUTABLE    ${ImageMagick_import_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's import executable.")
+SET(IMAGEMAGICK_MONTAGE_EXECUTABLE   ${ImageMagick_montage_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's montage executable.")
+SET(IMAGEMAGICK_COMPOSITE_EXECUTABLE ${ImageMagick_composite_EXECUTABLE}
+    CACHE FILEPATH "Path to ImageMagick's composite executable.")
 MARK_AS_ADVANCED(
   IMAGEMAGICK_BINARY_PATH
   IMAGEMAGICK_CONVERT_EXECUTABLE
@@ -79,4 +192,4 @@ MARK_AS_ADVANCED(
   IMAGEMAGICK_IMPORT_EXECUTABLE
   IMAGEMAGICK_MONTAGE_EXECUTABLE
   IMAGEMAGICK_COMPOSITE_EXECUTABLE
-)
+  )
diff --git a/Modules/FindJPEG.cmake b/Modules/FindJPEG.cmake
index 3692ee1eb4..9849294485 100644
--- a/Modules/FindJPEG.cmake
+++ b/Modules/FindJPEG.cmake
@@ -23,6 +23,8 @@ ENDIF(JPEG_FOUND)
 
 # Deprecated declarations.
 SET (NATIVE_JPEG_INCLUDE_PATH ${JPEG_INCLUDE_DIR} )
-GET_FILENAME_COMPONENT (NATIVE_JPEG_LIB_PATH ${JPEG_LIBRARY} PATH)
+IF(JPEG_LIBRARY)
+  GET_FILENAME_COMPONENT (NATIVE_JPEG_LIB_PATH ${JPEG_LIBRARY} PATH)
+ENDIF(JPEG_LIBRARY)
 
 MARK_AS_ADVANCED(JPEG_LIBRARY JPEG_INCLUDE_DIR )
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.cxx b/Source/CPack/cmCPackPackageMakerGenerator.cxx
index d35e764678..049a6e450c 100644
--- a/Source/CPack/cmCPackPackageMakerGenerator.cxx
+++ b/Source/CPack/cmCPackPackageMakerGenerator.cxx
@@ -829,8 +829,10 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
     // on (B and A), while selecting something that depends on C--either D
     // or E--will automatically cause C to get selected.
     out << "selected=\"my.choice.selected";
-    AddDependencyAttributes(component, out);
-    AddReverseDependencyAttributes(component, out);
+    std::set<const cmCPackComponent *> visited;
+    AddDependencyAttributes(component, visited, out);
+    visited.clear();
+    AddReverseDependencyAttributes(component, visited, out);
     out << "\"";
     }
   out << ">" << std::endl;
@@ -868,15 +870,23 @@ cmCPackPackageMakerGenerator::CreateChoice(const cmCPackComponent& component,
 //----------------------------------------------------------------------
 void 
 cmCPackPackageMakerGenerator::
-AddDependencyAttributes(const cmCPackComponent& component, cmOStringStream& out)
+AddDependencyAttributes(const cmCPackComponent& component, 
+                        std::set<const cmCPackComponent *>& visited,
+                        cmOStringStream& out)
 {
+  if (visited.find(&component) != visited.end())
+    {
+    return;
+    }
+  visited.insert(&component);
+
   std::vector<cmCPackComponent *>::const_iterator dependIt;
   for (dependIt = component.Dependencies.begin();
        dependIt != component.Dependencies.end();
        ++dependIt)
     {
     out << " &amp;&amp; choices['" << (*dependIt)->Name << "Choice'].selected";
-    AddDependencyAttributes(**dependIt, out);
+    AddDependencyAttributes(**dependIt, visited, out);
     }
 }
 
@@ -884,15 +894,22 @@ AddDependencyAttributes(const cmCPackComponent& component, cmOStringStream& out)
 void 
 cmCPackPackageMakerGenerator::
 AddReverseDependencyAttributes(const cmCPackComponent& component, 
+                               std::set<const cmCPackComponent *>& visited,
                                cmOStringStream& out)
 {
+  if (visited.find(&component) != visited.end())
+    {
+    return;
+    }
+  visited.insert(&component);
+
   std::vector<cmCPackComponent *>::const_iterator dependIt;
   for (dependIt = component.ReverseDependencies.begin();
        dependIt != component.ReverseDependencies.end();
        ++dependIt)
     {
     out << " || choices['" << (*dependIt)->Name << "Choice'].selected";
-    AddReverseDependencyAttributes(**dependIt, out);
+    AddReverseDependencyAttributes(**dependIt, visited, out);
     }
 }
 
diff --git a/Source/CPack/cmCPackPackageMakerGenerator.h b/Source/CPack/cmCPackPackageMakerGenerator.h
index 228e099ced..ea835b759f 100644
--- a/Source/CPack/cmCPackPackageMakerGenerator.h
+++ b/Source/CPack/cmCPackPackageMakerGenerator.h
@@ -88,12 +88,15 @@ protected:
   // Subroutine of WriteDistributionFile that writes out the
   // dependency attributes for inter-component dependencies.
   void AddDependencyAttributes(const cmCPackComponent& component,
+                               std::set<const cmCPackComponent *>& visited,
                                cmOStringStream& out);
 
   // Subroutine of WriteDistributionFile that writes out the
   // reverse dependency attributes for inter-component dependencies.
-  void AddReverseDependencyAttributes(const cmCPackComponent& component,
-                                      cmOStringStream& out);
+  void 
+  AddReverseDependencyAttributes(const cmCPackComponent& component,
+                                 std::set<const cmCPackComponent *>& visited,
+                                 cmOStringStream& out);
 
   // Generates XML that encodes the hierarchy of component groups and
   // their components in a form that can be used by distribution
diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx
index 305c06d67d..72dd1982be 100644
--- a/Source/cmComputeLinkDepends.cxx
+++ b/Source/cmComputeLinkDepends.cxx
@@ -24,7 +24,6 @@
 #include "cmake.h"
 
 #include <cmsys/stl/algorithm>
-#include <cmsys/RegularExpression.hxx>
 
 #include <assert.h>
 
@@ -199,12 +198,6 @@ void cmComputeLinkDepends::SetOldLinkDirMode(bool b)
 }
 
 //----------------------------------------------------------------------------
-void cmComputeLinkDepends::SetSharedRegex(std::string const& regex)
-{
-  this->SharedRegexString = regex;
-}
-
-//----------------------------------------------------------------------------
 std::vector<cmComputeLinkDepends::LinkEntry> const&
 cmComputeLinkDepends::Compute()
 {
@@ -881,9 +874,6 @@ void cmComputeLinkDepends::CheckWrongConfigItem(std::string const& item)
 //----------------------------------------------------------------------------
 void cmComputeLinkDepends::PreserveOriginalEntries()
 {
-  // Regular expression to match shared libraries.
-  cmsys::RegularExpression shared_lib(this->SharedRegexString.c_str());
-
   // Skip the part of the input sequence that already appears in the
   // output.
   std::vector<int>::const_iterator in = this->OriginalEntries.begin();
@@ -892,8 +882,7 @@ void cmComputeLinkDepends::PreserveOriginalEntries()
         out != this->FinalLinkOrder.end())
     {
     cmTarget* tgt = this->EntryList[*in].Target;
-    if((tgt && tgt->GetType() != cmTarget::STATIC_LIBRARY) ||
-       (!tgt && shared_lib.find(this->EntryList[*in].Item)))
+    if(tgt && tgt->GetType() != cmTarget::STATIC_LIBRARY)
       {
       // Skip input items known to not be static libraries.
       ++in;
@@ -916,8 +905,7 @@ void cmComputeLinkDepends::PreserveOriginalEntries()
   while(in != this->OriginalEntries.end())
     {
     cmTarget* tgt = this->EntryList[*in].Target;
-    if((tgt && tgt->GetType() != cmTarget::STATIC_LIBRARY) ||
-       (!tgt && shared_lib.find(this->EntryList[*in].Item)))
+    if(tgt && tgt->GetType() != cmTarget::STATIC_LIBRARY)
       {
       // Skip input items known to not be static libraries.
       ++in;
diff --git a/Source/cmComputeLinkDepends.h b/Source/cmComputeLinkDepends.h
index 1b2809bd46..3e42580df8 100644
--- a/Source/cmComputeLinkDepends.h
+++ b/Source/cmComputeLinkDepends.h
@@ -58,10 +58,6 @@ public:
   std::set<cmTarget*> const& GetOldWrongConfigItems() const
     { return this->OldWrongConfigItems; }
 
-  /** Set a regular expression that matches strings ending in a shared
-      library extension.  */
-  void SetSharedRegex(std::string const& regex);
-
 private:
 
   // Context information.
@@ -141,7 +137,6 @@ private:
   // Preservation of original link line.
   std::vector<int> OriginalEntries;
   void PreserveOriginalEntries();
-  std::string SharedRegexString;
 
   // Compatibility help.
   bool OldLinkDirMode;
diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx
index af4b141e5f..6e0f10bf78 100644
--- a/Source/cmComputeLinkInformation.cxx
+++ b/Source/cmComputeLinkInformation.cxx
@@ -256,10 +256,10 @@ cmComputeLinkInformation
 
   // Allocate internals.
   this->OrderLinkerSearchPath =
-    new cmOrderDirectories(this->GlobalGenerator, target->GetName(),
+    new cmOrderDirectories(this->GlobalGenerator, target,
                            "linker search path");
   this->OrderRuntimeSearchPath =
-    new cmOrderDirectories(this->GlobalGenerator, target->GetName(),
+    new cmOrderDirectories(this->GlobalGenerator, target,
                            "runtime search path");
   this->OrderDependentRPath = 0;
 
@@ -362,7 +362,7 @@ cmComputeLinkInformation
     {
     this->SharedDependencyMode = SharedDepModeDir;
     this->OrderDependentRPath =
-      new cmOrderDirectories(this->GlobalGenerator, target->GetName(),
+      new cmOrderDirectories(this->GlobalGenerator, target,
                              "dependent library path");
     }
 
@@ -511,7 +511,6 @@ bool cmComputeLinkInformation::Compute()
   // Compute the ordered link line items.
   cmComputeLinkDepends cld(this->Target, this->Config);
   cld.SetOldLinkDirMode(this->OldLinkDirMode);
-  cld.SetSharedRegex(this->SharedRegexString);
   cmComputeLinkDepends::EntryVector const& linkEntries = cld.Compute();
 
   // Add the link line items.
@@ -1131,6 +1130,10 @@ bool cmComputeLinkInformation::CheckImplicitDirItem(std::string const& item)
   // portion.  This will allow the system linker to locate the proper
   // library for the architecture at link time.
   this->AddUserItem(file, false);
+
+  // Make sure the link directory ordering will find the library.
+  this->OrderLinkerSearchPath->AddLinkLibrary(item);
+
   return true;
 }
 
@@ -1362,6 +1365,14 @@ void cmComputeLinkInformation::AddSharedLibNoSOName(std::string const& item)
 void cmComputeLinkInformation::HandleBadFullItem(std::string const& item,
                                                  std::string const& file)
 {
+  // Do not depend on things that do not exist.
+  std::vector<std::string>::iterator i =
+    std::find(this->Depends.begin(), this->Depends.end(), item);
+  if(i != this->Depends.end())
+    {
+    this->Depends.erase(i);
+    }
+
   // Tell the linker to search for the item and provide the proper
   // path for it.  Do not contribute to any CMP0003 warning (do not
   // put in OldLinkDirItems or OldUserFlagItems).
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 1c6df15298..dd978fed69 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1630,7 +1630,7 @@ void cmLocalGenerator::AddLanguageFlags(std::string& flags,
     const char* sysrootDefault = 
       this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT_DEFAULT");
     bool flagsUsed = false;
-    if(osxArch && sysroot  && lang && lang[0] =='C')
+    if(osxArch && sysroot  && lang && (lang[0] =='C' || lang[0] == 'F'))
       { 
       std::vector<std::string> archs;
       cmSystemTools::ExpandListArgument(std::string(osxArch),
diff --git a/Source/cmOrderDirectories.cxx b/Source/cmOrderDirectories.cxx
index 25253d9920..54f23f7947 100644
--- a/Source/cmOrderDirectories.cxx
+++ b/Source/cmOrderDirectories.cxx
@@ -18,6 +18,7 @@
 
 #include "cmGlobalGenerator.h"
 #include "cmSystemTools.h"
+#include "cmake.h"
 
 #include <assert.h>
 
@@ -56,7 +57,7 @@ public:
     {
     for(unsigned int i=0; i < this->OD->OriginalDirectories.size(); ++i)
       {
-      // Check if this directory conflicts with they entry.
+      // Check if this directory conflicts with the entry.
       std::string const& dir = this->OD->OriginalDirectories[i];
       if(dir != this->Directory && this->FindConflict(dir))
         {
@@ -68,6 +69,29 @@ public:
         }
       }
     }
+
+  void FindImplicitConflicts(cmOStringStream& w)
+    {
+    bool first = true;
+    for(unsigned int i=0; i < this->OD->OriginalDirectories.size(); ++i)
+      {
+      // Check if this directory conflicts with the entry.
+      std::string const& dir = this->OD->OriginalDirectories[i];
+      if(dir != this->Directory && this->FindConflict(dir))
+        {
+        // The library will be found in this directory but it is
+        // supposed to be found in an implicit search directory.
+        if(first)
+          {
+          first = false;
+          w << "  ";
+          this->Report(w);
+          w << " in " << this->Directory << " may be hidden by files in:\n";
+          }
+        w << "    " << dir << "\n";
+        }
+      }
+    }
 protected:
   virtual bool FindConflict(std::string const& dir) = 0;
 
@@ -239,11 +263,11 @@ bool cmOrderDirectoriesConstraintLibrary::FindConflict(std::string const& dir)
 
 //----------------------------------------------------------------------------
 cmOrderDirectories::cmOrderDirectories(cmGlobalGenerator* gg,
-                                       const char* name,
+                                       cmTarget* target,
                                        const char* purpose)
 {
   this->GlobalGenerator = gg;
-  this->Name = name;
+  this->Target = target;
   this->Purpose = purpose;
   this->Computed = false;
 }
@@ -257,6 +281,12 @@ cmOrderDirectories::~cmOrderDirectories()
     {
     delete *i;
     }
+  for(std::vector<cmOrderDirectoriesConstraint*>::iterator
+        i = this->ImplicitDirEntries.begin();
+      i != this->ImplicitDirEntries.end(); ++i)
+    {
+    delete *i;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -279,13 +309,15 @@ void cmOrderDirectories::AddRuntimeLibrary(std::string const& fullPath,
   // Add the runtime library at most once.
   if(this->EmmittedConstraintSOName.insert(fullPath).second)
     {
-    // Avoid dealing with implicit directories.
+    // Implicit link directories need special handling.
     if(!this->ImplicitDirectories.empty())
       {
       std::string dir = cmSystemTools::GetFilenamePath(fullPath);
       if(this->ImplicitDirectories.find(dir) !=
          this->ImplicitDirectories.end())
         {
+        this->ImplicitDirEntries.push_back(
+          new cmOrderDirectoriesConstraintSOName(this, fullPath, soname));
         return;
         }
       }
@@ -312,13 +344,15 @@ void cmOrderDirectories::AddLinkLibrary(std::string const& fullPath)
   // Add the link library at most once.
   if(this->EmmittedConstraintLibrary.insert(fullPath).second)
     {
-    // Avoid dealing with implicit directories.
+    // Implicit link directories need special handling.
     if(!this->ImplicitDirectories.empty())
       {
       std::string dir = cmSystemTools::GetFilenamePath(fullPath);
       if(this->ImplicitDirectories.find(dir) !=
          this->ImplicitDirectories.end())
         {
+        this->ImplicitDirEntries.push_back(
+          new cmOrderDirectoriesConstraintLibrary(this, fullPath));
         return;
         }
       }
@@ -366,7 +400,7 @@ void cmOrderDirectories::CollectOriginalDirectories()
         di = this->UserDirectories.begin();
       di != this->UserDirectories.end(); ++di)
     {
-    // Avoid dealing with implicit directories.
+    // We never explicitly specify implicit link directories.
     if(this->ImplicitDirectories.find(*di) !=
        this->ImplicitDirectories.end())
       {
@@ -449,6 +483,39 @@ void cmOrderDirectories::FindConflicts()
       std::unique(i->begin(), i->end(), cmOrderDirectoriesCompare());
     i->erase(last, i->end());
     }
+
+  // Check items in implicit link directories.
+  this->FindImplicitConflicts();
+}
+
+//----------------------------------------------------------------------------
+void cmOrderDirectories::FindImplicitConflicts()
+{
+  // Check for items in implicit link directories that have conflicts
+  // in the explicit directories.
+  cmOStringStream conflicts;
+  for(unsigned int i=0; i < this->ImplicitDirEntries.size(); ++i)
+    {
+    this->ImplicitDirEntries[i]->FindImplicitConflicts(conflicts);
+    }
+
+  // Skip warning if there were no conflicts.
+  std::string text = conflicts.str();
+  if(text.empty())
+    {
+    return;
+    }
+
+  // Warn about the conflicts.
+  cmOStringStream w;
+  w << "Cannot generate a safe " << this->Purpose
+    << " for target " << this->Target->GetName()
+    << " because files in some directories may conflict with "
+    << " libraries in implicit directories:\n"
+    << text
+    << "Some of these libraries may not be found correctly.";
+  this->GlobalGenerator->GetCMakeInstance()
+    ->IssueMessage(cmake::WARNING, w.str(), this->Target->GetBacktrace());
 }
 
 //----------------------------------------------------------------------------
@@ -510,22 +577,24 @@ void cmOrderDirectories::DiagnoseCycle()
 
   // Construct the message.
   cmOStringStream e;
-  e << "WARNING: Cannot generate a safe " << this->Purpose
-    << " for target " << this->Name
+  e << "Cannot generate a safe " << this->Purpose
+    << " for target " << this->Target->GetName()
     << " because there is a cycle in the constraint graph:\n";
 
   // Display the conflict graph.
   for(unsigned int i=0; i < this->ConflictGraph.size(); ++i)
     {
     ConflictList const& clist = this->ConflictGraph[i];
-    e << "dir " << i << " is [" << this->OriginalDirectories[i] << "]\n";
+    e << "  dir " << i << " is [" << this->OriginalDirectories[i] << "]\n";
     for(ConflictList::const_iterator j = clist.begin();
         j != clist.end(); ++j)
       {
-      e << "  dir " << j->first << " must precede it due to ";
+      e << "    dir " << j->first << " must precede it due to ";
       this->ConstraintEntries[j->second]->Report(e);
       e << "\n";
       }
     }
-  cmSystemTools::Message(e.str().c_str());
+  e << "Some of these libraries may not be found correctly.";
+  this->GlobalGenerator->GetCMakeInstance()
+    ->IssueMessage(cmake::WARNING, e.str(), this->Target->GetBacktrace());
 }
diff --git a/Source/cmOrderDirectories.h b/Source/cmOrderDirectories.h
index 00a59559fd..54077334b3 100644
--- a/Source/cmOrderDirectories.h
+++ b/Source/cmOrderDirectories.h
@@ -24,6 +24,7 @@
 class cmGlobalGenerator;
 class cmOrderDirectoriesConstraint;
 class cmOrderDirectoriesConstraintLibrary;
+class cmTarget;
 
 /** \class cmOrderDirectories
  * \brief Compute a safe runtime path order for a set of shared libraries.
@@ -31,7 +32,7 @@ class cmOrderDirectoriesConstraintLibrary;
 class cmOrderDirectories
 {
 public:
-  cmOrderDirectories(cmGlobalGenerator* gg, const char* name,
+  cmOrderDirectories(cmGlobalGenerator* gg, cmTarget* target,
                      const char* purpose);
   ~cmOrderDirectories();
   void AddRuntimeLibrary(std::string const& fullPath, const char* soname = 0);
@@ -44,7 +45,7 @@ public:
   std::vector<std::string> const& GetOrderedDirectories();
 private:
   cmGlobalGenerator* GlobalGenerator;
-  std::string Name;
+  cmTarget* Target;
   std::string Purpose;
 
   bool Computed;
@@ -53,6 +54,7 @@ private:
 
   bool OrderedDirectoriesComputed;
   std::vector<cmOrderDirectoriesConstraint*> ConstraintEntries;
+  std::vector<cmOrderDirectoriesConstraint*> ImplicitDirEntries;
   std::vector<std::string> UserDirectories;
   cmsys::RegularExpression RemoveLibraryExtension;
   std::vector<std::string> LinkExtensions;
@@ -65,6 +67,7 @@ private:
   void CollectOriginalDirectories();
   int AddOriginalDirectory(std::string const& dir);
   void FindConflicts();
+  void FindImplicitConflicts();
   void OrderDirectories();
   void VisitDirectory(unsigned int i);
   void DiagnoseCycle();
diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx
index 274c0ed156..d7b2aa6baf 100644
--- a/Source/cmSourceFileLocation.cxx
+++ b/Source/cmSourceFileLocation.cxx
@@ -17,6 +17,8 @@
 #include "cmSourceFileLocation.h"
 
 #include "cmMakefile.h"
+#include "cmLocalGenerator.h"
+#include "cmGlobalGenerator.h"
 #include "cmSystemTools.h"
 
 //----------------------------------------------------------------------------
@@ -89,11 +91,14 @@ void cmSourceFileLocation::UpdateExtension(const char* name)
   std::string ext = cmSystemTools::GetFilenameLastExtension(name);
   if(!ext.empty()) { ext = ext.substr(1); }
 
-  // TODO: Let enable-language specify extensions for each language.
-  cmMakefile const* mf = this->Makefile;
+  // The global generator checks extensions of enabled languages.
+  cmGlobalGenerator* gg =
+    this->Makefile->GetLocalGenerator()->GetGlobalGenerator();
+  cmMakefile* mf = this->Makefile;
   const std::vector<std::string>& srcExts = mf->GetSourceExtensions();
   const std::vector<std::string>& hdrExts = mf->GetHeaderExtensions();
-  if(std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
+  if(gg->GetLanguageFromExtension(ext.c_str()) ||
+     std::find(srcExts.begin(), srcExts.end(), ext) != srcExts.end() ||
      std::find(hdrExts.begin(), hdrExts.end(), ext) != hdrExts.end())
     {
     // This is a known extension.  Use the given filename with extension.
@@ -113,8 +118,11 @@ void cmSourceFileLocation::UpdateExtension(const char* name)
       tryPath = this->Makefile->GetCurrentDirectory();
       tryPath += "/";
       }
-    tryPath += this->Directory;
-    tryPath += "/";
+    if(!this->Directory.empty())
+      {
+      tryPath += this->Directory;
+      tryPath += "/";
+      }
     tryPath += this->Name;
     if(cmSystemTools::FileExists(tryPath.c_str(), true))
       {