Merge branch 'master' into import-KWSys-subtree

61 files changed, 2396 insertions, 868 deletions

diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index c01c490..46bdec6 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -337,6 +337,8 @@ IF (WIN32)
       cmGlobalVisualStudio11Generator.cxx
       cmGlobalVisualStudio11Win64Generator.h
       cmGlobalVisualStudio11Win64Generator.cxx
+      cmGlobalVisualStudio11ARMGenerator.h
+      cmGlobalVisualStudio11ARMGenerator.cxx
       cmGlobalVisualStudioGenerator.cxx
       cmGlobalVisualStudioGenerator.h
       cmGlobalWatcomWMakeGenerator.cxx
@@ -423,6 +425,9 @@ SET(CTEST_SRCS cmCTest.cxx
   CTest/cmCTestConfigureHandler.cxx
   CTest/cmCTestCoverageCommand.cxx
   CTest/cmCTestCoverageHandler.cxx
+  CTest/cmParseMumpsCoverage.cxx
+  CTest/cmParseCacheCoverage.cxx
+  CTest/cmParseGTMCoverage.cxx
   CTest/cmParsePHPCoverage.cxx
   CTest/cmCTestEmptyBinaryDirectoryCommand.cxx
   CTest/cmCTestGenericHandler.cxx
diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake
index 9a31b07..345a56f 100644
--- a/Source/CMakeVersion.cmake
+++ b/Source/CMakeVersion.cmake
@@ -2,5 +2,5 @@
 SET(CMake_VERSION_MAJOR 2)
 SET(CMake_VERSION_MINOR 8)
 SET(CMake_VERSION_PATCH 8)
-SET(CMake_VERSION_TWEAK 20120508)
+SET(CMake_VERSION_TWEAK 20120612)
 #SET(CMake_VERSION_RC 1)
diff --git a/Source/CPack/cmCPackDebGenerator.h b/Source/CPack/cmCPackDebGenerator.h
index f536c47..7f2352f 100644
--- a/Source/CPack/cmCPackDebGenerator.h
+++ b/Source/CPack/cmCPackDebGenerator.h
@@ -31,6 +31,17 @@ public:
   cmCPackDebGenerator();
   virtual ~cmCPackDebGenerator();
 
+  static bool CanGenerate()
+    {
+#ifdef __APPLE__
+    // on MacOS enable CPackDeb iff dpkg is found
+    return cmSystemTools::FindProgram("dpkg") != "" ? true : false;
+#else
+    // legacy behavior on other systems
+    return true;
+#endif
+    }
+
 protected:
   virtual int InitializeInternal();
   /**
diff --git a/Source/CPack/cmCPackDocumentVariables.cxx b/Source/CPack/cmCPackDocumentVariables.cxx
index d2e3802..edbef45 100644
--- a/Source/CPack/cmCPackDocumentVariables.cxx
+++ b/Source/CPack/cmCPackDocumentVariables.cxx
@@ -77,4 +77,35 @@ void cmCPackDocumentVariables::DefineVariables(cmake* cm)
          "which is done right before packaging the files."
          " The script is not called by e.g.: make install.", false,
          "Variables common to all CPack generators");
+
+  cm->DefineProperty
+        ("CPACK_ABSOLUTE_DESTINATION_FILES", cmProperty::VARIABLE,
+         "List of files which have been installed using "
+         " an ABSOLUTE DESTINATION path.",
+         "This variable is a Read-Only variable which is set internally"
+         " by CPack during installation and before packaging using"
+         " CMAKE_ABSOLUTE_DESTINATION_FILES defined in cmake_install.cmake "
+         "scripts. The value can be used within CPack project configuration"
+         " file and/or CPack<GEN>.cmake file of <GEN> generator.", false,
+         "Variables common to all CPack generators");
+
+  cm->DefineProperty
+        ("CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
+         "Ask CPack to warn each time a file with absolute INSTALL"
+         " DESTINATION is encountered.",
+         "This variable triggers the definition of "
+         "CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION when CPack runs"
+         " cmake_install.cmake scripts.", false,
+         "Variables common to all CPack generators");
+
+  cm->DefineProperty
+        ("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
+         "Ask CPack to error out as soon as a file with absolute INSTALL"
+         " DESTINATION is encountered.",
+         "The fatal error is emitted before the installation of "
+         "the offending file takes place. Some CPack generators, like NSIS,"
+         "enforce this internally. "
+         "This variable triggers the definition of"
+         "CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION when CPack runs"
+         "Variables common to all CPack generators");
 }
diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx
index 0f832b3..0177653 100644
--- a/Source/CPack/cmCPackGenerator.cxx
+++ b/Source/CPack/cmCPackGenerator.cxx
@@ -62,10 +62,31 @@ void cmCPackGenerator::DisplayVerboseOutput(const char* msg,
 
 //----------------------------------------------------------------------
 int cmCPackGenerator::PrepareNames()
-{  
+{
   cmCPackLogger(cmCPackLog::LOG_DEBUG,
     "Create temp directory." << std::endl);
 
+  // checks CPACK_SET_DESTDIR support
+  if (IsOn("CPACK_SET_DESTDIR"))
+    {
+      if (SETDESTDIR_UNSUPPORTED==SupportsSetDestdir())
+        {
+          cmCPackLogger(cmCPackLog::LOG_ERROR,
+                        "CPACK_SET_DESTDIR is set to ON but the '"
+                        << Name << "' generator does NOT support it."
+                        << std::endl);
+          return 0;
+        }
+      else if (SETDESTDIR_SHOULD_NOT_BE_USED==SupportsSetDestdir())
+        {
+          cmCPackLogger(cmCPackLog::LOG_WARNING,
+                        "CPACK_SET_DESTDIR is set to ON but it is "
+                        << "usually a bad idea to do that with '"
+                        << Name << "' generator. Use at your own risk."
+                        << std::endl);
+        }
+  }
+
   std::string tempDirectory = this->GetOption("CPACK_PACKAGE_DIRECTORY");
   tempDirectory += "/_CPack_Packages/";
   const char* toplevelTag = this->GetOption("CPACK_TOPLEVEL_TAG");
@@ -388,8 +409,11 @@ int cmCPackGenerator::InstallProjectViaInstalledDirectories(
                                    std::string>(targetFile,inFileRelative));
           }
         /* If it is not a symlink then do a plain copy */
-        else if ( !cmSystemTools::CopyFileIfDifferent(inFile.c_str(),
-            filePath.c_str()) )
+        else if (!(
+            cmSystemTools::CopyFileIfDifferent(inFile.c_str(),filePath.c_str())
+            &&
+            cmSystemTools::CopyFileTime(inFile.c_str(),filePath.c_str())
+                ) )
           {
           cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem copying file: "
             << inFile.c_str() << " -> " << filePath.c_str() << std::endl);
@@ -828,8 +852,35 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects(
           filesBefore = glB.GetFiles();
           std::sort(filesBefore.begin(),filesBefore.end());
           }
+
+        // If CPack was asked to warn on ABSOLUTE INSTALL DESTINATION
+        // then forward request to cmake_install.cmake script
+        if (this->GetOption("CPACK_WARN_ON_ABSOLUTE_INSTALL_DESTINATION"))
+          {
+            mf->AddDefinition("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION",
+                              "1");
+          }
+        // If current CPack generator does support
+        // ABSOLUTE INSTALL DESTINATION or CPack has been asked for
+        // then ask cmake_install.cmake script to error out
+        // as soon as it occurs (before installing file)
+        if (!SupportsAbsoluteDestination() ||
+            this->GetOption("CPACK_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION"))
+          {
+            mf->AddDefinition("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION",
+                              "1");
+          }
         // do installation
         int res = mf->ReadListFile(0, installFile.c_str());
+        // forward definition of CMAKE_ABSOLUTE_DESTINATION_FILES
+        // to CPack (may be used by generators like CPack RPM or DEB)
+        // in order to transparently handle ABSOLUTE PATH
+        if (mf->GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"))
+          {
+            mf->AddDefinition("CPACK_ABSOLUTE_DESTINATION_FILES",
+                mf->GetDefinition("CMAKE_ABSOLUTE_DESTINATION_FILES"));
+          }
+
         // Now rebuild the list of files after installation
         // of the current component (if we are in component install)
         if (componentInstall)
@@ -953,6 +1004,8 @@ int cmCPackGenerator::DoPackage()
   cmCPackLogger(cmCPackLog::LOG_OUTPUT,
     "Create package using " << this->Name.c_str() << std::endl);
 
+  // Prepare CPack internal name and check
+  // values for many CPACK_xxx vars
   if ( !this->PrepareNames() )
     {
     return 0;
@@ -1431,6 +1484,19 @@ std::string cmCPackGenerator::GetComponentPackageFileName(
 }
 
 //----------------------------------------------------------------------
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackGenerator::SupportsSetDestdir() const
+{
+  return cmCPackGenerator::SETDESTDIR_SUPPORTED;
+}
+
+//----------------------------------------------------------------------
+bool cmCPackGenerator::SupportsAbsoluteDestination() const
+{
+  return true;
+}
+
+//----------------------------------------------------------------------
 bool cmCPackGenerator::SupportsComponentInstallation() const
 {
   return false;
diff --git a/Source/CPack/cmCPackGenerator.h b/Source/CPack/cmCPackGenerator.h
index 55afb44..6748512 100644
--- a/Source/CPack/cmCPackGenerator.h
+++ b/Source/CPack/cmCPackGenerator.h
@@ -63,6 +63,16 @@ public:
       cmSystemTools::OUTPUT_MERGE : cmSystemTools::OUTPUT_NONE; }
 
   /**
+   * Returns true if the generator may work on this system.
+   * Rational:
+   * Some CPack generator may run on some host and may not on others
+   * (with the same system) because some tools are missing. If the tool
+   * is missing then CPack won't activate (in the CPackGeneratorFactory)
+   * this particular generator.
+   */
+  static bool CanGenerate() { return true; }
+
+  /**
    * Do the actual whole package processing.
    * Subclass may redefine it but its usually enough
    * to redefine @ref PackageFiles, because in fact
@@ -190,6 +200,38 @@ protected:
     bool setDestDir, const char* tempInstallDirectory);
 
   /**
+   * The various level of support of
+   * CPACK_SET_DESTDIR used by the generator.
+   */
+  enum CPackSetDestdirSupport {
+    /* the generator works with or without it */
+    SETDESTDIR_SUPPORTED,
+    /* the generator works best if automatically handled */
+    SETDESTDIR_INTERNALLY_SUPPORTED,
+    /* no official support, use at your own risk */
+    SETDESTDIR_SHOULD_NOT_BE_USED,
+    /* officially NOT supported */
+    SETDESTDIR_UNSUPPORTED
+  };
+
+  /**
+   * Does the CPack generator support CPACK_SET_DESTDIR?
+   * The default legacy value is 'SETDESTDIR_SUPPORTED' generator
+   * have to override it in order change this.
+   * @return CPackSetDestdirSupport
+   */
+  virtual enum CPackSetDestdirSupport SupportsSetDestdir() const;
+
+  /**
+   * Does the CPack generator support absolute path
+   * in INSTALL DESTINATION?
+   * The default legacy value is 'true' generator
+   * have to override it in order change this.
+   * @return true if supported false otherwise
+   */
+  virtual bool SupportsAbsoluteDestination() const;
+
+  /**
    * Does the CPack generator support component installation?.
    * Some Generators requires the user to set
    * CPACK_<GENNAME>_COMPONENT_INSTALL in order to make this
diff --git a/Source/CPack/cmCPackGeneratorFactory.cxx b/Source/CPack/cmCPackGeneratorFactory.cxx
index a04b403..37ff460 100644
--- a/Source/CPack/cmCPackGeneratorFactory.cxx
+++ b/Source/CPack/cmCPackGeneratorFactory.cxx
@@ -31,7 +31,7 @@
 #  include "cmCPackCygwinSourceGenerator.h"
 #endif
 
-#if !defined(_WIN32) && !defined(__APPLE__) \
+#if !defined(_WIN32) \
  && !defined(__QNXNTO__) && !defined(__BEOS__)
 #  include "cmCPackDebGenerator.h"
 #  include "cmCPackRPMGenerator.h"
@@ -40,44 +40,90 @@
 
 #include "cmCPackLog.h"
 
+#if defined(__BORLANDC__)
+# pragma warn -8008 /* condition is always true */
+#endif
+
 //----------------------------------------------------------------------
 cmCPackGeneratorFactory::cmCPackGeneratorFactory()
 {
-  this->RegisterGenerator("TGZ", "Tar GZip compression",
-    cmCPackTGZGenerator::CreateGenerator);
-  this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
-    cmCPackSTGZGenerator::CreateGenerator);
-  this->RegisterGenerator("NSIS", "Null Soft Installer",
-    cmCPackNSISGenerator::CreateGenerator);
+  if (cmCPackTGZGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("TGZ", "Tar GZip compression",
+      cmCPackTGZGenerator::CreateGenerator);
+    }
+  if (cmCPackSTGZGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("STGZ", "Self extracting Tar GZip compression",
+      cmCPackSTGZGenerator::CreateGenerator);
+    }
+  if (cmCPackNSISGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("NSIS", "Null Soft Installer",
+      cmCPackNSISGenerator::CreateGenerator);
+    }
 #ifdef __CYGWIN__
-  this->RegisterGenerator("CygwinBinary", "Cygwin Binary Installer",
-                          cmCPackCygwinBinaryGenerator::CreateGenerator);
-  this->RegisterGenerator("CygwinSource", "Cygwin Source Installer",
-                          cmCPackCygwinSourceGenerator::CreateGenerator);
+  if (cmCPackCygwinBinaryGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("CygwinBinary", "Cygwin Binary Installer",
+                            cmCPackCygwinBinaryGenerator::CreateGenerator);
+    }
+  if (cmCPackCygwinSourceGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("CygwinSource", "Cygwin Source Installer",
+                            cmCPackCygwinSourceGenerator::CreateGenerator);
+    }
 #endif
 
-  this->RegisterGenerator("ZIP", "ZIP file format",
-    cmCPackZIPGenerator::CreateGenerator);
-  this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
-    cmCPackTarBZip2Generator::CreateGenerator);
-  this->RegisterGenerator("TZ", "Tar Compress compression",
-    cmCPackTarCompressGenerator::CreateGenerator);
+  if (cmCPackZIPGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("ZIP", "ZIP file format",
+      cmCPackZIPGenerator::CreateGenerator);
+    }
+  if (cmCPackTarBZip2Generator::CanGenerate())
+    {
+    this->RegisterGenerator("TBZ2", "Tar BZip2 compression",
+      cmCPackTarBZip2Generator::CreateGenerator);
+    }
+  if (cmCPackTarCompressGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("TZ", "Tar Compress compression",
+      cmCPackTarCompressGenerator::CreateGenerator);
+    }
 #ifdef __APPLE__
-  this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
-    cmCPackDragNDropGenerator::CreateGenerator);
-  this->RegisterGenerator("Bundle", "Mac OSX bundle",
-    cmCPackBundleGenerator::CreateGenerator);
-  this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
-    cmCPackPackageMakerGenerator::CreateGenerator);
-  this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
-    cmCPackOSXX11Generator::CreateGenerator);
+  if (cmCPackDragNDropGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("DragNDrop", "Mac OSX Drag And Drop",
+      cmCPackDragNDropGenerator::CreateGenerator);
+    }
+  if (cmCPackBundleGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("Bundle", "Mac OSX bundle",
+      cmCPackBundleGenerator::CreateGenerator);
+    }
+  if (cmCPackPackageMakerGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("PackageMaker", "Mac OSX Package Maker installer",
+      cmCPackPackageMakerGenerator::CreateGenerator);
+    }
+  if (cmCPackOSXX11Generator::CanGenerate())
+    {
+    this->RegisterGenerator("OSXX11", "Mac OSX X11 bundle",
+      cmCPackOSXX11Generator::CreateGenerator);
+    }
 #endif
-#if !defined(_WIN32) && !defined(__APPLE__) \
+#if !defined(_WIN32) \
   && !defined(__QNXNTO__) && !defined(__BEOS__)
-  this->RegisterGenerator("DEB", "Debian packages",
-    cmCPackDebGenerator::CreateGenerator);
-  this->RegisterGenerator("RPM", "RPM packages",
-    cmCPackRPMGenerator::CreateGenerator);
+  if (cmCPackDebGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("DEB", "Debian packages",
+      cmCPackDebGenerator::CreateGenerator);
+    }
+  if (cmCPackRPMGenerator::CanGenerate())
+    {
+    this->RegisterGenerator("RPM", "RPM packages",
+      cmCPackRPMGenerator::CreateGenerator);
+    }
 #endif
 }
 
diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx
index 0787ef9..7b52511 100644
--- a/Source/CPack/cmCPackNSISGenerator.cxx
+++ b/Source/CPack/cmCPackNSISGenerator.cxx
@@ -64,6 +64,7 @@ int cmCPackNSISGenerator::PackageFiles()
       << std::endl);
     return false;
     }
+
   std::string nsisFileName = this->GetOption("CPACK_TOPLEVEL_DIRECTORY");
   std::string tmpFile = nsisFileName;
   tmpFile += "/NSISOutput.log";
@@ -542,8 +543,8 @@ void cmCPackNSISGenerator::CreateMenuLinks( cmOStringStream& str,
     {
     cmCPackLogger(
       cmCPackLog::LOG_ERROR,
-      "CPACK_PACKAGE_EXECUTABLES should contain pairs of <executable> and "
-      "<icon name>." << std::endl);
+      "CPACK_NSIS_MENU_LINKS should contain pairs of <shortcut target> and "
+      "<shortcut label>." << std::endl);
     return;
     }
 
@@ -631,6 +632,19 @@ bool cmCPackNSISGenerator::GetListOfSubdirectories(const char* topdir,
 }
 
 //----------------------------------------------------------------------
+enum cmCPackGenerator::CPackSetDestdirSupport
+cmCPackNSISGenerator::SupportsSetDestdir() const
+{
+  return cmCPackGenerator::SETDESTDIR_SHOULD_NOT_BE_USED;
+}
+
+//----------------------------------------------------------------------
+bool cmCPackNSISGenerator::SupportsAbsoluteDestination() const
+{
+        return false;
+}
+
+//----------------------------------------------------------------------
 bool cmCPackNSISGenerator::SupportsComponentInstallation() const
 {
         return true;
diff --git a/Source/CPack/cmCPackNSISGenerator.h b/Source/CPack/cmCPackNSISGenerator.h
index 7bccb89..8224854 100644
--- a/Source/CPack/cmCPackNSISGenerator.h
+++ b/Source/CPack/cmCPackNSISGenerator.h
@@ -44,6 +44,8 @@ protected:
   bool GetListOfSubdirectories(const char* dir,
     std::vector<std::string>& dirs);
 
+  enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const;
+  virtual bool SupportsAbsoluteDestination() const;
   virtual bool SupportsComponentInstallation() const;
 
   /// Produce a string that contains the NSIS code to describe a
diff --git a/Source/CPack/cmCPackRPMGenerator.h b/Source/CPack/cmCPackRPMGenerator.h
index 4883a0d..eec8204 100644
--- a/Source/CPack/cmCPackRPMGenerator.h
+++ b/Source/CPack/cmCPackRPMGenerator.h
@@ -35,6 +35,17 @@ public:
   cmCPackRPMGenerator();
   virtual ~cmCPackRPMGenerator();
 
+  static bool CanGenerate()
+    {
+#ifdef __APPLE__
+    // on MacOS enable CPackRPM iff rpmbuild is found
+    return cmSystemTools::FindProgram("rpmbuild") != "" ? true : false;
+#else
+    // legacy behavior on other systems
+    return true;
+#endif
+    }
+
 protected:
   virtual int InitializeInternal();
   virtual int PackageFiles();
diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx
index ae06b0f..81d3669 100644
--- a/Source/CTest/cmCTestCoverageHandler.cxx
+++ b/Source/CTest/cmCTestCoverageHandler.cxx
@@ -11,6 +11,8 @@
 ============================================================================*/
 #include "cmCTestCoverageHandler.h"
 #include "cmParsePHPCoverage.h"
+#include "cmParseGTMCoverage.h"
+#include "cmParseCacheCoverage.h"
 #include "cmCTest.h"
 #include "cmake.h"
 #include "cmMakefile.h"
@@ -373,21 +375,29 @@ int cmCTestCoverageHandler::ProcessHandler()
     }
   int file_count = 0;
   file_count += this->HandleGCovCoverage(&cont);
+  error = cont.Error;
   if ( file_count < 0 )
     {
     return error;
     }
   file_count += this->HandleTracePyCoverage(&cont);
+  error = cont.Error;
   if ( file_count < 0 )
     {
     return error;
     }
   file_count += this->HandlePHPCoverage(&cont);
+  error = cont.Error;
   if ( file_count < 0 )
     {
     return error;
     }
+  file_count += this->HandleMumpsCoverage(&cont);
   error = cont.Error;
+  if ( file_count < 0 )
+    {
+    return error;
+    }
 
   std::set<std::string> uncovered = this->FindUncoveredFiles(&cont);
 
@@ -751,6 +761,46 @@ int cmCTestCoverageHandler::HandlePHPCoverage(
     }
   return static_cast<int>(cont->TotalCoverage.size());
 }
+//----------------------------------------------------------------------
+int cmCTestCoverageHandler::HandleMumpsCoverage(
+  cmCTestCoverageHandlerContainer* cont)
+{
+  // try gtm coverage
+  cmParseGTMCoverage cov(*cont, this->CTest);
+  std::string coverageFile = this->CTest->GetBinaryDir() +
+    "/gtm_coverage.mcov";
+  if(cmSystemTools::FileExists(coverageFile.c_str()))
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Parsing Cache Coverage: " << coverageFile
+               << std::endl);
+    cov.ReadCoverageFile(coverageFile.c_str());
+    return static_cast<int>(cont->TotalCoverage.size());
+    }
+  else
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               " Cannot find foobar GTM coverage file: " << coverageFile
+               << std::endl);
+    }
+  cmParseCacheCoverage ccov(*cont, this->CTest);
+  coverageFile = this->CTest->GetBinaryDir() +
+    "/cache_coverage.cmcov";
+  if(cmSystemTools::FileExists(coverageFile.c_str()))
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               "Parsing Cache Coverage: " << coverageFile
+               << std::endl);
+    ccov.ReadCoverageFile(coverageFile.c_str());
+    }
+  else
+    {
+    cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+               " Cannot find Cache coverage file: " << coverageFile
+               << std::endl);
+    }
+  return static_cast<int>(cont->TotalCoverage.size());
+}
 
 struct cmCTestCoverageHandlerLocale
 {
@@ -800,7 +850,7 @@ int cmCTestCoverageHandler::HandleGCovCoverage(
   std::string st2gcovOutputRex1 = "^File *[`'](.*)'$";
   std::string st2gcovOutputRex2
     = "Lines executed: *[0-9]+\\.[0-9]+% of [0-9]+$";
-  std::string st2gcovOutputRex3 = "^(.*):creating [`'](.*\\.gcov)'";
+  std::string st2gcovOutputRex3 = "^(.*)reating [`'](.*\\.gcov)'";
   std::string st2gcovOutputRex4 = "^(.*):unexpected EOF *$";
   std::string st2gcovOutputRex5 = "^(.*):cannot open source file*$";
   std::string st2gcovOutputRex6
@@ -1806,7 +1856,7 @@ int cmCTestCoverageHandler::HandleBullseyeCoverage(
   cmCTestCoverageHandlerContainer* cont)
 {
   const char* covfile = cmSystemTools::GetEnv("COVFILE");
-  if(!covfile)
+  if(!covfile || strlen(covfile) == 0)
     {
     cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT, 
                " COVFILE environment variable not found, not running " 
diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h
index d3e8503..92b0b22 100644
--- a/Source/CTest/cmCTestCoverageHandler.h
+++ b/Source/CTest/cmCTestCoverageHandler.h
@@ -70,6 +70,8 @@ private:
 
   //! Handle coverage using xdebug php coverage
   int HandlePHPCoverage(cmCTestCoverageHandlerContainer* cont);
+  //! Handle coverage for mumps
+  int HandleMumpsCoverage(cmCTestCoverageHandlerContainer* cont);
 
   //! Handle coverage using Bullseye
   int HandleBullseyeCoverage(cmCTestCoverageHandlerContainer* cont);
diff --git a/Source/CTest/cmParseCacheCoverage.cxx b/Source/CTest/cmParseCacheCoverage.cxx
new file mode 100644
index 0000000..137f344
--- /dev/null
+++ b/Source/CTest/cmParseCacheCoverage.cxx
@@ -0,0 +1,220 @@
+#include "cmStandardIncludes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmSystemTools.h"
+#include "cmParseCacheCoverage.h"
+#include <cmsys/Directory.hxx>
+#include <cmsys/Glob.hxx>
+
+
+cmParseCacheCoverage::cmParseCacheCoverage(
+  cmCTestCoverageHandlerContainer& cont,
+  cmCTest* ctest)
+  :cmParseMumpsCoverage(cont, ctest)
+{
+}
+
+
+bool cmParseCacheCoverage::LoadCoverageData(const char* d)
+{
+  // load all the .mcov files in the specified directory
+  cmsys::Directory dir;
+  if(!dir.Load(d))
+    {
+    return false;
+    }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++)
+    {
+    std::string file = dir.GetFile(i);
+    if(file != "." && file != ".."
+       && !cmSystemTools::FileIsDirectory(file.c_str()))
+      {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if(cmSystemTools::GetFilenameLastExtension(path) == ".cmcov")
+        {
+        if(!this->ReadCMCovFile(path.c_str()))
+          {
+          return false;
+          }
+        }
+      }
+    }
+  return true;
+}
+
+// not currently used, but leave it in case we want it in the future
+void cmParseCacheCoverage::RemoveUnCoveredFiles()
+{
+  // loop over the coverage data computed and remove all files
+  // that only have -1 or 0 for the lines.
+  cmCTestCoverageHandlerContainer::TotalCoverageMap::iterator ci =
+    this->Coverage.TotalCoverage.begin();
+  while(ci != this->Coverage.TotalCoverage.end())
+    {
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector& v =
+      ci->second;
+    bool nothing = true;
+    for(cmCTestCoverageHandlerContainer::SingleFileCoverageVector::iterator i=
+          v.begin(); i != v.end(); ++i)
+      {
+      if(*i > 0)
+        {
+        nothing = false;
+        break;
+        }
+      }
+    if(nothing)
+      {
+      cmCTestLog(this->CTest, HANDLER_VERBOSE_OUTPUT,
+                 "No coverage found in: " << ci->first
+                 << std::endl);
+      this->Coverage.TotalCoverage.erase(ci++);
+      }
+    else
+      {
+      ++ci;
+      }
+    }
+}
+
+bool cmParseCacheCoverage::SplitString(std::vector<std::string>& args,
+                                       std::string const& line)
+{
+  std::string::size_type pos1 = 0;
+  std::string::size_type pos2 = line.find(',', 0);
+  if(pos2 == std::string::npos)
+    {
+    return false;
+    }
+  std::string arg;
+  while(pos2 != std::string::npos)
+    {
+    arg = line.substr(pos1, pos2-pos1);
+    args.push_back(arg);
+    pos1 = pos2+1;
+    pos2 = line.find(',',pos1);
+    }
+  arg = line.substr(pos1);
+  args.push_back(arg);
+  return true;
+}
+
+bool cmParseCacheCoverage::ReadCMCovFile(const char* file)
+{
+  std::ifstream in(file);
+  if(!in)
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Can not open : "
+               << file << "\n");
+    return false;
+    }
+  std::string line;
+  std::vector<std::string> separateLine;
+  if(!cmSystemTools::GetLineFromStream(in, line))
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Empty file : "
+               << file << "  referenced in this line of cmcov data:\n"
+               "[" << line << "]\n");
+    return false;
+    }
+  separateLine.clear();
+  this->SplitString(separateLine, line);
+  if(separateLine.size() !=4 || separateLine[0] != "Routine"
+     || separateLine[1] != "Line" || separateLine[2] != "RtnLine"
+     || separateLine[3] != "Code")
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Bad first line of cmcov file : "
+               << file << "  line:\n"
+               "[" << line << "]\n");
+    }
+  std::string routine;
+  std::string filepath;
+  while(cmSystemTools::GetLineFromStream(in, line))
+    {
+    // clear out line argument vector
+    separateLine.clear();
+    // parse the comma separated line
+    this->SplitString(separateLine, line);
+    // might have more because code could have a quoted , in it
+    // but we only care about the first 3 args anyway
+    if(separateLine.size() < 4)
+      {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Bad line of cmcov file expected at least 4 found: "
+                 << separateLine.size() << " "
+                 << file << "  line:\n"
+                 "[" << line << "]\n");
+      for(std::string::size_type i = 0; i < separateLine.size(); ++i)
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,""
+                   << separateLine[1] << " ");
+        }
+      cmCTestLog(this->CTest, ERROR_MESSAGE, "\n");
+      return false;
+      }
+    // if we do not have a routine yet, then it should be
+    // the first argument in the vector
+    if(routine.size() == 0)
+      {
+      routine = separateLine[0];
+      // Find the full path to the file
+      if(!this->FindMumpsFile(routine, filepath))
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Could not find mumps file for routine: "
+                   << routine << "\n");
+        filepath = "";
+        continue; // move to next line
+        }
+      }
+    // if we have a routine name, check for end of routine
+    else
+      {
+      // Totals in arg 0 marks the end of a routine
+      if(separateLine[0].substr(0, 6) == "Totals")
+        {
+        routine = ""; // at the end of this routine
+        filepath = "";
+        continue; // move to next line
+        }
+      }
+    // if the file path was not found for the routine
+    // move to next line. We should have already warned
+    // after the call to FindMumpsFile that we did not find
+    // it, so don't report again to cut down on output
+    if(filepath.size() == 0)
+      {
+      continue;
+      }
+    // now we are ready to set the coverage from the line of data
+    cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+      coverageVector = this->Coverage.TotalCoverage[filepath];
+    std::string::size_type linenumber = atoi(separateLine[1].c_str()) -1;
+    int count = atoi(separateLine[2].c_str());
+    if(linenumber > coverageVector.size())
+      {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+                 "Parse error line is greater than number of lines in file: "
+                 << linenumber << " " << filepath << "\n");
+      continue; // skip setting count to avoid crash
+      }
+    // now add to count for linenumber
+    // for some reason the cache coverage adds extra lines to the
+    // end of the file in some cases. Since they do not exist, we will
+    // mark them as non executable
+    while(linenumber >= coverageVector.size())
+      {
+      coverageVector.push_back(-1);
+      }
+    coverageVector[linenumber] += count;
+    }
+  return true;
+}
diff --git a/Source/CTest/cmParseCacheCoverage.h b/Source/CTest/cmParseCacheCoverage.h
new file mode 100644
index 0000000..114eb92
--- /dev/null
+++ b/Source/CTest/cmParseCacheCoverage.h
@@ -0,0 +1,42 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 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.
+============================================================================*/
+
+#ifndef cmParseCacheCoverage_h
+#define cmParseCacheCoverage_h
+
+#include "cmParseMumpsCoverage.h"
+
+/** \class cmParseCacheCoverage
+ * \brief Parse Cache coverage information
+ *
+ * This class is used to parse Cache coverage information for
+ * mumps.
+ */
+class cmParseCacheCoverage : public cmParseMumpsCoverage
+{
+public:
+  cmParseCacheCoverage(cmCTestCoverageHandlerContainer& cont,
+    cmCTest* ctest);
+protected:
+  // implement virtual from parent
+  bool LoadCoverageData(const char* dir);
+  // remove files with no coverage
+  void RemoveUnCoveredFiles();
+  // Read a single mcov file
+  bool ReadCMCovFile(const char* f);
+  // split a string based on ,
+  bool SplitString(std::vector<std::string>& args,
+                   std::string const& line);
+};
+
+
+#endif
diff --git a/Source/CTest/cmParseGTMCoverage.cxx b/Source/CTest/cmParseGTMCoverage.cxx
new file mode 100644
index 0000000..5dfcfe5
--- /dev/null
+++ b/Source/CTest/cmParseGTMCoverage.cxx
@@ -0,0 +1,272 @@
+#include "cmStandardIncludes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmSystemTools.h"
+#include "cmParseGTMCoverage.h"
+#include <cmsys/Directory.hxx>
+#include <cmsys/Glob.hxx>
+
+
+cmParseGTMCoverage::cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
+                                       cmCTest* ctest)
+  :cmParseMumpsCoverage(cont, ctest)
+{
+}
+
+
+bool cmParseGTMCoverage::LoadCoverageData(const char* d)
+{
+  // load all the .mcov files in the specified directory
+  cmsys::Directory dir;
+  if(!dir.Load(d))
+    {
+    return false;
+    }
+  size_t numf;
+  unsigned int i;
+  numf = dir.GetNumberOfFiles();
+  for (i = 0; i < numf; i++)
+    {
+    std::string file = dir.GetFile(i);
+    if(file != "." && file != ".."
+       && !cmSystemTools::FileIsDirectory(file.c_str()))
+      {
+      std::string path = d;
+      path += "/";
+      path += file;
+      if(cmSystemTools::GetFilenameLastExtension(path) == ".mcov")
+        {
+        if(!this->ReadMCovFile(path.c_str()))
+          {
+          return false;
+          }
+        }
+      }
+    }
+  return true;
+}
+
+bool cmParseGTMCoverage::ReadMCovFile(const char* file)
+{
+  std::ifstream in(file);
+  if(!in)
+    {
+    return false;
+    }
+  std::string line;
+  std::string lastfunction;
+  std::string lastroutine;
+  std::string lastpath;
+  int lastoffset = 0;
+  while(  cmSystemTools::GetLineFromStream(in, line))
+    {
+    // only look at lines that have coverage data
+    if(line.find("^ZZCOVERAGE") == line.npos)
+      {
+      continue;
+      }
+    std::string filepath;
+    std::string function;
+    std::string routine;
+    int linenumber = 0;
+    int count = 0;
+    this->ParseMCOVLine(line, routine, function, linenumber, count);
+    // skip this one
+    if(routine == "RSEL")
+      {
+      continue;
+      }
+    // no need to search the file if we just did it
+    if(function == lastfunction && lastroutine == routine)
+      {
+      if(lastpath.size())
+        {
+        this->Coverage.TotalCoverage[lastpath][lastoffset + linenumber]
+          += count;
+        }
+      else
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Can not find mumps file : "
+                   << lastroutine <<
+                   "  referenced in this line of mcov data:\n"
+                   "[" << line << "]\n");
+        }
+      continue;
+      }
+    // Find the full path to the file
+    bool found = this->FindMumpsFile(routine, filepath);
+    if(found)
+      {
+      int lineoffset;
+      if(this->FindFunctionInMumpsFile(filepath,
+                                       function,
+                                       lineoffset))
+        {
+        cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+          coverageVector = this->Coverage.TotalCoverage[filepath];
+        coverageVector[lineoffset + linenumber] += count;
+        }
+      lastoffset = lineoffset;
+      }
+    else
+      {
+      cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Can not find mumps file : "
+               << routine << "  referenced in this line of mcov data:\n"
+                 "[" << line << "]\n");
+      }
+    lastfunction = function;
+    lastroutine = routine;
+    lastpath = filepath;
+    }
+  return true;
+}
+
+bool cmParseGTMCoverage::FindFunctionInMumpsFile(std::string const& filepath,
+                                                 std::string const& function,
+                                                 int& lineoffset)
+{
+  std::ifstream in(filepath.c_str());
+  if(!in)
+    {
+    return false;
+    }
+  std::string line;
+  int linenum = 0;
+  while(  cmSystemTools::GetLineFromStream(in, line))
+    {
+    std::string::size_type pos = line.find(function.c_str());
+    if(pos == 0)
+      {
+      char nextchar = line[function.size()];
+      if(nextchar == ' ' || nextchar == '(')
+        {
+        lineoffset = linenum;
+        return true;
+        }
+      }
+    if(pos == 1)
+      {
+      char prevchar = line[0];
+      char nextchar = line[function.size()+1];
+      if(prevchar == '%' && (nextchar == ' ' || nextchar == '('))
+        {
+        lineoffset = linenum;
+        return true;
+        }
+      }
+    linenum++; // move to next line count
+    }
+  lineoffset = 0;
+  cmCTestLog(this->CTest, ERROR_MESSAGE,
+             "Could not find entry point : "
+             << function << " in " << filepath << "\n");
+  return false;
+}
+
+bool cmParseGTMCoverage::ParseMCOVLine(std::string const& line,
+                                       std::string& routine,
+                                       std::string& function,
+                                       int& linenumber,
+                                       int& count)
+{
+  // this method parses lines from the .mcov file
+  // each line has ^COVERAGE(...) in it, and there
+  // are several varients of coverage lines:
+  //
+  // ^COVERAGE("DIC11","PR1",0)="2:0:0:0"
+  //          ( file  , entry, line ) = "number_executed:timing_info"
+  // ^COVERAGE("%RSEL","SRC")="1:0:0:0"
+  //          ( file  , entry ) = "number_executed:timing_info"
+  // ^COVERAGE("%RSEL","init",8,"FOR_LOOP",1)=1
+  //          ( file  , entry, line, IGNORE ) =number_executed
+  std::vector<cmStdString> args;
+  std::string::size_type pos = line.find('(', 0);
+  // if no ( is found, then return line has no coverage
+  if(pos == std::string::npos)
+    {
+    return false;
+    }
+  std::string arg;
+  bool done = false;
+  // separate out all of the comma separated arguments found
+  // in the COVERAGE(...) line
+  while(line[pos] && !done)
+    {
+    // save the char we are looking at
+    char cur = line[pos];
+    // , or ) means end of argument
+    if(cur == ',' || cur == ')')
+      {
+      // save the argument into the argument vector
+      args.push_back(arg);
+      // start on a new argument
+      arg = "";
+      // if we are at the end of the ), then finish while loop
+      if(cur == ')')
+        {
+        done = true;
+        }
+      }
+    else
+      {
+      // all chars except ", (, and % get stored in the arg string
+      if(cur != '\"' && cur != '(' && cur != '%')
+        {
+        arg.append(1, line[pos]);
+        }
+      }
+    // move to next char
+    pos++;
+    }
+  // now parse the right hand side of the =
+  pos = line.find('=');
+  // no = found, this is an error
+  if(pos == line.npos)
+    {
+    return false;
+    }
+  pos++; // move past =
+
+  // if the next positing is not a ", then this is a
+  // COVERAGE(..)=count line and turn the rest of the string
+  // past the = into an integer and set it to count
+  if(line[pos] != '\"')
+    {
+    count = atoi(line.substr(pos).c_str());
+    }
+  else
+    {
+    // this means line[pos] is a ", and we have a
+    // COVERAGE(...)="1:0:0:0" type of line
+    pos++; // move past "
+    // find the first : past the "
+    std::string::size_type pos2 = line.find(':', pos);
+    // turn the string between the " and the first : into an integer
+    // and set it to count
+    count = atoi(line.substr(pos, pos2-pos).c_str());
+    }
+  // less then two arguments is an error
+  if(args.size() < 2)
+    {
+    cmCTestLog(this->CTest, ERROR_MESSAGE,
+               "Error parsing mcov line: [" << line << "]\n");
+    return false;
+    }
+  routine = args[0]; // the routine is the first argument
+  function = args[1]; // the function in the routine is the second
+  // in the two argument only format
+  // ^COVERAGE("%RSEL","SRC"), the line offset is 0
+  if(args.size() == 2)
+    {
+    linenumber = 0;
+    }
+  else
+    {
+    // this is the format for this line
+    // ^COVERAGE("%RSEL","SRC",count)
+    linenumber = atoi(args[2].c_str());
+    }
+  return true;
+}
diff --git a/Source/CTest/cmParseGTMCoverage.h b/Source/CTest/cmParseGTMCoverage.h
new file mode 100644
index 0000000..c6d7ef9
--- /dev/null
+++ b/Source/CTest/cmParseGTMCoverage.h
@@ -0,0 +1,49 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 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.
+============================================================================*/
+
+#ifndef cmParseGTMCoverage_h
+#define cmParseGTMCoverage_h
+
+#include "cmParseMumpsCoverage.h"
+
+/** \class cmParseGTMCoverage
+ * \brief Parse GTM coverage information
+ *
+ * This class is used to parse GTM coverage information for
+ * mumps.
+ */
+class cmParseGTMCoverage : public cmParseMumpsCoverage
+{
+public:
+  cmParseGTMCoverage(cmCTestCoverageHandlerContainer& cont,
+    cmCTest* ctest);
+protected:
+  // implement virtual from parent
+  bool LoadCoverageData(const char* dir);
+  // Read a single mcov file
+  bool ReadMCovFile(const char* f);
+  // find out what line in a mumps file (filepath) the given entry point
+  // or function is.  lineoffset is set by this method.
+  bool FindFunctionInMumpsFile(std::string const& filepath,
+                               std::string const& function,
+                               int& lineoffset);
+  // parse a line from a .mcov file, and fill in the
+  // routine, function, linenumber and coverage count
+  bool ParseMCOVLine(std::string const& line,
+                 std::string& routine,
+                 std::string& function,
+                 int& linenumber,
+                 int& count);
+};
+
+
+#endif
diff --git a/Source/CTest/cmParseMumpsCoverage.cxx b/Source/CTest/cmParseMumpsCoverage.cxx
new file mode 100644
index 0000000..37e8bd0
--- /dev/null
+++ b/Source/CTest/cmParseMumpsCoverage.cxx
@@ -0,0 +1,165 @@
+#include "cmStandardIncludes.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include "cmSystemTools.h"
+#include "cmParseGTMCoverage.h"
+#include <cmsys/Directory.hxx>
+#include <cmsys/Glob.hxx>
+
+
+cmParseMumpsCoverage::cmParseMumpsCoverage(
+  cmCTestCoverageHandlerContainer& cont,
+  cmCTest* ctest)
+  :Coverage(cont), CTest(ctest)
+{
+}
+
+cmParseMumpsCoverage::~cmParseMumpsCoverage()
+{
+}
+
+bool cmParseMumpsCoverage::ReadCoverageFile(const char* file)
+{
+  // Read the gtm_coverage.mcov file, that has two lines of data:
+  // packages:/full/path/to/Vista/Packages
+  // coverage_dir:/full/path/to/dir/with/*.mcov
+  std::ifstream in(file);
+  if(!in)
+    {
+    return false;
+    }
+  std::string line;
+  while(cmSystemTools::GetLineFromStream(in, line))
+    {
+    std::string::size_type pos = line.find(':', 0);
+    std::string packages;
+    if(pos != std::string::npos)
+      {
+      std::string type = line.substr(0, pos);
+      std::string path = line.substr(pos+1);
+      if(type == "packages")
+        {
+        this->LoadPackages(path.c_str());
+        }
+      else if(type == "coverage_dir")
+        {
+        this->LoadCoverageData(path.c_str());
+        }
+      else
+        {
+        cmCTestLog(this->CTest, ERROR_MESSAGE,
+                   "Parse Error in Mumps coverage file :\n"
+                   << file <<
+                   "\ntype: [" << type << "]\npath:[" << path << "]\n"
+                   "input line: [" << line << "]\n");
+        }
+      }
+    }
+  return true;
+}
+
+void cmParseMumpsCoverage::InitializeMumpsFile(std::string& file)
+{
+  // initialize the coverage information for a given mumps file
+  std::ifstream in(file.c_str());
+  if(!in)
+    {
+    return;
+    }
+  std::string line;
+  cmCTestCoverageHandlerContainer::SingleFileCoverageVector&
+    coverageVector = this->Coverage.TotalCoverage[file];
+  if(!cmSystemTools::GetLineFromStream(in, line))
+    {
+    return;
+    }
+  // first line of a .m file can never be run
+  coverageVector.push_back(-1);
+  while( cmSystemTools::GetLineFromStream(in, line) )
+    {
+    // putting in a 0 for a line means it is executable code
+    // putting in a -1 for a line means it is not executable code
+    int val = -1; // assume line is not executable
+    bool found = false;
+    std::string::size_type i = 0;
+    // (1) Search for the first whitespace or semicolon character on a line.
+    //This will skip over labels if the line starts with one, or will simply
+    //be the first character on the line for non-label lines.
+    for(; i < line.size(); ++i)
+      {
+      if(line[i] == ' ' || line[i] == '\t' || line[i] == ';')
+        {
+        found = true;
+        break;
+        }
+      }
+    if(found)
+      {
+      // (2) If the first character found above is whitespace then continue the
+      // search for the first following non-whitespace character.
+      if(line[i] == ' ' || line[i] == '\t')
+        {
+        while(i < line.size() && (line[i] == ' ' || line[i] == '\t'))
+          {
+          i++;
+          }
+        }
+      // (3) If the character found is not a semicolon then the line counts for
+      // coverage.
+      if(i < line.size() && line[i] != ';')
+        {
+        val = 0;
+        }
+      }
+    coverageVector.push_back(val);
+    }
+}
+
+bool cmParseMumpsCoverage::LoadPackages(const char* d)
+{
+  cmsys::Glob glob;
+  glob.RecurseOn();
+  std::string pat = d;
+  pat += "/*.m";
+  glob.FindFiles(pat.c_str());
+  std::vector<std::string>& files = glob.GetFiles();
+  std::vector<std::string>::iterator fileIt;
+  for ( fileIt = files.begin(); fileIt != files.end();
+        ++ fileIt )
+    {
+    std::string name = cmSystemTools::GetFilenameName(*fileIt);
+    this->RoutineToDirectory[name.substr(0, name.size()-2)] = *fileIt;
+    // initialze each file, this is left out until CDash is fixed
+    // to handle large numbers of files
+    this->InitializeMumpsFile(*fileIt);
+    }
+  return true;
+}
+
+bool cmParseMumpsCoverage::FindMumpsFile(std::string const& routine,
+                                         std::string& filepath)
+{
+  std::map<cmStdString, cmStdString>::iterator i =
+    this->RoutineToDirectory.find(routine);
+  if(i != this->RoutineToDirectory.end())
+    {
+    filepath = i->second;
+    return true;
+    }
+  else
+    {
+    // try some alternate names
+    const char* tryname[] = {"GUX", "GTM", "ONT", 0};
+    for(int k=0; tryname[k] != 0; k++)
+      {
+      std::string routine2 = routine + tryname[k];
+      i = this->RoutineToDirectory.find(routine2);
+      if(i != this->RoutineToDirectory.end())
+        {
+        filepath = i->second;
+        return true;
+        }
+      }
+    }
+  return false;
+}
diff --git a/Source/CTest/cmParseMumpsCoverage.h b/Source/CTest/cmParseMumpsCoverage.h
new file mode 100644
index 0000000..c1effa7
--- /dev/null
+++ b/Source/CTest/cmParseMumpsCoverage.h
@@ -0,0 +1,52 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2009 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.
+============================================================================*/
+
+#ifndef cmParseMumpsCoverage_h
+#define cmParseMumpsCoverage_h
+
+#include "cmStandardIncludes.h"
+#include "cmCTestCoverageHandler.h"
+
+/** \class cmParseMumpsCoverage
+ * \brief Parse Mumps coverage information
+ *
+ * This class is used as the base class for Mumps coverage
+ * parsing.
+ */
+class cmParseMumpsCoverage
+{
+public:
+  cmParseMumpsCoverage(cmCTestCoverageHandlerContainer& cont,
+    cmCTest* ctest);
+  virtual ~cmParseMumpsCoverage();
+  // This is the toplevel coverage file locating the coverage files
+  // and the mumps source code package tree.
+  bool ReadCoverageFile(const char* file);
+protected:
+  // sub classes will use this to
+  // load all coverage files found in the given directory
+  virtual bool LoadCoverageData(const char* d) = 0;
+  // search the package directory for mumps files and fill
+  // in the RoutineToDirectory map
+  bool LoadPackages(const char* dir);
+  // initialize the coverage information for a single mumps file
+  void InitializeMumpsFile(std::string& file);
+  // Find mumps file for routine
+  bool FindMumpsFile(std::string const& routine,
+                     std::string& filepath);
+protected:
+  std::map<cmStdString, cmStdString> RoutineToDirectory;
+  cmCTestCoverageHandlerContainer& Coverage;
+  cmCTest* CTest;
+};
+
+#endif
diff --git a/Source/CTest/cmParsePHPCoverage.h b/Source/CTest/cmParsePHPCoverage.h
index ce5741d..d50a83c 100644
--- a/Source/CTest/cmParsePHPCoverage.h
+++ b/Source/CTest/cmParsePHPCoverage.h
@@ -37,9 +37,6 @@ private:
   bool ReadInt(std::ifstream& in, int& v);
   bool ReadCoverageArray(std::ifstream& in, cmStdString const&);
   bool ReadUntil(std::ifstream& in, char until);
-  typedef std::map<int, int> FileLineCoverage;
-  std::map<cmStdString, FileLineCoverage> FileToCoverage;
-  std::map<int, int> FileCoverage;
   cmCTestCoverageHandlerContainer& Coverage;
   cmCTest* CTest;
 };
diff --git a/Source/cmDependsFortranLexer.cxx b/Source/cmDependsFortranLexer.cxx
index 438af2d..b0d9a74 100644
--- a/Source/cmDependsFortranLexer.cxx
+++ b/Source/cmDependsFortranLexer.cxx
@@ -20,7 +20,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 34
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -65,7 +65,6 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t;
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
-#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -96,6 +95,8 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! C99 */
+
 #endif /* ! FLEXINT_H */
 
 #ifdef __cplusplus
@@ -169,7 +170,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 /* The state buf must be large enough to hold one state per character in the main buffer.
@@ -203,13 +212,6 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 
 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
 
-/* The following is because we cannot portably get our hands on size_t
- * (without autoconf's help, which isn't available because we want
- * flex-generated scanners to compile on their own).
- * Given that the standard has decreed that size_t exists since 1989,
- * I guess we can afford to depend on it. Manoj.
- */
-
 #ifndef YY_TYPEDEF_YY_SIZE_T
 #define YY_TYPEDEF_YY_SIZE_T
 typedef size_t yy_size_t;
@@ -367,8 +369,8 @@ static void yy_fatal_error (yyconst char msg[] ,yyscan_t yyscanner );
         *yy_cp = '\0'; \
         yyg->yy_c_buf_p = yy_cp;
 
-#define YY_NUM_RULES 43
-#define YY_END_OF_BUFFER 44
+#define YY_NUM_RULES 44
+#define YY_END_OF_BUFFER 45
 /* This struct is not used in this scanner,
    but its presence is necessary. */
 struct yy_trans_info
@@ -376,25 +378,26 @@ struct yy_trans_info
         flex_int32_t yy_verify;
         flex_int32_t yy_nxt;
         };
-static yyconst flex_int16_t yy_accept[161] =
+static yyconst flex_int16_t yy_accept[165] =
     {   0,
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-       44,   38,   40,   39,   42,    1,   38,   31,    2,   33,
-       38,   39,   36,   38,   37,   38,   37,   40,   38,   39,
-       38,   37,    9,    8,    9,    4,    3,   38,    0,   10,
-        0,    0,    0,    0,    0,   31,   31,   32,   34,   36,
-       38,   37,    0,   41,   37,    0,    0,    0,    0,    0,
-        0,    0,    0,   38,    0,   11,   37,    0,    0,    5,
-        0,    0,    0,   27,    0,    0,   31,   31,   31,   31,
-        0,    0,    0,    0,    0,   21,    0,    0,    0,    0,
+       45,   39,   41,   40,   43,    1,   39,   32,    2,   34,
+       39,   40,   37,   39,   38,   39,   38,   41,   39,   40,
+       39,   38,    9,    8,    9,    4,    3,   39,    0,   10,
+        0,    0,    0,    0,    0,   32,   32,   33,   35,   37,
+       39,   38,    0,   42,   38,    0,    0,    0,    0,    0,
+        0,    0,    0,   39,    0,   11,   38,    0,    0,    5,
+        0,    0,    0,   28,    0,    0,   32,   32,   32,   32,
+        0,    0,    0,    0,    0,   22,    0,    0,    0,    0,
         0,    6,    0,    0,    0,    0,    0,    0,    0,    0,
 
         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
-        0,    0,   28,   29,    0,    0,    0,    0,    0,    0,
-        0,   22,   23,    0,    0,    0,    0,    0,    0,    0,
-        0,   30,   25,    0,    0,   18,    0,    0,   24,   19,
-        0,    0,   17,    0,    0,   16,   26,    0,    0,   15,
-       20,    0,    7,   35,    7,   13,    0,   12,   14,    0
+        0,    0,   29,   30,    0,    0,    0,    0,    0,    0,
+        0,   23,   24,    0,    0,    0,    0,    0,    0,    0,
+        0,   31,   26,    0,    0,   19,    0,    0,   25,   20,
+        0,    0,   18,    0,    0,   17,   27,    0,    0,   16,
+       21,    0,    7,   36,    7,   14,    0,   13,   15,    0,
+        0,    0,   12,    0
     } ;
 
 static yyconst flex_int32_t yy_ec[256] =
@@ -404,15 +407,15 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    5,    6,    7,    8,    9,    1,   10,   11,    1,
         1,   12,    1,   13,    1,    1,    1,   14,   14,   14,
-       14,   14,   14,   14,   14,   14,   14,   15,   16,    1,
-       17,   18,   19,    1,   20,   20,   21,   22,   23,   24,
-       20,   20,   25,   20,   20,   26,   20,   27,   20,   20,
-       20,   20,   28,   20,   29,   20,   20,   20,   20,   20,
-        1,   30,    1,    1,   31,    1,   20,   20,   32,   33,
-
-       34,   35,   20,   20,   36,   20,   20,   37,   20,   38,
-       20,   20,   20,   20,   39,   20,   40,   20,   20,   20,
-       20,   20,    1,    1,    1,    1,    1,    1,    1,    1,
+       14,   14,   14,   14,   14,   14,   14,   15,   16,   17,
+       18,   19,   20,    1,   21,   21,   22,   23,   24,   25,
+       21,   21,   26,   21,   21,   27,   21,   28,   21,   21,
+       21,   21,   29,   21,   30,   21,   21,   21,   21,   21,
+        1,   31,    1,    1,   32,    1,   21,   21,   33,   34,
+
+       35,   36,   21,   21,   37,   21,   21,   38,   21,   39,
+       21,   21,   21,   21,   40,   21,   41,   21,   21,   21,
+       21,   21,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
@@ -429,178 +432,187 @@ static yyconst flex_int32_t yy_ec[256] =
         1,    1,    1,    1,    1
     } ;
 
-static yyconst flex_int32_t yy_meta[41] =
+static yyconst flex_int32_t yy_meta[42] =
     {   0,
         1,    2,    2,    3,    4,    3,    3,    1,    1,    3,
-        3,    1,    3,    5,    1,    3,    3,    1,    1,    6,
-        6,    6,    6,    6,    6,    6,    6,    6,    6,    1,
-        5,    6,    6,    6,    6,    6,    6,    6,    6,    6
+        3,    1,    3,    5,    1,    3,    1,    3,    6,    1,
+        7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
+        1,    5,    7,    7,    7,    7,    7,    7,    7,    7,
+        7
     } ;
 
-static yyconst flex_int16_t yy_base[169] =
+static yyconst flex_int16_t yy_base[174] =
     {   0,
-        0,   39,    0,   40,  184,   47,   43,   53,   55,   63,
-      186,    0,  476,  476,  164,  476,   79,   72,  476,  476,
-      143,  476,  130,  126,    0,   83,  119,   85,  149,  139,
-      189,  220,  476,  131,   89,  476,  476,    0,  132,  476,
-      259,   37,   69,   76,   34,  119,  137,  476,    0,  476,
-      121,    0,  150,  476,    0,  154,  298,    0,   75,  138,
-      142,   72,  127,  338,   94,  476,    0,   84,  158,  186,
-       81,  145,  108,  172,  147,  173,  260,  266,  284,  299,
-      272,  173,  178,  286,  245,  258,  285,  285,   78,   71,
-      207,  476,  288,  291,  296,  304,  310,  315,  317,  326,
-
-      330,  330,  335,  338,  338,  341,  343,  341,  348,   62,
-       52,  346,  476,  476,  353,  355,  357,  352,  359,  359,
-      359,  476,  476,  363,  365,  370,  366,  375,   46,   38,
-      378,  476,  476,  378,  381,  476,  376,  384,  476,  476,
-      384,  387,  476,  115,    0,  476,  476,  388,  393,  476,
-      476,  394,  476,  476,  476,  476,  398,  476,  476,  476,
-      432,  438,  443,  445,  451,  457,  463,  469
+        0,   40,    0,   41,  188,   48,   44,   54,   56,   65,
+      186,    0,  505,  505,  171,  505,   81,   74,  505,  505,
+      158,  505,  151,  137,    0,   85,  122,   87,  153,  145,
+      194,  226,  505,  143,   91,  505,  505,    0,  142,  505,
+      266,   34,   70,   74,   34,  122,  141,  505,    0,  505,
+      112,    0,   98,  505,    0,  154,  306,    0,   43,  133,
+      139,   46,  130,  347,  130,  505,    0,  121,  163,  179,
+      104,  156,  129,  176,  147,  178,  214,  267,  273,  292,
+      279,  179,  249,  280,  257,  265,  288,  289,  116,  107,
+      317,  505,  287,  289,  291,  302,  307,  310,  307,  311,
+
+      316,  326,  329,  333,  332,  336,  347,  345,  349,  101,
+       86,  346,  505,  505,  350,  351,  353,  350,  357,  362,
+      362,  505,  505,  367,  369,  371,  366,  372,   56,   47,
+      374,  505,  505,  374,  379,  505,  374,  387,  505,  505,
+      387,  391,  505,  117,    0,  505,  505,  392,  394,  505,
+      505,  394,  505,  505,  505,  505,  395,  419,  505,  429,
+        0,   25,  505,  505,  446,  453,  459,  462,  469,  476,
+      483,  490,  497
     } ;
 
-static yyconst flex_int16_t yy_def[169] =
+static yyconst flex_int16_t yy_def[174] =
     {   0,
-      160,    1,    1,    1,    1,    1,  161,  161,  161,  161,
-      160,  162,  160,  160,  163,  160,  162,  160,  160,  160,
-      162,  160,  160,  162,  164,  162,  164,  160,  162,  160,
-      165,  160,  160,  160,  160,  160,  160,  162,  163,  160,
-      160,  160,  160,  160,  160,  160,  166,  160,  162,  160,
-      162,  164,  160,  160,   27,  160,  160,   57,  160,  160,
-      160,  160,  160,  165,  165,  160,   32,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  166,  166,  166,  166,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  167,  168,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,    0,
-      160,  160,  160,  160,  160,  160,  160,  160
+      164,    1,    1,    1,    1,    1,  165,  165,  165,  165,
+      164,  166,  164,  164,  167,  164,  166,  164,  164,  164,
+      166,  164,  164,  166,  168,  166,  168,  164,  166,  164,
+      169,  164,  164,  164,  164,  164,  164,  166,  167,  164,
+      164,  164,  164,  164,  164,  164,  170,  164,  166,  164,
+      166,  168,  164,  164,   27,  164,  164,   57,  164,  164,
+      164,  164,  164,  169,  169,  164,   32,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  170,  170,  170,  170,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  171,  172,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      173,  173,  164,    0,  164,  164,  164,  164,  164,  164,
+      164,  164,  164
     } ;
 
-static yyconst flex_int16_t yy_nxt[517] =
+static yyconst flex_int16_t yy_nxt[547] =
     {   0,
        12,   13,   14,   13,   13,   15,   16,   12,   17,   18,
-       19,   12,   20,   12,   21,   22,   23,   12,   24,   25,
-       25,   25,   25,   25,   25,   25,   25,   25,   25,   26,
-       27,   25,   25,   25,   25,   25,   25,   25,   25,   25,
-       28,   28,  145,   28,   28,   34,   29,   29,   28,   30,
-      144,   28,   35,   36,   29,   34,  130,   34,   31,   71,
-       76,   37,   35,   36,   35,   34,  129,   32,   32,   37,
-       71,   76,   35,   46,   46,  111,   46,   47,   32,   32,
-       41,   48,  110,   41,   53,   54,   56,   53,   90,   56,
-       69,   70,   57,   69,   72,   73,   66,   83,   88,   74,
-
-       42,   43,   75,   44,   93,   72,   73,   45,   83,   88,
-       74,   42,   43,   75,   44,   93,  154,  154,   45,   38,
-       46,   46,   81,   46,   47,   81,   38,   38,   48,   96,
-       38,   89,   55,   38,   40,   68,   38,   38,   78,   46,
-       96,   78,   79,   63,   51,   82,   80,   50,   38,   55,
-       58,   53,   54,   58,   53,   56,   82,   49,   56,   69,
-       70,   57,   69,   84,   85,   86,   40,   99,   87,   94,
-       59,   60,   95,   61,   84,   85,   86,   62,   99,   87,
-       94,   59,   60,   95,   61,  160,   30,   91,   62,   64,
-       91,   66,  160,   97,  100,   92,   64,   64,   98,  101,
-
-       64,  102,   64,   64,   97,  100,   64,   64,   91,   98,
-      101,   91,  102,  160,  160,  160,   92,  160,   64,   64,
-       65,   65,   66,   65,   65,   65,   65,   65,   65,   65,
-       65,   65,   65,   67,   65,   65,   65,   65,   65,   67,
-       67,   67,   67,   67,   67,   67,   67,   67,   67,   65,
-       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
-       41,   78,   46,   41,   78,   79,  105,   78,   46,   80,
-       78,   79,  160,   81,  160,   80,   81,  105,  160,  106,
-       42,   43,  160,   44,  107,   78,   46,   45,   78,   79,
-      106,   42,   43,   80,   44,  107,   82,  160,   45,   58,
-
-       78,   46,   58,   78,   79,  108,  109,   82,   80,  160,
-      103,  160,  112,  104,  113,  160,  108,  109,  114,   59,
-       60,  103,   61,  112,  104,  113,   62,  160,  115,  114,
-       59,   60,  116,   61,  160,  160,  117,   62,   64,  115,
-       66,  160,  118,  116,  160,   64,   64,  117,  119,   64,
-      120,   64,   64,  118,  121,   64,   64,  160,  122,  119,
-      123,  120,  124,  125,  126,  121,  127,   64,   64,  122,
-      128,  123,  131,  124,  125,  126,  132,  127,  133,  134,
-      135,  128,  136,  131,  137,  138,  139,  132,  140,  133,
-      134,  135,  141,  136,  142,  137,  138,  139,  143,  140,
-
-      146,  147,  148,  141,  149,  142,  150,  151,  152,  143,
-      156,  146,  147,  148,  157,  149,  158,  150,  151,  152,
-      159,  156,  160,  160,  160,  157,  160,  158,  160,  160,
-      160,  159,   33,   33,   33,   33,   33,   33,   38,  160,
-      160,  160,   38,   39,   39,   39,   39,   39,   39,   52,
-       52,   65,   65,   65,   65,   65,   65,   77,   77,   77,
-       77,   77,   77,  153,  153,  153,  160,  153,  153,  155,
-      160,  155,  160,  155,  155,   11,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160
+       19,   12,   20,   12,   21,   22,   12,   23,   12,   24,
+       25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
+       26,   27,   25,   25,   25,   25,   25,   25,   25,   25,
+       25,   28,   28,  163,   28,   28,   34,   29,   29,   28,
+       30,  145,   28,   35,   36,   29,   34,   71,   34,   31,
+      144,   76,   37,   35,   36,   35,   83,   34,   71,   32,
+       32,   37,   76,   88,   35,   46,   46,   83,   46,   47,
+       32,   32,   41,   48,   88,   41,   53,   54,   56,   53,
+      130,   56,   69,   70,   57,   69,   72,   73,   74,   53,
+
+       54,   75,   53,   42,   43,  129,   44,   72,   73,   74,
+       45,  111,   75,   81,   42,   43,   81,   44,  154,  154,
+      110,   45,   38,   46,   46,   90,   46,   47,   93,   38,
+       38,   48,   66,   38,   89,   55,   38,   82,   38,   93,
+       38,   38,   78,   46,   40,   78,   79,   68,   82,   63,
+       80,   96,   38,   55,   58,   56,   51,   58,   56,   84,
+       85,   57,   96,   86,   69,   70,   87,   69,   99,   50,
+       84,   85,   49,   40,   86,   59,   60,   87,   61,   99,
+       91,   94,   62,   91,   95,  164,   59,   60,   92,   61,
+       30,  164,   94,   62,   64,   95,   66,  164,   97,  164,
+
+      100,   64,   64,   98,  164,   64,  101,   64,   64,   97,
+       64,  100,   64,   64,   98,   78,   46,  101,   78,   79,
+      164,  164,  164,   80,   64,   64,   65,   65,   66,   65,
+       65,   65,   65,   65,   65,   65,   65,   65,   65,   67,
+       65,   65,   65,   65,   65,   65,   67,   67,   67,   67,
+       67,   67,   67,   67,   67,   67,   65,   67,   67,   67,
+       67,   67,   67,   67,   67,   67,   67,   41,   78,   46,
+       41,   78,   79,  102,   78,   46,   80,   78,   79,  105,
+       81,  164,   80,   81,  102,  164,  164,  106,   42,   43,
+      105,   44,  107,   78,   46,   45,   78,   79,  106,   42,
+
+       43,   80,   44,  107,   82,  103,   45,   58,  104,  108,
+       58,  109,  112,  113,  114,   82,  103,  164,   91,  104,
+      108,   91,  109,  112,  113,  114,   92,  115,   59,   60,
+      116,   61,  117,  118,  119,   62,  164,  120,  115,   59,
+       60,  116,   61,  117,  118,  119,   62,   64,  120,   66,
+      164,  121,  164,  122,   64,   64,  123,  124,   64,  125,
+       64,   64,  121,   64,  122,   64,   64,  123,  124,  126,
+      125,  127,  128,  131,  132,  133,  134,   64,   64,  135,
+      126,  136,  127,  128,  131,  132,  133,  134,  137,  138,
+      135,  139,  136,  140,  141,  142,  143,  146,  147,  137,
+
+      138,  148,  139,  149,  140,  141,  142,  143,  146,  147,
+      150,  151,  148,  152,  149,  156,  157,  158,  159,  164,
+      160,  150,  151,  160,  152,  164,  156,  157,  158,  159,
+      160,  164,  164,  160,  164,  161,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  161,   33,   33,   33,   33,
+       33,   33,   33,   38,  164,  164,  164,   38,   38,   39,
+       39,   39,   39,   39,   39,   39,   52,  164,   52,   65,
+       65,   65,   65,   65,   65,   65,   77,   77,   77,   77,
+       77,   77,   77,  153,  153,  153,  164,  153,  153,  153,
+      155,  164,  155,  164,  155,  155,  155,  162,  162,  162,
+
+      162,  162,  164,  162,   11,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164
     } ;
 
-static yyconst flex_int16_t yy_chk[517] =
+static yyconst flex_int16_t yy_chk[547] =
     {   0,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
-        2,    4,  130,    2,    4,    7,    2,    4,    6,    6,
-      129,    6,    7,    7,    6,    8,  111,    9,    6,   42,
-       45,    9,    8,    8,    9,   10,  110,    6,    6,   10,
-       42,   45,   10,   18,   18,   90,   18,   18,    6,    6,
-       17,   18,   89,   17,   26,   26,   28,   26,   68,   28,
-       35,   35,   28,   35,   43,   43,   65,   59,   62,   44,
-
-       17,   17,   44,   17,   71,   43,   43,   17,   59,   62,
-       44,   17,   17,   44,   17,   71,  144,  144,   17,   27,
-       46,   46,   51,   46,   46,   51,   27,   27,   46,   73,
-       27,   63,   27,   27,   39,   34,   27,   27,   47,   47,
-       73,   47,   47,   30,   24,   51,   47,   23,   27,   27,
-       29,   53,   53,   29,   53,   56,   51,   21,   56,   69,
-       69,   56,   69,   60,   60,   61,   15,   75,   61,   72,
-       29,   29,   72,   29,   60,   60,   61,   29,   75,   61,
-       72,   29,   29,   72,   29,   11,    5,   70,   29,   31,
-       70,   31,    0,   74,   76,   70,   31,   31,   74,   82,
-
-       31,   83,   31,   31,   74,   76,   31,   31,   91,   74,
-       82,   91,   83,    0,    0,    0,   91,    0,   31,   31,
-       32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
+        1,    2,    4,  162,    2,    4,    7,    2,    4,    6,
+        6,  130,    6,    7,    7,    6,    8,   42,    9,    6,
+      129,   45,    9,    8,    8,    9,   59,   10,   42,    6,
+        6,   10,   45,   62,   10,   18,   18,   59,   18,   18,
+        6,    6,   17,   18,   62,   17,   26,   26,   28,   26,
+      111,   28,   35,   35,   28,   35,   43,   43,   44,   53,
+
+       53,   44,   53,   17,   17,  110,   17,   43,   43,   44,
+       17,   90,   44,   51,   17,   17,   51,   17,  144,  144,
+       89,   17,   27,   46,   46,   68,   46,   46,   71,   27,
+       27,   46,   65,   27,   63,   27,   27,   51,   27,   71,
+       27,   27,   47,   47,   39,   47,   47,   34,   51,   30,
+       47,   73,   27,   27,   29,   56,   24,   29,   56,   60,
+       60,   56,   73,   61,   69,   69,   61,   69,   75,   23,
+       60,   60,   21,   15,   61,   29,   29,   61,   29,   75,
+       70,   72,   29,   70,   72,   11,   29,   29,   70,   29,
+        5,    0,   72,   29,   31,   72,   31,    0,   74,    0,
+
+       76,   31,   31,   74,    0,   31,   82,   31,   31,   74,
+       31,   76,   31,   31,   74,   77,   77,   82,   77,   77,
+        0,    0,    0,   77,   31,   31,   32,   32,   32,   32,
        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
-       41,   77,   77,   41,   77,   77,   85,   78,   78,   77,
-       78,   78,    0,   81,    0,   78,   81,   85,    0,   86,
-       41,   41,    0,   41,   86,   79,   79,   41,   79,   79,
-       86,   41,   41,   79,   41,   86,   81,    0,   41,   57,
-
-       80,   80,   57,   80,   80,   87,   88,   81,   80,    0,
-       84,    0,   93,   84,   94,    0,   87,   88,   95,   57,
-       57,   84,   57,   93,   84,   94,   57,    0,   96,   95,
-       57,   57,   97,   57,    0,    0,   98,   57,   64,   96,
-       64,    0,   99,   97,    0,   64,   64,   98,  100,   64,
-      101,   64,   64,   99,  102,   64,   64,    0,  103,  100,
-      104,  101,  105,  106,  107,  102,  108,   64,   64,  103,
-      109,  104,  112,  105,  106,  107,  115,  108,  116,  117,
-      118,  109,  119,  112,  120,  121,  124,  115,  125,  116,
-      117,  118,  126,  119,  127,  120,  121,  124,  128,  125,
-
-      131,  134,  135,  126,  137,  127,  138,  141,  142,  128,
-      148,  131,  134,  135,  149,  137,  152,  138,  141,  142,
-      157,  148,    0,    0,    0,  149,    0,  152,    0,    0,
-        0,  157,  161,  161,  161,  161,  161,  161,  162,    0,
-        0,    0,  162,  163,  163,  163,  163,  163,  163,  164,
-      164,  165,  165,  165,  165,  165,  165,  166,  166,  166,
-      166,  166,  166,  167,  167,  167,    0,  167,  167,  168,
-        0,  168,    0,  168,  168,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-
-      160,  160,  160,  160,  160,  160,  160,  160,  160,  160,
-      160,  160,  160,  160,  160,  160
+       32,   32,   32,   32,   32,   32,   32,   41,   78,   78,
+       41,   78,   78,   83,   79,   79,   78,   79,   79,   85,
+       81,    0,   79,   81,   83,    0,    0,   86,   41,   41,
+       85,   41,   86,   80,   80,   41,   80,   80,   86,   41,
+
+       41,   80,   41,   86,   81,   84,   41,   57,   84,   87,
+       57,   88,   93,   94,   95,   81,   84,    0,   91,   84,
+       87,   91,   88,   93,   94,   95,   91,   96,   57,   57,
+       97,   57,   98,   99,  100,   57,    0,  101,   96,   57,
+       57,   97,   57,   98,   99,  100,   57,   64,  101,   64,
+        0,  102,    0,  103,   64,   64,  104,  105,   64,  106,
+       64,   64,  102,   64,  103,   64,   64,  104,  105,  107,
+      106,  108,  109,  112,  115,  116,  117,   64,   64,  118,
+      107,  119,  108,  109,  112,  115,  116,  117,  120,  121,
+      118,  124,  119,  125,  126,  127,  128,  131,  134,  120,
+
+      121,  135,  124,  137,  125,  126,  127,  128,  131,  134,
+      138,  141,  135,  142,  137,  148,  149,  152,  157,    0,
+      158,  138,  141,  158,  142,    0,  148,  149,  152,  157,
+      160,    0,    0,  160,    0,  158,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,  160,  165,  165,  165,  165,
+      165,  165,  165,  166,    0,    0,    0,  166,  166,  167,
+      167,  167,  167,  167,  167,  167,  168,    0,  168,  169,
+      169,  169,  169,  169,  169,  169,  170,  170,  170,  170,
+      170,  170,  170,  171,  171,  171,    0,  171,  171,  171,
+      172,    0,  172,    0,  172,  172,  172,  173,  173,  173,
+
+      173,  173,    0,  173,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164,  164,  164,  164,  164,
+      164,  164,  164,  164,  164,  164
     } ;
 
 /* The intent behind this definition is that it'll catch
@@ -673,7 +685,7 @@ Modify cmDependsFortranLexer.h:
 /*--------------------------------------------------------------------------*/
 
 
-#line 670 "cmDependsFortranLexer.cxx"
+#line 678 "cmDependsFortranLexer.cxx"
 
 #define INITIAL 0
 #define free_fmt 1
@@ -796,7 +808,12 @@ static int input (yyscan_t yyscanner );
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Copy whatever the last rule matched to the standard output. */
@@ -804,7 +821,7 @@ static int input (yyscan_t yyscanner );
 /* This used to be an fputs(), but since the string might contain NUL's,
  * we now use fwrite().
  */
-#define ECHO fwrite( yytext, yyleng, 1, yyout )
+#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
 #endif
 
 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
@@ -815,7 +832,7 @@ static int input (yyscan_t yyscanner );
         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
                 { \
                 int c = '*'; \
-                int n; \
+                size_t n; \
                 for ( n = 0; n < max_size && \
                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
                         buf[n] = (char) c; \
@@ -901,10 +918,10 @@ YY_DECL
         register int yy_act;
     struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
 
-#line 75 "cmDependsFortranLexer.in.l"
+#line 71 "cmDependsFortranLexer.in.l"
 
 
-#line 901 "cmDependsFortranLexer.cxx"
+#line 914 "cmDependsFortranLexer.cxx"
 
         if ( !yyg->yy_init )
                 {
@@ -958,13 +975,13 @@ yy_match:
                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                                 {
                                 yy_current_state = (int) yy_def[yy_current_state];
-                                if ( yy_current_state >= 161 )
+                                if ( yy_current_state >= 165 )
                                         yy_c = yy_meta[(unsigned int) yy_c];
                                 }
                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
                         ++yy_cp;
                         }
-                while ( yy_base[yy_current_state] != 476 );
+                while ( yy_base[yy_current_state] != 505 );
 
 yy_find_action:
                 yy_act = yy_accept[yy_current_state];
@@ -990,7 +1007,7 @@ do_action:      /* This label is used only to access EOF actions. */
 
 case 1:
 YY_RULE_SETUP
-#line 77 "cmDependsFortranLexer.in.l"
+#line 73 "cmDependsFortranLexer.in.l"
 {
   cmDependsFortranParser_StringStart(yyextra);
   cmDependsFortranParser_SetOldStartcond(yyextra, YY_START);
@@ -999,7 +1016,7 @@ YY_RULE_SETUP
         YY_BREAK
 case 2:
 YY_RULE_SETUP
-#line 83 "cmDependsFortranLexer.in.l"
+#line 79 "cmDependsFortranLexer.in.l"
 {
   cmDependsFortranParser_StringStart(yyextra);
   cmDependsFortranParser_SetOldStartcond(yyextra, YY_START);
@@ -1007,10 +1024,10 @@ YY_RULE_SETUP
 }
         YY_BREAK
 case 3:
-#line 90 "cmDependsFortranLexer.in.l"
+#line 86 "cmDependsFortranLexer.in.l"
 case 4:
 YY_RULE_SETUP
-#line 90 "cmDependsFortranLexer.in.l"
+#line 86 "cmDependsFortranLexer.in.l"
 {
   BEGIN(cmDependsFortranParser_GetOldStartcond(yyextra) );
   yylvalp->string = strdup(cmDependsFortranParser_StringEnd(yyextra));
@@ -1018,17 +1035,17 @@ YY_RULE_SETUP
 }
 case 5:
 /* rule 5 can match eol */
-#line 97 "cmDependsFortranLexer.in.l"
+#line 93 "cmDependsFortranLexer.in.l"
 case 6:
 /* rule 6 can match eol */
 YY_RULE_SETUP
-#line 97 "cmDependsFortranLexer.in.l"
+#line 93 "cmDependsFortranLexer.in.l"
 /* Ignore (continued strings, free fmt) */
         YY_BREAK
 case 7:
 /* rule 7 can match eol */
 YY_RULE_SETUP
-#line 99 "cmDependsFortranLexer.in.l"
+#line 95 "cmDependsFortranLexer.in.l"
 {
   if (cmDependsFortranParser_GetOldStartcond(yyextra) == fixed_fmt)
     ; /* Ignore (cont. strings, fixed fmt) */
@@ -1041,7 +1058,7 @@ YY_RULE_SETUP
 case 8:
 /* rule 8 can match eol */
 YY_RULE_SETUP
-#line 109 "cmDependsFortranLexer.in.l"
+#line 105 "cmDependsFortranLexer.in.l"
 {
   unput ('\n');
   BEGIN(INITIAL);
@@ -1049,7 +1066,7 @@ YY_RULE_SETUP
 }
 case 9:
 YY_RULE_SETUP
-#line 115 "cmDependsFortranLexer.in.l"
+#line 111 "cmDependsFortranLexer.in.l"
 {
   cmDependsFortranParser_StringAppend(yyextra, yytext[0]);
 }
@@ -1057,96 +1074,99 @@ YY_RULE_SETUP
 case 10:
 /* rule 10 can match eol */
 YY_RULE_SETUP
-#line 119 "cmDependsFortranLexer.in.l"
+#line 115 "cmDependsFortranLexer.in.l"
 { return EOSTMT; } /* Treat comments like */
 case 11:
 /* rule 11 can match eol */
 YY_RULE_SETUP
-#line 120 "cmDependsFortranLexer.in.l"
+#line 116 "cmDependsFortranLexer.in.l"
 { return EOSTMT; } /* empty lines */
 case 12:
+/* rule 12 can match eol */
 YY_RULE_SETUP
-#line 122 "cmDependsFortranLexer.in.l"
-{ return CPP_INCLUDE; }
+#line 118 "cmDependsFortranLexer.in.l"
+{
+  yytext[yyleng-1] = 0;
+  yylvalp->string = strdup(strchr(yytext, '<')+1);
+  return CPP_INCLUDE_ANGLE;
+}
 case 13:
 YY_RULE_SETUP
 #line 123 "cmDependsFortranLexer.in.l"
-{ return F90PPR_INCLUDE; }
+{ return CPP_INCLUDE; }
 case 14:
 YY_RULE_SETUP
 #line 124 "cmDependsFortranLexer.in.l"
-{ return COCO_INCLUDE; }
+{ return F90PPR_INCLUDE; }
 case 15:
 YY_RULE_SETUP
-#line 126 "cmDependsFortranLexer.in.l"
-{ return CPP_DEFINE; }
+#line 125 "cmDependsFortranLexer.in.l"
+{ return COCO_INCLUDE; }
 case 16:
 YY_RULE_SETUP
 #line 127 "cmDependsFortranLexer.in.l"
-{ return F90PPR_DEFINE; }
+{ return CPP_DEFINE; }
 case 17:
 YY_RULE_SETUP
-#line 129 "cmDependsFortranLexer.in.l"
-{ return CPP_UNDEF; }
+#line 128 "cmDependsFortranLexer.in.l"
+{ return F90PPR_DEFINE; }
 case 18:
 YY_RULE_SETUP
 #line 130 "cmDependsFortranLexer.in.l"
-{ return F90PPR_UNDEF; }
+{ return CPP_UNDEF; }
 case 19:
 YY_RULE_SETUP
-#line 132 "cmDependsFortranLexer.in.l"
-{ return CPP_IFDEF; }
+#line 131 "cmDependsFortranLexer.in.l"
+{ return F90PPR_UNDEF; }
 case 20:
 YY_RULE_SETUP
 #line 133 "cmDependsFortranLexer.in.l"
-{ return CPP_IFNDEF; }
+{ return CPP_IFDEF; }
 case 21:
 YY_RULE_SETUP
 #line 134 "cmDependsFortranLexer.in.l"
-{ return CPP_IF; }
+{ return CPP_IFNDEF; }
 case 22:
 YY_RULE_SETUP
 #line 135 "cmDependsFortranLexer.in.l"
-{ return CPP_ELIF; }
+{ return CPP_IF; }
 case 23:
 YY_RULE_SETUP
 #line 136 "cmDependsFortranLexer.in.l"
-{ return CPP_ELSE; }
+{ return CPP_ELIF; }
 case 24:
 YY_RULE_SETUP
 #line 137 "cmDependsFortranLexer.in.l"
-{ return CPP_ENDIF; }
+{ return CPP_ELSE; }
 case 25:
 YY_RULE_SETUP
-#line 139 "cmDependsFortranLexer.in.l"
-{ return F90PPR_IFDEF; }
+#line 138 "cmDependsFortranLexer.in.l"
+{ return CPP_ENDIF; }
 case 26:
 YY_RULE_SETUP
 #line 140 "cmDependsFortranLexer.in.l"
-{ return F90PPR_IFNDEF; }
+{ return F90PPR_IFDEF; }
 case 27:
 YY_RULE_SETUP
 #line 141 "cmDependsFortranLexer.in.l"
-{ return F90PPR_IF; }
+{ return F90PPR_IFNDEF; }
 case 28:
 YY_RULE_SETUP
 #line 142 "cmDependsFortranLexer.in.l"
-{ return F90PPR_ELIF; }
+{ return F90PPR_IF; }
 case 29:
 YY_RULE_SETUP
 #line 143 "cmDependsFortranLexer.in.l"
-{ return F90PPR_ELSE; }
+{ return F90PPR_ELIF; }
 case 30:
 YY_RULE_SETUP
 #line 144 "cmDependsFortranLexer.in.l"
-{ return F90PPR_ENDIF; }
-/* Line continuations, possible involving comments.  */
+{ return F90PPR_ELSE; }
 case 31:
-/* rule 31 can match eol */
 YY_RULE_SETUP
-#line 147 "cmDependsFortranLexer.in.l"
-
-        YY_BREAK
+#line 145 "cmDependsFortranLexer.in.l"
+{ return F90PPR_ENDIF; }
+/* Line continuations, possible involving comments.  */
 case 32:
 /* rule 32 can match eol */
 YY_RULE_SETUP
@@ -1154,59 +1174,65 @@ YY_RULE_SETUP
 
         YY_BREAK
 case 33:
+/* rule 33 can match eol */
 YY_RULE_SETUP
-#line 150 "cmDependsFortranLexer.in.l"
-{ return COMMA; }
+#line 149 "cmDependsFortranLexer.in.l"
+
+        YY_BREAK
 case 34:
 YY_RULE_SETUP
-#line 152 "cmDependsFortranLexer.in.l"
-{ return DCOLON; }
+#line 151 "cmDependsFortranLexer.in.l"
+{ return COMMA; }
 case 35:
-/* rule 35 can match eol */
 YY_RULE_SETUP
-#line 154 "cmDependsFortranLexer.in.l"
-{ return GARBAGE; }
+#line 153 "cmDependsFortranLexer.in.l"
+{ return DCOLON; }
 case 36:
+/* rule 36 can match eol */
 YY_RULE_SETUP
-#line 156 "cmDependsFortranLexer.in.l"
-{ return ASSIGNMENT_OP; }
+#line 155 "cmDependsFortranLexer.in.l"
+{ return GARBAGE; }
 case 37:
 YY_RULE_SETUP
-#line 158 "cmDependsFortranLexer.in.l"
+#line 157 "cmDependsFortranLexer.in.l"
+{ return ASSIGNMENT_OP; }
+case 38:
+YY_RULE_SETUP
+#line 159 "cmDependsFortranLexer.in.l"
 {
   yylvalp->string = strdup(yytext);
   return WORD;
 }
-case 38:
+case 39:
 YY_RULE_SETUP
-#line 163 "cmDependsFortranLexer.in.l"
+#line 164 "cmDependsFortranLexer.in.l"
 { return GARBAGE; }
-case 39:
-/* rule 39 can match eol */
+case 40:
+/* rule 40 can match eol */
 YY_RULE_SETUP
-#line 165 "cmDependsFortranLexer.in.l"
+#line 166 "cmDependsFortranLexer.in.l"
 { return EOSTMT; }
-case 40:
+case 41:
 YY_RULE_SETUP
-#line 168 "cmDependsFortranLexer.in.l"
+#line 169 "cmDependsFortranLexer.in.l"
 /* Ignore */
         YY_BREAK
-case 41:
-/* rule 41 can match eol */
+case 42:
+/* rule 42 can match eol */
 YY_RULE_SETUP
-#line 169 "cmDependsFortranLexer.in.l"
+#line 170 "cmDependsFortranLexer.in.l"
 /* Ignore line-endings preceeded by \ */
         YY_BREAK
-case 42:
+case 43:
 YY_RULE_SETUP
-#line 171 "cmDependsFortranLexer.in.l"
+#line 172 "cmDependsFortranLexer.in.l"
 { return *yytext; }
 case YY_STATE_EOF(INITIAL):
 case YY_STATE_EOF(free_fmt):
 case YY_STATE_EOF(fixed_fmt):
 case YY_STATE_EOF(str_sq):
 case YY_STATE_EOF(str_dq):
-#line 173 "cmDependsFortranLexer.in.l"
+#line 174 "cmDependsFortranLexer.in.l"
 {
   if(!cmDependsFortranParser_FilePop(yyextra) )
     {
@@ -1214,12 +1240,12 @@ case YY_STATE_EOF(str_dq):
     }
 }
         YY_BREAK
-case 43:
+case 44:
 YY_RULE_SETUP
-#line 180 "cmDependsFortranLexer.in.l"
+#line 181 "cmDependsFortranLexer.in.l"
 ECHO;
         YY_BREAK
-#line 1247 "cmDependsFortranLexer.cxx"
+#line 1270 "cmDependsFortranLexer.cxx"
 
         case YY_END_OF_BUFFER:
                 {
@@ -1512,7 +1538,7 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                         {
                         yy_current_state = (int) yy_def[yy_current_state];
-                        if ( yy_current_state >= 161 )
+                        if ( yy_current_state >= 165 )
                                 yy_c = yy_meta[(unsigned int) yy_c];
                         }
                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
@@ -1541,11 +1567,11 @@ static int yy_get_next_buffer (yyscan_t yyscanner)
         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
                 {
                 yy_current_state = (int) yy_def[yy_current_state];
-                if ( yy_current_state >= 161 )
+                if ( yy_current_state >= 165 )
                         yy_c = yy_meta[(unsigned int) yy_c];
                 }
         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
-        yy_is_jam = (yy_current_state == 160);
+        yy_is_jam = (yy_current_state == 164);
 
         return yy_is_jam ? 0 : yy_current_state;
 }
@@ -1991,7 +2017,7 @@ YY_BUFFER_STATE cmDependsFortran_yy_scan_string (yyconst char * yystr , yyscan_t
 }
 
 /** Setup the input buffer state to scan the given bytes. The next call to cmDependsFortran_yylex() will
- * scan from a @e copy of @a yybytes.
+ * scan from a @e copy of @a bytes.
  * @param yybytes the byte buffer to scan
  * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
  * @param yyscanner The scanner object.
@@ -2154,7 +2180,7 @@ void cmDependsFortran_yyset_lineno (int  line_number , yyscan_t yyscanner)
 }
 
 /** Set the current column.
- * @param column_no
+ * @param line_number
  * @param yyscanner The scanner object.
  */
 void cmDependsFortran_yyset_column (int  column_no , yyscan_t yyscanner)
@@ -2374,7 +2400,7 @@ void cmDependsFortran_yyfree (void * ptr , yyscan_t)
 
 #define YYTABLES_NAME "yytables"
 
-#line 180 "cmDependsFortranLexer.in.l"
+#line 181 "cmDependsFortranLexer.in.l"
 
 
 
diff --git a/Source/cmDependsFortranLexer.h b/Source/cmDependsFortranLexer.h
index 85e861d..8e24cfd 100644
--- a/Source/cmDependsFortranLexer.h
+++ b/Source/cmDependsFortranLexer.h
@@ -20,7 +20,7 @@
 #define FLEX_SCANNER
 #define YY_FLEX_MAJOR_VERSION 2
 #define YY_FLEX_MINOR_VERSION 5
-#define YY_FLEX_SUBMINOR_VERSION 34
+#define YY_FLEX_SUBMINOR_VERSION 35
 #if YY_FLEX_SUBMINOR_VERSION > 0
 #define FLEX_BETA
 #endif
@@ -65,7 +65,6 @@ typedef int flex_int32_t;
 typedef unsigned char flex_uint8_t;
 typedef unsigned short int flex_uint16_t;
 typedef unsigned int flex_uint32_t;
-#endif /* ! C99 */
 
 /* Limits of integral types. */
 #ifndef INT8_MIN
@@ -96,6 +95,8 @@ typedef unsigned int flex_uint32_t;
 #define UINT32_MAX             (4294967295U)
 #endif
 
+#endif /* ! C99 */
+
 #endif /* ! FLEXINT_H */
 
 #ifdef __cplusplus
@@ -138,7 +139,15 @@ typedef void* yyscan_t;
 
 /* Size of default input buffer. */
 #ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
 #define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
 #endif
 
 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
@@ -146,13 +155,6 @@ typedef void* yyscan_t;
 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 #endif
 
-/* The following is because we cannot portably get our hands on size_t
- * (without autoconf's help, which isn't available because we want
- * flex-generated scanners to compile on their own).
- * Given that the standard has decreed that size_t exists since 1989,
- * I guess we can afford to depend on it. Manoj.
- */
-
 #ifndef YY_TYPEDEF_YY_SIZE_T
 #define YY_TYPEDEF_YY_SIZE_T
 typedef size_t yy_size_t;
@@ -304,7 +306,12 @@ static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
 
 /* Amount of stuff to slurp up with each read. */
 #ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
 #define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
 #endif
 
 /* Number of entries by which start-condition stack grows. */
diff --git a/Source/cmDependsFortranLexer.in.l b/Source/cmDependsFortranLexer.in.l
index af8e37d..40e80b7 100644
--- a/Source/cmDependsFortranLexer.in.l
+++ b/Source/cmDependsFortranLexer.in.l
@@ -115,6 +115,11 @@ Modify cmDependsFortranLexer.h:
 !.*\n                   { return EOSTMT; } /* Treat comments like */
 <fixed_fmt>^[cC*dD].*\n { return EOSTMT; } /* empty lines */
 
+^[ \t]*#[ \t]*include[ \t]*<[^>]+> {
+  yytext[yyleng-1] = 0;
+  yylvalp->string = strdup(strchr(yytext, '<')+1);
+  return CPP_INCLUDE_ANGLE;
+}
 ^[ \t]*#[ \t]*include  { return CPP_INCLUDE; }
 \$[ \t]*include { return F90PPR_INCLUDE; }
 \?\?[ \t]*include { return COCO_INCLUDE; }
diff --git a/Source/cmDependsFortranParser.cxx b/Source/cmDependsFortranParser.cxx
index ea31d3a..7b49a9c 100644
--- a/Source/cmDependsFortranParser.cxx
+++ b/Source/cmDependsFortranParser.cxx
@@ -1,9 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.5.  */
 
-/* Skeleton implementation for Bison's Yacc-like parsers in C
+/* Bison implementation for Yacc-like parsers in C
 
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -45,7 +44,7 @@
 #define YYBISON 1
 
 /* Bison version.  */
-#define YYBISON_VERSION "2.4.1"
+#define YYBISON_VERSION "2.5"
 
 /* Skeleton name.  */
 #define YYSKELETON_NAME "yacc.c"
@@ -74,7 +73,7 @@
 
 /* Copy the first part of user declarations.  */
 
-/* Line 189 of yacc.c  */
+/* Line 268 of yacc.c  */
 #line 1 "cmDependsFortranParser.y"
 
 /*============================================================================
@@ -161,8 +160,8 @@ static bool cmDependsFortranParserIsKeyword(const char* word,
 #endif
 
 
-/* Line 189 of yacc.c  */
-#line 172 "cmDependsFortranParser.cxx"
+/* Line 268 of yacc.c  */
+#line 165 "cmDependsFortranParser.cxx"
 
 /* Enabling traces.  */
 #ifndef YYDEBUG
@@ -216,7 +215,8 @@ static bool cmDependsFortranParserIsKeyword(const char* word,
      CPP_TOENDL = 282,
      UNTERMINATED_STRING = 283,
      STRING = 284,
-     WORD = 285
+     WORD = 285,
+     CPP_INCLUDE_ANGLE = 286
    };
 #endif
 /* Tokens.  */
@@ -248,6 +248,7 @@ static bool cmDependsFortranParserIsKeyword(const char* word,
 #define UNTERMINATED_STRING 283
 #define STRING 284
 #define WORD 285
+#define CPP_INCLUDE_ANGLE 286
 
 
 
@@ -256,15 +257,15 @@ static bool cmDependsFortranParserIsKeyword(const char* word,
 typedef union YYSTYPE
 {
 
-/* Line 214 of yacc.c  */
-#line 94 "cmDependsFortranParser.y"
+/* Line 293 of yacc.c  */
+#line 89 "cmDependsFortranParser.y"
 
   char* string;
 
 
 
-/* Line 214 of yacc.c  */
-#line 274 "cmDependsFortranParser.cxx"
+/* Line 293 of yacc.c  */
+#line 269 "cmDependsFortranParser.cxx"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
@@ -275,8 +276,8 @@ typedef union YYSTYPE
 /* Copy the second part of user declarations.  */
 
 
-/* Line 264 of yacc.c  */
-#line 286 "cmDependsFortranParser.cxx"
+/* Line 343 of yacc.c  */
+#line 281 "cmDependsFortranParser.cxx"
 
 #ifdef short
 # undef short
@@ -326,7 +327,7 @@ typedef short int yytype_int16;
 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
 
 #ifndef YY_
-# if YYENABLE_NLS
+# if defined YYENABLE_NLS && YYENABLE_NLS
 #  if ENABLE_NLS
 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
@@ -379,11 +380,11 @@ YYID (yyi)
 #    define alloca _alloca
 #   else
 #    define YYSTACK_ALLOC alloca
-#    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+#    if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#     ifndef _STDLIB_H
-#      define _STDLIB_H 1
+#     ifndef EXIT_SUCCESS
+#      define EXIT_SUCCESS 0
 #     endif
 #    endif
 #   endif
@@ -406,24 +407,24 @@ YYID (yyi)
 #  ifndef YYSTACK_ALLOC_MAXIMUM
 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
 #  endif
-#  if (defined __cplusplus && ! defined _STDLIB_H \
+#  if (defined __cplusplus && ! defined EXIT_SUCCESS \
        && ! ((defined YYMALLOC || defined malloc) \
              && (defined YYFREE || defined free)))
 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
-#   ifndef _STDLIB_H
-#    define _STDLIB_H 1
+#   ifndef EXIT_SUCCESS
+#    define EXIT_SUCCESS 0
 #   endif
 #  endif
 #  ifndef YYMALLOC
 #   define YYMALLOC malloc
-#   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+#   if ! defined malloc && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
 #   endif
 #  endif
 #  ifndef YYFREE
 #   define YYFREE free
-#   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
+#   if ! defined free && ! defined EXIT_SUCCESS && (defined __STDC__ || defined __C99__FUNC__ \
      || defined __cplusplus || defined _MSC_VER)
 void free (void *); /* INFRINGES ON USER NAME SPACE */
 #   endif
@@ -452,23 +453,7 @@ union yyalloc
      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
       + YYSTACK_GAP_MAXIMUM)
 
-/* Copy COUNT objects from FROM to TO.  The source and destination do
-   not overlap.  */
-# ifndef YYCOPY
-#  if defined __GNUC__ && 1 < __GNUC__
-#   define YYCOPY(To, From, Count) \
-      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
-#  else
-#   define YYCOPY(To, From, Count)              \
-      do                                        \
-        {                                       \
-          YYSIZE_T yyi;                         \
-          for (yyi = 0; yyi < (Count); yyi++)   \
-            (To)[yyi] = (From)[yyi];            \
-        }                                       \
-      while (YYID (0))
-#  endif
-# endif
+# define YYCOPY_NEEDED 1
 
 /* Relocate STACK from its old location to the new one.  The
    local variables YYSIZE and YYSTACKSIZE give the old and new number of
@@ -488,23 +473,43 @@ union yyalloc
 
 #endif
 
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined __GNUC__ && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)              \
+      do                                        \
+        {                                       \
+          YYSIZE_T yyi;                         \
+          for (yyi = 0; yyi < (Count); yyi++)   \
+            (To)[yyi] = (From)[yyi];            \
+        }                                       \
+      while (YYID (0))
+#  endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
 /* YYFINAL -- State number of the termination state.  */
 #define YYFINAL  2
 /* YYLAST -- Last index in YYTABLE.  */
-#define YYLAST   271
+#define YYLAST   276
 
 /* YYNTOKENS -- Number of terminals.  */
-#define YYNTOKENS  31
+#define YYNTOKENS  32
 /* YYNNTS -- Number of nonterminals.  */
 #define YYNNTS  16
 /* YYNRULES -- Number of rules.  */
-#define YYNRULES  52
+#define YYNRULES  53
 /* YYNRULES -- Number of states.  */
-#define YYNSTATES  94
+#define YYNSTATES  97
 
 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
 #define YYUNDEFTOK  2
-#define YYMAXUTOK   285
+#define YYMAXUTOK   286
 
 #define YYTRANSLATE(YYX)                                                \
   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
@@ -540,7 +545,7 @@ static const yytype_uint8 yytranslate[] =
        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
-      25,    26,    27,    28,    29,    30
+      25,    26,    27,    28,    29,    30,    31
 };
 
 #if YYDEBUG
@@ -549,43 +554,43 @@ static const yytype_uint8 yytranslate[] =
 static const yytype_uint8 yyprhs[] =
 {
        0,     0,     3,     4,     7,     9,    11,    16,    19,    24,
-      30,    38,    43,    48,    53,    58,    63,    68,    72,    76,
-      80,    84,    89,    93,    95,    97,    99,   101,   103,   105,
-     107,   109,   111,   113,   115,   117,   119,   121,   123,   125,
-     127,   129,   131,   133,   135,   136,   139,   141,   143,   145,
-     147,   149,   151
+      30,    38,    43,    47,    52,    57,    62,    67,    72,    76,
+      80,    84,    88,    93,    97,    99,   101,   103,   105,   107,
+     109,   111,   113,   115,   117,   119,   121,   123,   125,   127,
+     129,   131,   133,   135,   137,   139,   140,   143,   145,   147,
+     149,   151,   153,   155
 };
 
 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
 static const yytype_int8 yyrhs[] =
 {
-      32,     0,    -1,    -1,    32,    33,    -1,    35,    -1,    34,
-      -1,    30,     4,    45,     3,    -1,    30,     3,    -1,    30,
-      30,    45,     3,    -1,    30,    26,    30,    45,     3,    -1,
-      30,    25,    30,    26,    30,    45,     3,    -1,    30,    29,
-      45,     3,    -1,    36,    29,    45,     3,    -1,    37,    30,
-      45,     3,    -1,    38,    30,    45,     3,    -1,    39,    30,
-      45,     3,    -1,    40,    30,    45,     3,    -1,    41,    45,
-       3,    -1,    42,    45,     3,    -1,    43,    45,     3,    -1,
-      44,    45,     3,    -1,    30,     5,    45,     3,    -1,     5,
-      45,     3,    -1,     3,    -1,     1,    -1,     6,    -1,     7,
-      -1,     8,    -1,    10,    -1,     9,    -1,    12,    -1,    11,
-      -1,    13,    -1,    19,    -1,    14,    -1,    20,    -1,    15,
-      -1,    21,    -1,    17,    -1,    23,    -1,    16,    -1,    22,
-      -1,    18,    -1,    24,    -1,    -1,    45,    46,    -1,    30,
-      -1,    29,    -1,     5,    -1,     4,    -1,    26,    -1,    25,
-      -1,    28,    -1
+      33,     0,    -1,    -1,    33,    34,    -1,    36,    -1,    35,
+      -1,    30,     4,    46,     3,    -1,    30,     3,    -1,    30,
+      30,    46,     3,    -1,    30,    26,    30,    46,     3,    -1,
+      30,    25,    30,    26,    30,    46,     3,    -1,    30,    29,
+      46,     3,    -1,    31,    46,     3,    -1,    37,    29,    46,
+       3,    -1,    38,    30,    46,     3,    -1,    39,    30,    46,
+       3,    -1,    40,    30,    46,     3,    -1,    41,    30,    46,
+       3,    -1,    42,    46,     3,    -1,    43,    46,     3,    -1,
+      44,    46,     3,    -1,    45,    46,     3,    -1,    30,     5,
+      46,     3,    -1,     5,    46,     3,    -1,     3,    -1,     1,
+      -1,     6,    -1,     7,    -1,     8,    -1,    10,    -1,     9,
+      -1,    12,    -1,    11,    -1,    13,    -1,    19,    -1,    14,
+      -1,    20,    -1,    15,    -1,    21,    -1,    17,    -1,    23,
+      -1,    16,    -1,    22,    -1,    18,    -1,    24,    -1,    -1,
+      46,    47,    -1,    30,    -1,    29,    -1,     5,    -1,     4,
+      -1,    26,    -1,    25,    -1,    28,    -1
 };
 
 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
 static const yytype_uint16 yyrline[] =
 {
-       0,   115,   115,   115,   117,   117,   119,   125,   135,   165,
-     176,   189,   200,   207,   213,   219,   225,   231,   236,   241,
-     246,   251,   255,   256,   257,   262,   262,   262,   263,   263,
-     264,   264,   265,   265,   266,   266,   267,   267,   268,   268,
-     269,   269,   270,   270,   271,   271,   274,   275,   276,   277,
-     278,   279,   280
+       0,   111,   111,   111,   113,   113,   115,   121,   131,   161,
+     172,   185,   196,   203,   210,   216,   222,   228,   234,   239,
+     244,   249,   254,   258,   259,   260,   265,   265,   265,   266,
+     266,   267,   267,   268,   268,   269,   269,   270,   270,   271,
+     271,   272,   272,   273,   273,   274,   274,   277,   278,   279,
+     280,   281,   282,   283
 };
 #endif
 
@@ -600,9 +605,9 @@ static const char *const yytname[] =
   "CPP_IF", "CPP_ELSE", "CPP_ELIF", "CPP_ENDIF", "F90PPR_IFDEF",
   "F90PPR_IFNDEF", "F90PPR_IF", "F90PPR_ELSE", "F90PPR_ELIF",
   "F90PPR_ENDIF", "COMMA", "DCOLON", "CPP_TOENDL", "UNTERMINATED_STRING",
-  "STRING", "WORD", "$accept", "code", "stmt", "assignment_stmt",
-  "keyword_stmt", "include", "define", "undef", "ifdef", "ifndef", "if",
-  "elif", "else", "endif", "other", "misc_code", 0
+  "STRING", "WORD", "CPP_INCLUDE_ANGLE", "$accept", "code", "stmt",
+  "assignment_stmt", "keyword_stmt", "include", "define", "undef", "ifdef",
+  "ifndef", "if", "elif", "else", "endif", "other", "misc_code", 0
 };
 #endif
 
@@ -614,163 +619,168 @@ static const yytype_uint16 yytoknum[] =
        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
-     285
+     285,   286
 };
 # endif
 
 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
 static const yytype_uint8 yyr1[] =
 {
-       0,    31,    32,    32,    33,    33,    34,    35,    35,    35,
-      35,    35,    35,    35,    35,    35,    35,    35,    35,    35,
-      35,    35,    35,    35,    35,    36,    36,    36,    37,    37,
-      38,    38,    39,    39,    40,    40,    41,    41,    42,    42,
-      43,    43,    44,    44,    45,    45,    46,    46,    46,    46,
-      46,    46,    46
+       0,    32,    33,    33,    34,    34,    35,    36,    36,    36,
+      36,    36,    36,    36,    36,    36,    36,    36,    36,    36,
+      36,    36,    36,    36,    36,    36,    37,    37,    37,    38,
+      38,    39,    39,    40,    40,    41,    41,    42,    42,    43,
+      43,    44,    44,    45,    45,    46,    46,    47,    47,    47,
+      47,    47,    47,    47
 };
 
 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
 static const yytype_uint8 yyr2[] =
 {
        0,     2,     0,     2,     1,     1,     4,     2,     4,     5,
-       7,     4,     4,     4,     4,     4,     4,     3,     3,     3,
-       3,     4,     3,     1,     1,     1,     1,     1,     1,     1,
+       7,     4,     3,     4,     4,     4,     4,     4,     3,     3,
+       3,     3,     4,     3,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     0,     2,     1,     1,     1,     1,
-       1,     1,     1
+       1,     1,     1,     1,     1,     0,     2,     1,     1,     1,
+       1,     1,     1,     1
 };
 
-/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
-   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+/* YYDEFACT[STATE-NAME] -- Default reduction number in state STATE-NUM.
+   Performed when YYTABLE doesn't specify something else to do.  Zero
    means the default is an error.  */
 static const yytype_uint8 yydefact[] =
 {
-       2,     0,     1,    24,    23,    44,    25,    26,    27,    29,
-      28,    31,    30,    32,    34,    36,    40,    38,    42,    33,
-      35,    37,    41,    39,    43,     0,     3,     5,     4,     0,
-       0,     0,     0,     0,    44,    44,    44,    44,     0,     7,
-      44,    44,     0,     0,    44,    44,    44,    44,    44,    44,
-      44,     0,     0,     0,     0,    22,    49,    48,    51,    50,
-      52,    47,    46,    45,     0,     0,     0,    44,     0,     0,
-       0,     0,     0,     0,     0,    17,    18,    19,    20,     6,
-      21,     0,     0,    11,     8,    12,    13,    14,    15,    16,
-      44,     9,     0,    10
+       2,     0,     1,    25,    24,    45,    26,    27,    28,    30,
+      29,    32,    31,    33,    35,    37,    41,    39,    43,    34,
+      36,    38,    42,    40,    44,     0,    45,     3,     5,     4,
+       0,     0,     0,     0,     0,    45,    45,    45,    45,     0,
+       7,    45,    45,     0,     0,    45,    45,     0,    45,    45,
+      45,    45,    45,     0,     0,     0,     0,    23,    50,    49,
+      52,    51,    53,    48,    47,    46,     0,     0,     0,    45,
+       0,     0,    12,     0,     0,     0,     0,     0,    18,    19,
+      20,    21,     6,    22,     0,     0,    11,     8,    13,    14,
+      15,    16,    17,    45,     9,     0,    10
 };
 
 /* YYDEFGOTO[NTERM-NUM].  */
 static const yytype_int8 yydefgoto[] =
 {
-      -1,     1,    26,    27,    28,    29,    30,    31,    32,    33,
-      34,    35,    36,    37,    38,    63
+      -1,     1,    27,    28,    29,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    65
 };
 
 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
    STATE-NUM.  */
-#define YYPACT_NINF -35
+#define YYPACT_NINF -29
 static const yytype_int16 yypact[] =
 {
-     -35,    29,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
-     -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
-     -35,   -35,   -35,   -35,   -35,   241,   -35,   -35,   -35,   -25,
-     -22,   -21,   -13,   -12,   -35,   -35,   -35,   -35,    57,   -35,
-     -35,   -35,   -11,   -10,   -35,   -35,   -35,   -35,   -35,   -35,
-     -35,    63,    69,    75,   103,   -35,   -35,   -35,   -35,   -35,
-     -35,   -35,   -35,   -35,   109,   115,    -5,   -35,   121,   149,
-     155,   161,   167,   195,   201,   -35,   -35,   -35,   -35,   -35,
-     -35,    -8,   207,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
-     -35,   -35,   213,   -35
+     -29,    39,   -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,
+     -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,
+     -29,   -29,   -29,   -29,   -29,   246,   -29,   -29,   -29,   -29,
+     -28,   -27,   -22,   -17,   -16,   -29,   -29,   -29,   -29,     2,
+     -29,   -29,   -29,   -13,   -12,   -29,   -29,    61,   -29,   -29,
+     -29,   -29,   -29,    68,    74,    80,   108,   -29,   -29,   -29,
+     -29,   -29,   -29,   -29,   -29,   -29,   114,   120,   -24,   -29,
+     126,   154,   -29,   160,   166,   172,   200,   206,   -29,   -29,
+     -29,   -29,   -29,   -29,    -9,   212,   -29,   -29,   -29,   -29,
+     -29,   -29,   -29,   -29,   -29,   218,   -29
 };
 
 /* YYPGOTO[NTERM-NUM].  */
 static const yytype_int8 yypgoto[] =
 {
-     -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,   -35,
-     -35,   -35,   -35,   -35,   -34,   -35
+     -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,   -29,
+     -29,   -29,   -29,   -29,   -26,   -29
 };
 
 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
    positive, shift that token.  If negative, reduce the rule which
-   number is the opposite.  If zero, do what YYDEFACT says.
-   If YYTABLE_NINF, syntax error.  */
+   number is the opposite.  If YYTABLE_NINF, syntax error.  */
 #define YYTABLE_NINF -1
 static const yytype_uint8 yytable[] =
 {
-      51,    52,    53,    54,    46,     0,    64,    65,    47,    48,
-      68,    69,    70,    71,    72,    73,    74,    49,    50,    66,
-      67,    81,    90,     0,     0,     0,     0,     0,     0,     2,
-       3,     0,     4,    82,     5,     6,     7,     8,     9,    10,
+      47,    48,    84,    49,     0,    57,    58,    59,    50,    53,
+      54,    55,    56,    51,    52,    66,    67,    68,    69,    70,
+      71,    93,    73,    74,    75,    76,    77,    60,    61,     0,
+      62,    63,    64,     0,     0,     0,     0,     0,     0,     2,
+       3,     0,     4,    85,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,     0,     0,    92,     0,     0,    25,
-      55,    56,    57,     0,     0,     0,    75,    56,    57,     0,
-       0,     0,    76,    56,    57,     0,     0,     0,    77,    56,
-      57,     0,    58,    59,     0,    60,    61,    62,    58,    59,
-       0,    60,    61,    62,    58,    59,     0,    60,    61,    62,
-      58,    59,     0,    60,    61,    62,    78,    56,    57,     0,
-       0,     0,    79,    56,    57,     0,     0,     0,    80,    56,
-      57,     0,     0,     0,    83,    56,    57,     0,    58,    59,
-       0,    60,    61,    62,    58,    59,     0,    60,    61,    62,
-      58,    59,     0,    60,    61,    62,    58,    59,     0,    60,
-      61,    62,    84,    56,    57,     0,     0,     0,    85,    56,
-      57,     0,     0,     0,    86,    56,    57,     0,     0,     0,
-      87,    56,    57,     0,    58,    59,     0,    60,    61,    62,
-      58,    59,     0,    60,    61,    62,    58,    59,     0,    60,
-      61,    62,    58,    59,     0,    60,    61,    62,    88,    56,
-      57,     0,     0,     0,    89,    56,    57,     0,     0,     0,
-      91,    56,    57,     0,     0,     0,    93,    56,    57,     0,
-      58,    59,     0,    60,    61,    62,    58,    59,     0,    60,
-      61,    62,    58,    59,     0,    60,    61,    62,    58,    59,
-       0,    60,    61,    62,    39,    40,    41,     0,     0,     0,
+      21,    22,    23,    24,    72,    58,    59,    95,     0,    25,
+      26,    78,    58,    59,     0,     0,     0,    79,    58,    59,
+       0,     0,     0,    80,    58,    59,    60,    61,     0,    62,
+      63,    64,     0,    60,    61,     0,    62,    63,    64,    60,
+      61,     0,    62,    63,    64,    60,    61,     0,    62,    63,
+      64,    81,    58,    59,     0,     0,     0,    82,    58,    59,
+       0,     0,     0,    83,    58,    59,     0,     0,     0,    86,
+      58,    59,     0,    60,    61,     0,    62,    63,    64,    60,
+      61,     0,    62,    63,    64,    60,    61,     0,    62,    63,
+      64,    60,    61,     0,    62,    63,    64,    87,    58,    59,
+       0,     0,     0,    88,    58,    59,     0,     0,     0,    89,
+      58,    59,     0,     0,     0,    90,    58,    59,     0,    60,
+      61,     0,    62,    63,    64,    60,    61,     0,    62,    63,
+      64,    60,    61,     0,    62,    63,    64,    60,    61,     0,
+      62,    63,    64,    91,    58,    59,     0,     0,     0,    92,
+      58,    59,     0,     0,     0,    94,    58,    59,     0,     0,
+       0,    96,    58,    59,     0,    60,    61,     0,    62,    63,
+      64,    60,    61,     0,    62,    63,    64,    60,    61,     0,
+      62,    63,    64,    60,    61,     0,    62,    63,    64,    40,
+      41,    42,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    42,    43,     0,     0,
-      44,    45
+       0,    43,    44,     0,     0,    45,    46
 };
 
+#define yypact_value_is_default(yystate) \
+  ((yystate) == (-29))
+
+#define yytable_value_is_error(yytable_value) \
+  YYID (0)
+
 static const yytype_int8 yycheck[] =
 {
-      34,    35,    36,    37,    29,    -1,    40,    41,    30,    30,
-      44,    45,    46,    47,    48,    49,    50,    30,    30,    30,
-      30,    26,    30,    -1,    -1,    -1,    -1,    -1,    -1,     0,
-       1,    -1,     3,    67,     5,     6,     7,     8,     9,    10,
+      26,    29,    26,    30,    -1,     3,     4,     5,    30,    35,
+      36,    37,    38,    30,    30,    41,    42,    30,    30,    45,
+      46,    30,    48,    49,    50,    51,    52,    25,    26,    -1,
+      28,    29,    30,    -1,    -1,    -1,    -1,    -1,    -1,     0,
+       1,    -1,     3,    69,     5,     6,     7,     8,     9,    10,
       11,    12,    13,    14,    15,    16,    17,    18,    19,    20,
-      21,    22,    23,    24,    -1,    -1,    90,    -1,    -1,    30,
-       3,     4,     5,    -1,    -1,    -1,     3,     4,     5,    -1,
-      -1,    -1,     3,     4,     5,    -1,    -1,    -1,     3,     4,
-       5,    -1,    25,    26,    -1,    28,    29,    30,    25,    26,
-      -1,    28,    29,    30,    25,    26,    -1,    28,    29,    30,
-      25,    26,    -1,    28,    29,    30,     3,     4,     5,    -1,
-      -1,    -1,     3,     4,     5,    -1,    -1,    -1,     3,     4,
-       5,    -1,    -1,    -1,     3,     4,     5,    -1,    25,    26,
-      -1,    28,    29,    30,    25,    26,    -1,    28,    29,    30,
-      25,    26,    -1,    28,    29,    30,    25,    26,    -1,    28,
-      29,    30,     3,     4,     5,    -1,    -1,    -1,     3,     4,
-       5,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,
-       3,     4,     5,    -1,    25,    26,    -1,    28,    29,    30,
-      25,    26,    -1,    28,    29,    30,    25,    26,    -1,    28,
-      29,    30,    25,    26,    -1,    28,    29,    30,     3,     4,
-       5,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,
-       3,     4,     5,    -1,    -1,    -1,     3,     4,     5,    -1,
-      25,    26,    -1,    28,    29,    30,    25,    26,    -1,    28,
-      29,    30,    25,    26,    -1,    28,    29,    30,    25,    26,
-      -1,    28,    29,    30,     3,     4,     5,    -1,    -1,    -1,
+      21,    22,    23,    24,     3,     4,     5,    93,    -1,    30,
+      31,     3,     4,     5,    -1,    -1,    -1,     3,     4,     5,
+      -1,    -1,    -1,     3,     4,     5,    25,    26,    -1,    28,
+      29,    30,    -1,    25,    26,    -1,    28,    29,    30,    25,
+      26,    -1,    28,    29,    30,    25,    26,    -1,    28,    29,
+      30,     3,     4,     5,    -1,    -1,    -1,     3,     4,     5,
+      -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,     3,
+       4,     5,    -1,    25,    26,    -1,    28,    29,    30,    25,
+      26,    -1,    28,    29,    30,    25,    26,    -1,    28,    29,
+      30,    25,    26,    -1,    28,    29,    30,     3,     4,     5,
+      -1,    -1,    -1,     3,     4,     5,    -1,    -1,    -1,     3,
+       4,     5,    -1,    -1,    -1,     3,     4,     5,    -1,    25,
+      26,    -1,    28,    29,    30,    25,    26,    -1,    28,    29,
+      30,    25,    26,    -1,    28,    29,    30,    25,    26,    -1,
+      28,    29,    30,     3,     4,     5,    -1,    -1,    -1,     3,
+       4,     5,    -1,    -1,    -1,     3,     4,     5,    -1,    -1,
+      -1,     3,     4,     5,    -1,    25,    26,    -1,    28,    29,
+      30,    25,    26,    -1,    28,    29,    30,    25,    26,    -1,
+      28,    29,    30,    25,    26,    -1,    28,    29,    30,     3,
+       4,     5,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    25,    26,    -1,    -1,
-      29,    30
+      -1,    25,    26,    -1,    -1,    29,    30
 };
 
 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
    symbol of state STATE-NUM.  */
 static const yytype_uint8 yystos[] =
 {
-       0,    32,     0,     1,     3,     5,     6,     7,     8,     9,
+       0,    33,     0,     1,     3,     5,     6,     7,     8,     9,
       10,    11,    12,    13,    14,    15,    16,    17,    18,    19,
-      20,    21,    22,    23,    24,    30,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,     3,
-       4,     5,    25,    26,    29,    30,    29,    30,    30,    30,
-      30,    45,    45,    45,    45,     3,     4,     5,    25,    26,
-      28,    29,    30,    46,    45,    45,    30,    30,    45,    45,
-      45,    45,    45,    45,    45,     3,     3,     3,     3,     3,
-       3,    26,    45,     3,     3,     3,     3,     3,     3,     3,
-      30,     3,    45,     3
+      20,    21,    22,    23,    24,    30,    31,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+       3,     4,     5,    25,    26,    29,    30,    46,    29,    30,
+      30,    30,    30,    46,    46,    46,    46,     3,     4,     5,
+      25,    26,    28,    29,    30,    47,    46,    46,    30,    30,
+      46,    46,     3,    46,    46,    46,    46,    46,     3,     3,
+       3,     3,     3,     3,    26,    46,     3,     3,     3,     3,
+       3,     3,     3,    30,     3,    46,     3
 };
 
 #define yyerrok         (yyerrstatus = 0)
@@ -785,9 +795,18 @@ static const yytype_uint8 yystos[] =
 
 /* Like YYERROR except do call yyerror.  This remains here temporarily
    to ease the transition to the new meaning of YYERROR, for GCC.
-   Once GCC version 2 has supplanted version 1, this can go.  */
+   Once GCC version 2 has supplanted version 1, this can go.  However,
+   YYFAIL appears to be in use.  Nevertheless, it is formally deprecated
+   in Bison 2.4.2's NEWS entry, where a plan to phase it out is
+   discussed.  */
 
 #define YYFAIL          goto yyerrlab
+#if defined YYFAIL
+  /* This is here to suppress warnings from the GCC cpp's
+     -Wunused-macros.  Normally we don't worry about that warning, but
+     some users do, and we want to make it easy for users to remove
+     YYFAIL uses, which will produce warnings from Bison 2.5.  */
+#endif
 
 #define YYRECOVERING()  (!!yyerrstatus)
 
@@ -797,7 +816,6 @@ do                                                              \
     {                                                           \
       yychar = (Token);                                         \
       yylval = (Value);                                         \
-      yytoken = YYTRANSLATE (yychar);                           \
       YYPOPSTACK (1);                                           \
       goto yybackup;                                            \
     }                                                           \
@@ -839,19 +857,10 @@ while (YYID (0))
 #endif
 
 
-/* YY_LOCATION_PRINT -- Print the location on the stream.
-   This macro was not mandated originally: define only if we know
-   we won't break user code: when these are the locations we know.  */
+/* This macro is provided for backward compatibility. */
 
 #ifndef YY_LOCATION_PRINT
-# if YYLTYPE_IS_TRIVIAL
-#  define YY_LOCATION_PRINT(File, Loc)                  \
-     fprintf (File, "%d.%d-%d.%d",                      \
-              (Loc).first_line, (Loc).first_column,     \
-              (Loc).last_line,  (Loc).last_column)
-# else
-#  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
-# endif
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
 #endif
 
 
@@ -1043,7 +1052,6 @@ int yydebug;
 # define YYMAXDEPTH 10000
 #endif
 
-
 
 #if YYERROR_VERBOSE
 
@@ -1146,115 +1154,142 @@ yytnamerr (char *yyres, const char *yystr)
 }
 # endif
 
-/* Copy into YYRESULT an error message about the unexpected token
-   YYCHAR while in state YYSTATE.  Return the number of bytes copied,
-   including the terminating null byte.  If YYRESULT is null, do not
-   copy anything; just return the number of bytes that would be
-   copied.  As a special case, return 0 if an ordinary "syntax error"
-   message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
-   size calculation.  */
-static YYSIZE_T
-yysyntax_error (char *yyresult, int yystate, int yychar)
-{
-  int yyn = yypact[yystate];
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+   about the unexpected token YYTOKEN for the state stack whose top is
+   YYSSP.
 
-  if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
-    return 0;
-  else
+   Return 0 if *YYMSG was successfully written.  Return 1 if *YYMSG is
+   not large enough to hold the message.  In that case, also set
+   *YYMSG_ALLOC to the required number of bytes.  Return 2 if the
+   required number of bytes is too large to store.  */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+                yytype_int16 *yyssp, int yytoken)
+{
+  YYSIZE_T yysize0 = yytnamerr (0, yytname[yytoken]);
+  YYSIZE_T yysize = yysize0;
+  YYSIZE_T yysize1;
+  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+  /* Internationalized format string. */
+  const char *yyformat = 0;
+  /* Arguments of yyformat. */
+  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+  /* Number of reported tokens (one for the "unexpected", one per
+     "expected"). */
+  int yycount = 0;
+
+  /* There are many possibilities here to consider:
+     - Assume YYFAIL is not used.  It's too flawed to consider.  See
+       <http://lists.gnu.org/archive/html/bison-patches/2009-12/msg00024.html>
+       for details.  YYERROR is fine as it does not invoke this
+       function.
+     - If this state is a consistent state with a default action, then
+       the only way this function was invoked is if the default action
+       is an error action.  In that case, don't check for expected
+       tokens because there are none.
+     - The only way there can be no lookahead present (in yychar) is if
+       this state is a consistent state with a default action.  Thus,
+       detecting the absence of a lookahead is sufficient to determine
+       that there is no unexpected or expected token to report.  In that
+       case, just report a simple "syntax error".
+     - Don't assume there isn't a lookahead just because this state is a
+       consistent state with a default action.  There might have been a
+       previous inconsistent state, consistent state with a non-default
+       action, or user semantic action that manipulated yychar.
+     - Of course, the expected token list depends on states to have
+       correct lookahead information, and it depends on the parser not
+       to perform extra reductions after fetching a lookahead from the
+       scanner and before detecting a syntax error.  Thus, state merging
+       (from LALR or IELR) and default reductions corrupt the expected
+       token list.  However, the list is correct for canonical LR with
+       one exception: it will still contain any token that will not be
+       accepted due to an error action in a later state.
+  */
+  if (yytoken != YYEMPTY)
     {
-      int yytype = YYTRANSLATE (yychar);
-      YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
-      YYSIZE_T yysize = yysize0;
-      YYSIZE_T yysize1;
-      int yysize_overflow = 0;
-      enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
-      char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
-      int yyx;
-
-# if 0
-      /* This is so xgettext sees the translatable formats that are
-         constructed on the fly.  */
-      YY_("syntax error, unexpected %s");
-      YY_("syntax error, unexpected %s, expecting %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s or %s");
-      YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
-# endif
-      char *yyfmt;
-      char const *yyf;
-      static char const yyunexpected[] = "syntax error, unexpected %s";
-      static char const yyexpecting[] = ", expecting %s";
-      static char const yyor[] = " or %s";
-      char yyformat[sizeof yyunexpected
-                    + sizeof yyexpecting - 1
-                    + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
-                       * (sizeof yyor - 1))];
-      char const *yyprefix = yyexpecting;
-
-      /* Start YYX at -YYN if negative to avoid negative indexes in
-         YYCHECK.  */
-      int yyxbegin = yyn < 0 ? -yyn : 0;
-
-      /* Stay within bounds of both yycheck and yytname.  */
-      int yychecklim = YYLAST - yyn + 1;
-      int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
-      int yycount = 1;
-
-      yyarg[0] = yytname[yytype];
-      yyfmt = yystpcpy (yyformat, yyunexpected);
-
-      for (yyx = yyxbegin; yyx < yyxend; ++yyx)
-        if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
-          {
-            if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+      int yyn = yypact[*yyssp];
+      yyarg[yycount++] = yytname[yytoken];
+      if (!yypact_value_is_default (yyn))
+        {
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  In other words, skip the first -YYN actions for
+             this state because they are default actions.  */
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          /* Stay within bounds of both yycheck and yytname.  */
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+                && !yytable_value_is_error (yytable[yyx + yyn]))
               {
-                yycount = 1;
-                yysize = yysize0;
-                yyformat[sizeof yyunexpected - 1] = '\0';
-                break;
+                if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+                  {
+                    yycount = 1;
+                    yysize = yysize0;
+                    break;
+                  }
+                yyarg[yycount++] = yytname[yyx];
+                yysize1 = yysize + yytnamerr (0, yytname[yyx]);
+                if (! (yysize <= yysize1
+                       && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+                  return 2;
+                yysize = yysize1;
               }
-            yyarg[yycount++] = yytname[yyx];
-            yysize1 = yysize + yytnamerr (0, yytname[yyx]);
-            yysize_overflow |= (yysize1 < yysize);
-            yysize = yysize1;
-            yyfmt = yystpcpy (yyfmt, yyprefix);
-            yyprefix = yyor;
-          }
+        }
+    }
+
+  switch (yycount)
+    {
+# define YYCASE_(N, S)                      \
+      case N:                               \
+        yyformat = S;                       \
+      break
+      YYCASE_(0, YY_("syntax error"));
+      YYCASE_(1, YY_("syntax error, unexpected %s"));
+      YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+      YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+      YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+      YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+    }
 
-      yyf = YY_(yyformat);
-      yysize1 = yysize + yystrlen (yyf);
-      yysize_overflow |= (yysize1 < yysize);
-      yysize = yysize1;
+  yysize1 = yysize + yystrlen (yyformat);
+  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+    return 2;
+  yysize = yysize1;
 
-      if (yysize_overflow)
-        return YYSIZE_MAXIMUM;
+  if (*yymsg_alloc < yysize)
+    {
+      *yymsg_alloc = 2 * yysize;
+      if (! (yysize <= *yymsg_alloc
+             && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+        *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+      return 1;
+    }
 
-      if (yyresult)
+  /* Avoid sprintf, as that infringes on the user's name space.
+     Don't have undefined behavior even if the translation
+     produced a string with the wrong number of "%s"s.  */
+  {
+    char *yyp = *yymsg;
+    int yyi = 0;
+    while ((*yyp = *yyformat) != '\0')
+      if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
         {
-          /* Avoid sprintf, as that infringes on the user's name space.
-             Don't have undefined behavior even if the translation
-             produced a string with the wrong number of "%s"s.  */
-          char *yyp = yyresult;
-          int yyi = 0;
-          while ((*yyp = *yyf) != '\0')
-            {
-              if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
-                {
-                  yyp += yytnamerr (yyp, yyarg[yyi++]);
-                  yyf += 2;
-                }
-              else
-                {
-                  yyp++;
-                  yyf++;
-                }
-            }
+          yyp += yytnamerr (yyp, yyarg[yyi++]);
+          yyformat += 2;
         }
-      return yysize;
-    }
+      else
+        {
+          yyp++;
+          yyformat++;
+        }
+  }
+  return 0;
 }
 #endif /* YYERROR_VERBOSE */
-
 
 /*-----------------------------------------------.
 | Release the memory associated to this symbol.  |
@@ -1287,6 +1322,7 @@ yydestruct (yymsg, yytype, yyvaluep)
     }
 }
 
+
 /* Prevent warnings from -Wmissing-prototypes.  */
 #ifdef YYPARSE_PARAM
 #if defined __STDC__ || defined __cplusplus
@@ -1303,12 +1339,9 @@ int yyparse ();
 #endif /* ! YYPARSE_PARAM */
 
 
-
-
-
-/*-------------------------.
-| yyparse or yypush_parse.  |
-`-------------------------*/
+/*----------.
+| yyparse.  |
+`----------*/
 
 #ifdef YYPARSE_PARAM
 #if (defined __STDC__ || defined __C99__FUNC__ \
@@ -1495,7 +1528,7 @@ yybackup:
 
   /* First try to decide what to do without reference to lookahead token.  */
   yyn = yypact[yystate];
-  if (yyn == YYPACT_NINF)
+  if (yypact_value_is_default (yyn))
     goto yydefault;
 
   /* Not known => get a lookahead token if don't already have one.  */
@@ -1526,7 +1559,7 @@ yybackup:
   yyn = yytable[yyn];
   if (yyn <= 0)
     {
-      if (yyn == 0 || yyn == YYTABLE_NINF)
+      if (yytable_value_is_error (yyn))
         goto yyerrlab;
       yyn = -yyn;
       goto yyreduce;
@@ -1582,8 +1615,8 @@ yyreduce:
     {
         case 6:
 
-/* Line 1455 of yacc.c  */
-#line 120 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 116 "cmDependsFortranParser.y"
     {
     free((yyvsp[(1) - (4)].string));
     }
@@ -1591,8 +1624,8 @@ yyreduce:
 
   case 7:
 
-/* Line 1455 of yacc.c  */
-#line 126 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 122 "cmDependsFortranParser.y"
     {
     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (2)].string), "interface"))
       {
@@ -1606,8 +1639,8 @@ yyreduce:
 
   case 8:
 
-/* Line 1455 of yacc.c  */
-#line 136 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 132 "cmDependsFortranParser.y"
     {
     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "use"))
       {
@@ -1641,8 +1674,8 @@ yyreduce:
 
   case 9:
 
-/* Line 1455 of yacc.c  */
-#line 166 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 162 "cmDependsFortranParser.y"
     {
     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (5)].string), "use"))
       {
@@ -1657,8 +1690,8 @@ yyreduce:
 
   case 10:
 
-/* Line 1455 of yacc.c  */
-#line 177 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 173 "cmDependsFortranParser.y"
     {
     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (7)].string), "use") &&
         cmDependsFortranParserIsKeyword((yyvsp[(3) - (7)].string), "non_intrinsic") )
@@ -1675,8 +1708,8 @@ yyreduce:
 
   case 11:
 
-/* Line 1455 of yacc.c  */
-#line 190 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 186 "cmDependsFortranParser.y"
     {
     if (cmDependsFortranParserIsKeyword((yyvsp[(1) - (4)].string), "include"))
       {
@@ -1691,8 +1724,20 @@ yyreduce:
 
   case 12:
 
-/* Line 1455 of yacc.c  */
-#line 201 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 197 "cmDependsFortranParser.y"
+    {
+    cmDependsFortranParser* parser =
+      cmDependsFortran_yyget_extra(yyscanner);
+    cmDependsFortranParser_RuleInclude(parser, (yyvsp[(1) - (3)].string));
+    free((yyvsp[(1) - (3)].string));
+    }
+    break;
+
+  case 13:
+
+/* Line 1806 of yacc.c  */
+#line 204 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser =
       cmDependsFortran_yyget_extra(yyscanner);
@@ -1701,10 +1746,10 @@ yyreduce:
     }
     break;
 
-  case 13:
+  case 14:
 
-/* Line 1455 of yacc.c  */
-#line 208 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 211 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleDefine(parser, (yyvsp[(2) - (4)].string));
@@ -1712,10 +1757,10 @@ yyreduce:
     }
     break;
 
-  case 14:
+  case 15:
 
-/* Line 1455 of yacc.c  */
-#line 214 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 217 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleUndef(parser, (yyvsp[(2) - (4)].string));
@@ -1723,10 +1768,10 @@ yyreduce:
     }
     break;
 
-  case 15:
+  case 16:
 
-/* Line 1455 of yacc.c  */
-#line 220 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 223 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleIfdef(parser, (yyvsp[(2) - (4)].string));
@@ -1734,10 +1779,10 @@ yyreduce:
     }
     break;
 
-  case 16:
+  case 17:
 
-/* Line 1455 of yacc.c  */
-#line 226 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 229 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleIfndef(parser, (yyvsp[(2) - (4)].string));
@@ -1745,75 +1790,86 @@ yyreduce:
     }
     break;
 
-  case 17:
+  case 18:
 
-/* Line 1455 of yacc.c  */
-#line 232 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 235 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleIf(parser);
     }
     break;
 
-  case 18:
+  case 19:
 
-/* Line 1455 of yacc.c  */
-#line 237 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 240 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleElif(parser);
     }
     break;
 
-  case 19:
+  case 20:
 
-/* Line 1455 of yacc.c  */
-#line 242 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 245 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleElse(parser);
     }
     break;
 
-  case 20:
+  case 21:
 
-/* Line 1455 of yacc.c  */
-#line 247 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 250 "cmDependsFortranParser.y"
     {
     cmDependsFortranParser* parser = cmDependsFortran_yyget_extra(yyscanner);
     cmDependsFortranParser_RuleEndif(parser);
     }
     break;
 
-  case 21:
+  case 22:
 
-/* Line 1455 of yacc.c  */
-#line 252 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 255 "cmDependsFortranParser.y"
     {
     free((yyvsp[(1) - (4)].string));
     }
     break;
 
-  case 46:
+  case 47:
 
-/* Line 1455 of yacc.c  */
-#line 274 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 277 "cmDependsFortranParser.y"
     { free ((yyvsp[(1) - (1)].string)); }
     break;
 
-  case 47:
+  case 48:
 
-/* Line 1455 of yacc.c  */
-#line 275 "cmDependsFortranParser.y"
+/* Line 1806 of yacc.c  */
+#line 278 "cmDependsFortranParser.y"
     { free ((yyvsp[(1) - (1)].string)); }
     break;
 
 
 
-/* Line 1455 of yacc.c  */
-#line 1821 "cmDependsFortranParser.cxx"
+/* Line 1806 of yacc.c  */
+#line 1860 "cmDependsFortranParser.cxx"
       default: break;
     }
+  /* User semantic actions sometimes alter yychar, and that requires
+     that yytoken be updated with the new translation.  We take the
+     approach of translating immediately before every use of yytoken.
+     One alternative is translating here after every semantic action,
+     but that translation would be missed if the semantic action invokes
+     YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+     if it invokes YYBACKUP.  In the case of YYABORT or YYACCEPT, an
+     incorrect destructor might then be invoked immediately.  In the
+     case of YYERROR or YYBACKUP, subsequent parser actions might lead
+     to an incorrect destructor call or verbose syntax error message
+     before the lookahead is translated.  */
   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
 
   YYPOPSTACK (yylen);
@@ -1841,6 +1897,10 @@ yyreduce:
 | yyerrlab -- here on detecting error |
 `------------------------------------*/
 yyerrlab:
+  /* Make sure we have latest lookahead translation.  See comments at
+     user semantic actions for why this is necessary.  */
+  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
   /* If not already recovering from an error, report this error.  */
   if (!yyerrstatus)
     {
@@ -1848,37 +1908,36 @@ yyerrlab:
 #if ! YYERROR_VERBOSE
       yyerror (YY_("syntax error"));
 #else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+                                        yyssp, yytoken)
       {
-        YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
-        if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
+        char const *yymsgp = YY_("syntax error");
+        int yysyntax_error_status;
+        yysyntax_error_status = YYSYNTAX_ERROR;
+        if (yysyntax_error_status == 0)
+          yymsgp = yymsg;
+        else if (yysyntax_error_status == 1)
           {
-            YYSIZE_T yyalloc = 2 * yysize;
-            if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
-              yyalloc = YYSTACK_ALLOC_MAXIMUM;
             if (yymsg != yymsgbuf)
               YYSTACK_FREE (yymsg);
-            yymsg = (char *) YYSTACK_ALLOC (yyalloc);
-            if (yymsg)
-              yymsg_alloc = yyalloc;
-            else
+            yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+            if (!yymsg)
               {
                 yymsg = yymsgbuf;
                 yymsg_alloc = sizeof yymsgbuf;
+                yysyntax_error_status = 2;
+              }
+            else
+              {
+                yysyntax_error_status = YYSYNTAX_ERROR;
+                yymsgp = yymsg;
               }
           }
-
-        if (0 < yysize && yysize <= yymsg_alloc)
-          {
-            (void) yysyntax_error (yymsg, yystate, yychar);
-            yyerror (yymsg);
-          }
-        else
-          {
-            yyerror (YY_("syntax error"));
-            if (yysize != 0)
-              goto yyexhaustedlab;
-          }
+        yyerror (yymsgp);
+        if (yysyntax_error_status == 2)
+          goto yyexhaustedlab;
       }
+# undef YYSYNTAX_ERROR
 #endif
     }
 
@@ -1939,7 +1998,7 @@ yyerrlab1:
   for (;;)
     {
       yyn = yypact[yystate];
-      if (yyn != YYPACT_NINF)
+      if (!yypact_value_is_default (yyn))
         {
           yyn += YYTERROR;
           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
@@ -1998,8 +2057,13 @@ yyexhaustedlab:
 
 yyreturn:
   if (yychar != YYEMPTY)
-     yydestruct ("Cleanup: discarding lookahead",
-                 yytoken, &yylval);
+    {
+      /* Make sure we have latest lookahead translation.  See comments at
+         user semantic actions for why this is necessary.  */
+      yytoken = YYTRANSLATE (yychar);
+      yydestruct ("Cleanup: discarding lookahead",
+                  yytoken, &yylval);
+    }
   /* Do not reclaim the symbols of the rule which action triggered
      this YYABORT or YYACCEPT.  */
   YYPOPSTACK (yylen);
@@ -2024,7 +2088,7 @@ yyreturn:
 
 
 
-/* Line 1675 of yacc.c  */
-#line 283 "cmDependsFortranParser.y"
+/* Line 2067 of yacc.c  */
+#line 286 "cmDependsFortranParser.y"
 
 /* End of grammar */
diff --git a/Source/cmDependsFortranParser.y b/Source/cmDependsFortranParser.y
index 00d3327..5681d69 100644
--- a/Source/cmDependsFortranParser.y
+++ b/Source/cmDependsFortranParser.y
@@ -102,6 +102,7 @@ static bool cmDependsFortranParserIsKeyword(const char* word,
 %token <string> CPP_TOENDL
 %token <number> UNTERMINATED_STRING
 %token <string> STRING WORD
+%token <string> CPP_INCLUDE_ANGLE
 
 /*-------------------------------------------------------------------------*/
 /* grammar */
@@ -192,6 +193,13 @@ keyword_stmt:
     free($1);
     free($2);
     }
+| CPP_INCLUDE_ANGLE other EOSTMT
+    {
+    cmDependsFortranParser* parser =
+      cmDependsFortran_yyget_extra(yyscanner);
+    cmDependsFortranParser_RuleInclude(parser, $1);
+    free($1);
+    }
 | include STRING other EOSTMT
     {
     cmDependsFortranParser* parser =
diff --git a/Source/cmDependsFortranParserTokens.h b/Source/cmDependsFortranParserTokens.h
index 0bbcaae..941eda0 100644
--- a/Source/cmDependsFortranParserTokens.h
+++ b/Source/cmDependsFortranParserTokens.h
@@ -1,9 +1,8 @@
-/* A Bison parser, made by GNU Bison 2.4.1.  */
+/* A Bison parser, made by GNU Bison 2.5.  */
 
-/* Skeleton interface for Bison's Yacc-like parsers in C
+/* Bison interface for Yacc-like parsers in C
 
-      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
-   Free Software Foundation, Inc.
+      Copyright (C) 1984, 1989-1990, 2000-2011 Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -31,6 +30,7 @@
    This special exception was added by the Free Software Foundation in
    version 2.2 of Bison.  */
 
+
 /* Tokens.  */
 #ifndef YYTOKENTYPE
 # define YYTOKENTYPE
@@ -64,7 +64,8 @@
      CPP_TOENDL = 282,
      UNTERMINATED_STRING = 283,
      STRING = 284,
-     WORD = 285
+     WORD = 285,
+     CPP_INCLUDE_ANGLE = 286
    };
 #endif
 /* Tokens.  */
@@ -96,6 +97,7 @@
 #define UNTERMINATED_STRING 283
 #define STRING 284
 #define WORD 285
+#define CPP_INCLUDE_ANGLE 286
 
 
 
@@ -104,12 +106,14 @@
 typedef union YYSTYPE
 {
 
-/* Line 1676 of yacc.c  */
-#line 94 "cmDependsFortranParser.y"
+/* Line 2068 of yacc.c  */
+#line 89 "cmDependsFortranParser.y"
 
   char* string;
 
-/* Line 1676 of yacc.c  */
+
+
+/* Line 2068 of yacc.c  */
 #line 118 "cmDependsFortranParserTokens.h"
 } YYSTYPE;
 # define YYSTYPE_IS_TRIVIAL 1
diff --git a/Source/cmDocumentVariables.cxx b/Source/cmDocumentVariables.cxx
index 897e516..9e33d75 100644
--- a/Source/cmDocumentVariables.cxx
+++ b/Source/cmDocumentVariables.cxx
@@ -523,6 +523,16 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
      "Variables That Change Behavior");
 
     cm->DefineProperty
+    ("CMAKE_INSTALL_DEFAULT_COMPONENT_NAME",  cmProperty::VARIABLE,
+     "Default component used in install() commands.",
+     "If an install() command is used without the COMPONENT argument, "
+     "these files will be grouped into a default component. The name of this "
+     "default install component will be taken from this variable.  "
+     "It defaults to \"Unspecified\". ",
+     false,
+     "Variables That Change Behavior");
+
+    cm->DefineProperty
     ("CMAKE_FIND_LIBRARY_PREFIXES",  cmProperty::VARIABLE,
      "Prefixes to prepend when looking for libraries.",
      "This specifies what prefixes to add to library names when "
@@ -833,6 +843,36 @@ void cmDocumentVariables::DefineVariables(cmake* cm)
      "Default is ON.",false,
      "Variables That Change Behavior");
 
+  cm->DefineProperty
+    ("CMAKE_ABSOLUTE_DESTINATION_FILES", cmProperty::VARIABLE,
+      "List of files which have been installed using "
+      " an ABSOLUTE DESTINATION path.",
+      "This variable is defined by CMake-generated cmake_install.cmake "
+      "scripts."
+      " It can be used (read-only) by program or script that source those"
+      " install scripts. This is used by some CPack generators (e.g. RPM).",
+      false,
+      "Variables That Change Behavior");
+
+  cm->DefineProperty
+    ("CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
+      "Ask cmake_install.cmake script to warn each time a file with "
+      "absolute INSTALL DESTINATION is encountered.",
+      "This variable is used by CMake-generated cmake_install.cmake"
+      " scripts. If ones set this variable to ON while running the"
+      " script, it may get warning messages from the script.", false,
+      "Variables That Change Behavior");
+
+  cm->DefineProperty
+    ("CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION", cmProperty::VARIABLE,
+      "Ask cmake_install.cmake script to error out as soon as "
+      "a file with absolute INSTALL DESTINATION is encountered.",
+      "The fatal error is emitted before the installation of "
+      "the offending file takes place."
+      " This variable is used by CMake-generated cmake_install.cmake"
+      " scripts. If ones set this variable to ON while running the"
+      " script, it may get fatal error messages from the script.",false,
+      "Variables That Change Behavior");
 
   // Variables defined by CMake that describe the system
 
diff --git a/Source/cmDocumentationFormatterHTML.cxx b/Source/cmDocumentationFormatterHTML.cxx
index ed28b45..cd0077e 100644
--- a/Source/cmDocumentationFormatterHTML.cxx
+++ b/Source/cmDocumentationFormatterHTML.cxx
@@ -145,7 +145,7 @@ void cmDocumentationFormatterHTML
             cmDocumentationPrintHTMLId(os, op->Name.c_str());
             os << "\"><b><code>";
             this->PrintHTMLEscapes(os, op->Name.c_str());
-            os << "</code></b></a></li>";
+            os << "</code></b></a></li>\n";
             }
           }
         os << "</ul>\n" ;
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 4f9ba7e..be47f95 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -1368,41 +1368,73 @@ bool cmFindPackageCommand::ReadListFile(const char* f, PolicyScopeRule psr)
 }
 
 //----------------------------------------------------------------------------
-void cmFindPackageCommand::AppendToProperty(const char* propertyName)
+void cmFindPackageCommand::AppendToFoundProperty(bool found)
 {
-  std::string propertyValue;
-  const char *prop =
-      this->Makefile->GetCMakeInstance()->GetProperty(propertyName);
-  if (prop && *prop)
+  std::vector<std::string> foundContents;
+  const char *foundProp =
+             this->Makefile->GetCMakeInstance()->GetProperty("PACKAGES_FOUND");
+  if (foundProp && *foundProp)
     {
-    propertyValue = prop;
+    std::string tmp = foundProp;
 
-    std::vector<std::string> contents;
-    cmSystemTools::ExpandListArgument(propertyValue, contents, false);
-
-    bool alreadyInserted = false;
-    for(std::vector<std::string>::const_iterator it = contents.begin();
-      it != contents.end(); ++ it )
+    cmSystemTools::ExpandListArgument(tmp, foundContents, false);
+    std::vector<std::string>::iterator nameIt = std::find(
+                       foundContents.begin(), foundContents.end(), this->Name);
+    if(nameIt != foundContents.end())
       {
-      if (*it == this->Name)
-        {
-        alreadyInserted = true;
-        break;
-        }
+      foundContents.erase(nameIt);
       }
-    if (!alreadyInserted)
+    }
+
+  std::vector<std::string> notFoundContents;
+  const char *notFoundProp =
+         this->Makefile->GetCMakeInstance()->GetProperty("PACKAGES_NOT_FOUND");
+  if (notFoundProp && *notFoundProp)
+    {
+    std::string tmp = notFoundProp;
+
+    cmSystemTools::ExpandListArgument(tmp, notFoundContents, false);
+    std::vector<std::string>::iterator nameIt = std::find(
+                 notFoundContents.begin(), notFoundContents.end(), this->Name);
+    if(nameIt != notFoundContents.end())
       {
-      propertyValue += ";";
-      propertyValue += this->Name;
+      notFoundContents.erase(nameIt);
       }
     }
+
+  if(found)
+    {
+    foundContents.push_back(this->Name);
+    }
   else
     {
-    propertyValue = this->Name;
+    notFoundContents.push_back(this->Name);
+    }
+
+
+  std::string tmp;
+  const char* sep ="";
+  for(size_t i=0; i<foundContents.size(); i++)
+    {
+    tmp += sep;
+    tmp += foundContents[i];
+    sep = ";";
+    }
+
+  this->Makefile->GetCMakeInstance()->SetProperty("PACKAGES_FOUND",
+                                                  tmp.c_str());
+
+  tmp = "";
+  sep = "";
+  for(size_t i=0; i<notFoundContents.size(); i++)
+    {
+    tmp += sep;
+    tmp += notFoundContents[i];
+    sep = ";";
     }
-  this->Makefile->GetCMakeInstance()->SetProperty(propertyName,
-                                                  propertyValue.c_str());
- }
+  this->Makefile->GetCMakeInstance()->SetProperty("PACKAGES_NOT_FOUND",
+                                                  tmp.c_str());
+}
 
 //----------------------------------------------------------------------------
 void cmFindPackageCommand::AppendSuccessInformation()
@@ -1413,14 +1445,10 @@ void cmFindPackageCommand::AppendSuccessInformation()
 
   const char* upperResult = this->Makefile->GetDefinition(upperFound.c_str());
   const char* result = this->Makefile->GetDefinition(found.c_str());
-  if ((cmSystemTools::IsOn(result)) || (cmSystemTools::IsOn(upperResult)))
-    {
-    this->AppendToProperty("PACKAGES_FOUND");
-    }
-  else
-    {
-    this->AppendToProperty("PACKAGES_NOT_FOUND");
-    }
+  bool packageFound = ((cmSystemTools::IsOn(result))
+                                        || (cmSystemTools::IsOn(upperResult)));
+
+  this->AppendToFoundProperty(packageFound);
 
   // Record whether the find was quiet or not, so this can be used
   // e.g. in FeatureSummary.cmake
diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h
index edb70a6..c380122 100644
--- a/Source/cmFindPackageCommand.h
+++ b/Source/cmFindPackageCommand.h
@@ -69,7 +69,7 @@ protected:
   virtual void GenerateDocumentation();
 private:
   void AppendSuccessInformation();
-  void AppendToProperty(const char* propertyName);
+  void AppendToFoundProperty(bool found);
   void SetModuleVariables(const std::string& components);
   bool FindModule(bool& found);
   void AddFindDefinition(const char* var, const char* val);
diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx
index 42dd428..6e2e23d 100644
--- a/Source/cmGeneratorTarget.cxx
+++ b/Source/cmGeneratorTarget.cxx
@@ -39,17 +39,10 @@ void cmGeneratorTarget::ClassifySources()
     {
     cmSourceFile* sf = *si;
     std::string ext = cmSystemTools::LowerCase(sf->GetExtension());
-    cmTarget::SourceFileFlags tsFlags =
-      this->Target->GetTargetSourceFileFlags(sf);
     if(sf->GetCustomCommand())
       {
       this->CustomCommands.push_back(sf);
       }
-    else if(tsFlags.Type != cmTarget::SourceFileTypeNormal)
-      {
-      this->OSXContent.push_back(sf);
-      if(isObjLib) { badObjLib.push_back(sf); }
-      }
     else if(sf->GetPropertyAsBool("HEADER_FILE_ONLY"))
       {
       this->HeaderSources.push_back(sf);
diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h
index 3e50656..5c7578d 100644
--- a/Source/cmGeneratorTarget.h
+++ b/Source/cmGeneratorTarget.h
@@ -37,7 +37,6 @@ public:
   std::vector<cmSourceFile*> HeaderSources;
   std::vector<cmSourceFile*> ObjectSources;
   std::vector<cmSourceFile*> ExternalObjects;
-  std::vector<cmSourceFile*> OSXContent;
   std::vector<cmSourceFile*> IDLSources;
   std::string ModuleDefinitionFile;
 
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index b06cdb4..f883041 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -2474,3 +2474,16 @@ void cmGlobalGenerator::WriteSummary(cmTarget* target)
     cmSystemTools::RemoveFile(file.c_str());
     }
 }
+
+//----------------------------------------------------------------------------
+// static
+std::string cmGlobalGenerator::EscapeJSON(const std::string& s) {
+  std::string result;
+  for (std::string::size_type i = 0; i < s.size(); ++i) {
+    if (s[i] == '"' || s[i] == '\\') {
+      result += '\\';
+    }
+    result += s[i];
+  }
+  return result;
+}
diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h
index 5254b89..8535edc 100644
--- a/Source/cmGlobalGenerator.h
+++ b/Source/cmGlobalGenerator.h
@@ -280,6 +280,8 @@ public:
   /** Generate an <output>.rule file path for a given command output.  */
   virtual std::string GenerateRuleFile(std::string const& output) const;
 
+  static std::string EscapeJSON(const std::string& s);
+
 protected:
   typedef std::vector<cmLocalGenerator*> GeneratorVector;
   // for a project collect all its targets by following depend
diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx
index 9cbd502..0e89fab 100644
--- a/Source/cmGlobalNinjaGenerator.cxx
+++ b/Source/cmGlobalNinjaGenerator.cxx
@@ -341,6 +341,7 @@ cmGlobalNinjaGenerator::cmGlobalNinjaGenerator()
   : cmGlobalGenerator()
   , BuildFileStream(0)
   , RulesFileStream(0)
+  , CompileCommandsStream(0)
   , Rules()
   , AllDependencies()
 {
@@ -385,6 +386,12 @@ void cmGlobalNinjaGenerator::Generate()
   this->WriteTargetAliases(*this->BuildFileStream);
   this->WriteBuiltinTargets(*this->BuildFileStream);
 
+  if (cmSystemTools::GetErrorOccuredFlag()) {
+    this->RulesFileStream->setstate(std::ios_base::failbit);
+    this->BuildFileStream->setstate(std::ios_base::failbit);
+  }
+
+  this->CloseCompileCommandsStream();
   this->CloseRulesFileStream();
   this->CloseBuildFileStream();
 }
@@ -618,6 +625,46 @@ void cmGlobalNinjaGenerator::CloseRulesFileStream()
    }
 }
 
+void cmGlobalNinjaGenerator::AddCXXCompileCommand(
+                                      const std::string &commandLine,
+                                      const std::string &sourceFile)
+{
+  // Compute Ninja's build file path.
+  std::string buildFileDir =
+    this->GetCMakeInstance()->GetHomeOutputDirectory();
+  if (!this->CompileCommandsStream)
+    {
+    std::string buildFilePath = buildFileDir + "/compile_commands.json";
+
+    // Get a stream where to generate things.
+    this->CompileCommandsStream =
+      new cmGeneratedFileStream(buildFilePath.c_str());
+    *this->CompileCommandsStream << "[";
+    } else {
+    *this->CompileCommandsStream << "," << std::endl;
+    }
+
+  *this->CompileCommandsStream << "\n{\n"
+     << "  \"directory\": \""
+     << cmGlobalGenerator::EscapeJSON(buildFileDir) << "\",\n"
+     << "  \"command\": \""
+     << cmGlobalGenerator::EscapeJSON(commandLine) << "\",\n"
+     << "  \"file\": \""
+     << cmGlobalGenerator::EscapeJSON(sourceFile) << "\"\n"
+     << "}";
+}
+
+void cmGlobalNinjaGenerator::CloseCompileCommandsStream()
+{
+  if (this->CompileCommandsStream)
+    {
+    *this->CompileCommandsStream << "\n]";
+    delete this->CompileCommandsStream;
+    this->CompileCommandsStream = 0;
+    }
+
+}
+
 void cmGlobalNinjaGenerator::WriteDisclaimer(std::ostream& os)
 {
   os
@@ -754,6 +801,8 @@ void cmGlobalNinjaGenerator::WriteBuiltinTargets(std::ostream& os)
 
   this->WriteTargetAll(os);
   this->WriteTargetRebuildManifest(os);
+  this->WriteTargetClean(os);
+  this->WriteTargetHelp(os);
 }
 
 void cmGlobalNinjaGenerator::WriteTargetAll(std::ostream& os)
@@ -820,3 +869,43 @@ void cmGlobalNinjaGenerator::WriteTargetRebuildManifest(std::ostream& os)
                   implicitDeps,
                   cmNinjaDeps());
 }
+
+void cmGlobalNinjaGenerator::WriteTargetClean(std::ostream& os)
+{
+  WriteRule(*this->RulesFileStream,
+            "CLEAN",
+            "ninja -t clean",
+            "Cleaning all built files...",
+            "Rule for cleaning all built files.",
+            /*depfile=*/ "",
+            /*restat=*/ false,
+            /*generator=*/ false);
+  WriteBuild(os,
+             "Clean all the built files.",
+             "CLEAN",
+             /*outputs=*/ cmNinjaDeps(1, "clean"),
+             /*explicitDeps=*/ cmNinjaDeps(),
+             /*implicitDeps=*/ cmNinjaDeps(),
+             /*orderOnlyDeps=*/ cmNinjaDeps(),
+             /*variables=*/ cmNinjaVars());
+}
+
+void cmGlobalNinjaGenerator::WriteTargetHelp(std::ostream& os)
+{
+  WriteRule(*this->RulesFileStream,
+            "HELP",
+            "ninja -t targets",
+            "All primary targets available:",
+            "Rule for printing all primary targets available.",
+            /*depfile=*/ "",
+            /*restat=*/ false,
+            /*generator=*/ false);
+  WriteBuild(os,
+             "Print all primary targets available.",
+             "HELP",
+             /*outputs=*/ cmNinjaDeps(1, "help"),
+             /*explicitDeps=*/ cmNinjaDeps(),
+             /*implicitDeps=*/ cmNinjaDeps(),
+             /*orderOnlyDeps=*/ cmNinjaDeps(),
+             /*variables=*/ cmNinjaVars());
+}
diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h
index 3217581..7b6b9b7 100644
--- a/Source/cmGlobalNinjaGenerator.h
+++ b/Source/cmGlobalNinjaGenerator.h
@@ -213,6 +213,9 @@ public:
   cmGeneratedFileStream* GetRulesFileStream() const
   { return this->RulesFileStream; }
 
+  void AddCXXCompileCommand(const std::string &commandLine,
+                            const std::string &sourceFile);
+
   /**
    * Add a rule to the generated build system.
    * Call WriteRule() behind the scene but perform some check before like:
@@ -254,6 +257,8 @@ private:
   void OpenBuildFileStream();
   void CloseBuildFileStream();
 
+  void CloseCompileCommandsStream();
+
   void OpenRulesFileStream();
   void CloseRulesFileStream();
 
@@ -273,6 +278,8 @@ private:
   void WriteBuiltinTargets(std::ostream& os);
   void WriteTargetAll(std::ostream& os);
   void WriteTargetRebuildManifest(std::ostream& os);
+  void WriteTargetClean(std::ostream& os);
+  void WriteTargetHelp(std::ostream& os);
 
   /// Called when we have seen the given custom command.  Returns true
   /// if we has seen it before.
@@ -309,6 +316,7 @@ private:
   /// The file containing the rule statements. (The action attached to each
   /// edge of the compilation DAG).
   cmGeneratedFileStream* RulesFileStream;
+  cmGeneratedFileStream* CompileCommandsStream;
 
   /// The type used to store the set of rules added to the generated build
   /// system.
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index e63de9c..ebd8219 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -103,18 +103,6 @@ cmGlobalUnixMakefileGenerator3
     }
 }
 
-//----------------------------------------------------------------------------
-std::string EscapeJSON(const std::string& s) {
-  std::string result;
-  for (std::string::size_type i = 0; i < s.size(); ++i) {
-    if (s[i] == '"' || s[i] == '\\') {
-      result += '\\';
-    }
-    result += s[i];
-  }
-  return result;
-}
-
 void cmGlobalUnixMakefileGenerator3::Generate()
 {
   // first do superclass method
@@ -179,11 +167,14 @@ void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand(
     *this->CommandDatabase << "," << std::endl;
     }
   *this->CommandDatabase << "{" << std::endl
-      << "  \"directory\": \"" << EscapeJSON(workingDirectory) << "\","
+      << "  \"directory\": \""
+      << cmGlobalGenerator::EscapeJSON(workingDirectory) << "\","
       << std::endl
-      << "  \"command\": \"" << EscapeJSON(compileCommand) << "\","
+      << "  \"command\": \"" <<
+      cmGlobalGenerator::EscapeJSON(compileCommand) << "\","
       << std::endl
-      << "  \"file\": \"" << EscapeJSON(sourceFile) << "\""
+      << "  \"file\": \"" <<
+      cmGlobalGenerator::EscapeJSON(sourceFile) << "\""
       << std::endl << "}";
 }
 
diff --git a/Source/cmGlobalVisualStudio10Generator.cxx b/Source/cmGlobalVisualStudio10Generator.cxx
index 18a786d..947a1c9 100644
--- a/Source/cmGlobalVisualStudio10Generator.cxx
+++ b/Source/cmGlobalVisualStudio10Generator.cxx
@@ -278,3 +278,9 @@ void cmGlobalVisualStudio10Generator::PathTooLong(
     this->LongestSource.SourceRel = sfRel;
     }
 }
+
+//----------------------------------------------------------------------------
+bool cmGlobalVisualStudio10Generator::UseFolderProperty()
+{
+  return IsExpressEdition() ? false : cmGlobalGenerator::UseFolderProperty();
+}
diff --git a/Source/cmGlobalVisualStudio10Generator.h b/Source/cmGlobalVisualStudio10Generator.h
index 4236563..060cdff 100644
--- a/Source/cmGlobalVisualStudio10Generator.h
+++ b/Source/cmGlobalVisualStudio10Generator.h
@@ -88,6 +88,9 @@ protected:
 
   std::string PlatformToolset;
   bool ExpressEdition;
+
+  bool UseFolderProperty();
+
 private:
   struct LongestSourcePath
   {
diff --git a/Source/cmGlobalVisualStudio11ARMGenerator.cxx b/Source/cmGlobalVisualStudio11ARMGenerator.cxx
new file mode 100644
index 0000000..fef1aba
--- /dev/null
+++ b/Source/cmGlobalVisualStudio11ARMGenerator.cxx
@@ -0,0 +1,32 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#include "cmGlobalVisualStudio11ARMGenerator.h"
+#include "cmMakefile.h"
+#include "cmake.h"
+
+//----------------------------------------------------------------------------
+void cmGlobalVisualStudio11ARMGenerator
+::GetDocumentation(cmDocumentationEntry& entry) const
+{
+  entry.Name = this->GetName();
+  entry.Brief = "Generates Visual Studio 11 ARM project files.";
+  entry.Full = "";
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalVisualStudio11ARMGenerator
+::AddPlatformDefinitions(cmMakefile* mf)
+{
+  this->cmGlobalVisualStudio11Generator::AddPlatformDefinitions(mf);
+  mf->AddDefinition("MSVC_C_ARCHITECTURE_ID", "ARM");
+  mf->AddDefinition("MSVC_CXX_ARCHITECTURE_ID", "ARM");
+}
diff --git a/Source/cmGlobalVisualStudio11ARMGenerator.h b/Source/cmGlobalVisualStudio11ARMGenerator.h
new file mode 100644
index 0000000..77e1429
--- /dev/null
+++ b/Source/cmGlobalVisualStudio11ARMGenerator.h
@@ -0,0 +1,37 @@
+/*============================================================================
+  CMake - Cross Platform Makefile Generator
+  Copyright 2000-2011 Kitware, Inc., Insight Software Consortium
+
+  Distributed under the OSI-approved BSD License (the "License");
+  see accompanying file Copyright.txt for details.
+
+  This software is distributed WITHOUT ANY WARRANTY; without even the
+  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+  See the License for more information.
+============================================================================*/
+#ifndef cmGlobalVisualStudio11ARMGenerator_h
+#define cmGlobalVisualStudio11ARMGenerator_h
+
+#include "cmGlobalVisualStudio11Generator.h"
+
+class cmGlobalVisualStudio11ARMGenerator :
+  public cmGlobalVisualStudio11Generator
+{
+public:
+  cmGlobalVisualStudio11ARMGenerator() {}
+  static cmGlobalGenerator* New() {
+    return new cmGlobalVisualStudio11ARMGenerator; }
+
+  ///! Get the name for the generator.
+  virtual const char* GetName() const {
+    return cmGlobalVisualStudio11ARMGenerator::GetActualName();}
+  static const char* GetActualName() {return "Visual Studio 11 ARM";}
+
+  virtual const char* GetPlatformName() const {return "ARM";}
+
+  /** Get the documentation entry for this generator.  */
+  virtual void GetDocumentation(cmDocumentationEntry& entry) const;
+
+  virtual void AddPlatformDefinitions(cmMakefile* mf);
+};
+#endif
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 998843f..522f3da 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -723,6 +723,10 @@ GetSourcecodeValueFromFileExtension(const std::string& _ext,
     {
     sourcecode = "file.xib";
     }
+  else if(ext == "storyboard")
+    {
+    sourcecode = "file.storyboard";
+    }
   else if(ext == "mm")
     {
     sourcecode += ".cpp.objcpp";
diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx
index 4eed477..ffc0f35 100644
--- a/Source/cmIfCommand.cxx
+++ b/Source/cmIfCommand.cxx
@@ -74,6 +74,13 @@ IsFunctionBlocked(const cmListFileFunction& lff,
           {
           this->IsBlocking = this->HasRun;
           this->HasRun = true;
+
+          // if trace is enabled, print a (trivially) evaluated "else"
+          // statement
+          if(!this->IsBlocking && mf.GetCMakeInstance()->GetTrace())
+            {
+            mf.PrintCommandTrace(this->Functions[c]);
+            }
           }
         else if (scopeDepth == 0 && !cmSystemTools::Strucmp
                  (this->Functions[c].Name.c_str(),"elseif"))
@@ -88,6 +95,12 @@ IsFunctionBlocked(const cmListFileFunction& lff,
             cmMakefileCall stack_manager(&mf, this->Functions[c], status);
             static_cast<void>(stack_manager);
 
+            // if trace is enabled, print the evaluated "elseif" statement
+            if(mf.GetCMakeInstance()->GetTrace())
+              {
+              mf.PrintCommandTrace(this->Functions[c]);
+              }
+
             std::string errorString;
 
             std::vector<std::string> expandedArguments;
diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx
index c656487..4016734 100644
--- a/Source/cmInstallCommand.cxx
+++ b/Source/cmInstallCommand.cxx
@@ -23,25 +23,25 @@
 static cmInstallTargetGenerator* CreateInstallTargetGenerator(cmTarget& target,
      const cmInstallCommandArguments& args, bool impLib, bool forceOpt = false)
 {
-  return new cmInstallTargetGenerator(target, args.GetDestination().c_str(), 
-                        impLib, args.GetPermissions().c_str(), 
+  return new cmInstallTargetGenerator(target, args.GetDestination().c_str(),
+                        impLib, args.GetPermissions().c_str(),
                         args.GetConfigurations(), args.GetComponent().c_str(),
                         args.GetOptional() || forceOpt);
 }
 
 static cmInstallFilesGenerator* CreateInstallFilesGenerator(
-    const std::vector<std::string>& absFiles, 
+    const std::vector<std::string>& absFiles,
     const cmInstallCommandArguments& args, bool programs)
 {
-  return new cmInstallFilesGenerator(absFiles, args.GetDestination().c_str(), 
-                        programs, args.GetPermissions().c_str(), 
+  return new cmInstallFilesGenerator(absFiles, args.GetDestination().c_str(),
+                        programs, args.GetPermissions().c_str(),
                         args.GetConfigurations(), args.GetComponent().c_str(),
                         args.GetRename().c_str(), args.GetOptional());
 }
 
 
 // cmInstallCommand
-bool cmInstallCommand::InitialPass(std::vector<std::string> const& args, 
+bool cmInstallCommand::InitialPass(std::vector<std::string> const& args,
                                    cmExecutionStatus &)
 {
   // Allow calling with no arguments so that arguments may be built up
@@ -55,6 +55,13 @@ bool cmInstallCommand::InitialPass(std::vector<std::string> const& args,
   this->Makefile->GetLocalGenerator()
     ->GetGlobalGenerator()->EnableInstallTarget();
 
+  this->DefaultComponentName = this->Makefile->GetSafeDefinition(
+                                       "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
+  if (this->DefaultComponentName.empty())
+    {
+    this->DefaultComponentName = "Unspecified";
+    }
+
   // Switch among the command modes.
   if(args[0] == "SCRIPT")
     {
@@ -95,7 +102,7 @@ bool cmInstallCommand::InitialPass(std::vector<std::string> const& args,
 //----------------------------------------------------------------------------
 bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
 {
-  std::string component("Unspecified");
+  std::string component = this->DefaultComponentName;
   int componentCount = 0;
   bool doing_script = false;
   bool doing_code = false;
@@ -190,7 +197,7 @@ bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
 
 /*struct InstallPart
 {
-  InstallPart(cmCommandArgumentsHelper* helper, const char* key, 
+  InstallPart(cmCommandArgumentsHelper* helper, const char* key,
          cmCommandArgumentGroup* group);
   cmCAStringVector argVector;
   cmInstallCommandArguments args;
@@ -222,7 +229,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
   // ARCHIVE, RUNTIME etc. (see above)
   // These generic args also contain the targets and the export stuff
   std::vector<std::string> unknownArgs;
-  cmInstallCommandArguments genericArgs;
+  cmInstallCommandArguments genericArgs(this->DefaultComponentName);
   cmCAStringVector targetList(&genericArgs.Parser, "TARGETS");
   cmCAString exports(&genericArgs.Parser,"EXPORT", &genericArgs.ArgumentGroup);
   targetList.Follows(0);
@@ -230,16 +237,16 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
   genericArgs.Parse(&genericArgVector.GetVector(), &unknownArgs);
   bool success = genericArgs.Finalize();
 
-  cmInstallCommandArguments archiveArgs;
-  cmInstallCommandArguments libraryArgs;
-  cmInstallCommandArguments runtimeArgs;
-  cmInstallCommandArguments frameworkArgs;
-  cmInstallCommandArguments bundleArgs;
-  cmInstallCommandArguments privateHeaderArgs;
-  cmInstallCommandArguments publicHeaderArgs;
-  cmInstallCommandArguments resourceArgs;
+  cmInstallCommandArguments archiveArgs(this->DefaultComponentName);
+  cmInstallCommandArguments libraryArgs(this->DefaultComponentName);
+  cmInstallCommandArguments runtimeArgs(this->DefaultComponentName);
+  cmInstallCommandArguments frameworkArgs(this->DefaultComponentName);
+  cmInstallCommandArguments bundleArgs(this->DefaultComponentName);
+  cmInstallCommandArguments privateHeaderArgs(this->DefaultComponentName);
+  cmInstallCommandArguments publicHeaderArgs(this->DefaultComponentName);
+  cmInstallCommandArguments resourceArgs(this->DefaultComponentName);
 
-  // now parse the args for specific parts of the target (e.g. LIBRARY, 
+  // now parse the args for specific parts of the target (e.g. LIBRARY,
   // RUNTIME, ARCHIVE etc.
   archiveArgs.Parse      (&archiveArgVector.GetVector(),       &unknownArgs);
   libraryArgs.Parse      (&libraryArgVector.GetVector(),       &unknownArgs);
@@ -345,7 +352,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
                        this->Makefile->IsOn("CYGWIN") ||
                        this->Makefile->IsOn("MINGW"));
 
-  for(std::vector<std::string>::const_iterator 
+  for(std::vector<std::string>::const_iterator
       targetIt=targetList.GetVector().begin();
       targetIt!=targetList.GetVector().end();
       ++targetIt)
@@ -422,7 +429,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
       case cmTarget::SHARED_LIBRARY:
         {
         // Shared libraries are handled differently on DLL and non-DLL
-        // platforms.  All windows platforms are DLL platforms including 
+        // platforms.  All windows platforms are DLL platforms including
         // cygwin.  Currently no other platform is a DLL platform.
         if(dll_platform)
           {
@@ -436,13 +443,13 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
           if(!archiveArgs.GetDestination().empty())
             {
             // The import library uses the ARCHIVE properties.
-            archiveGenerator = CreateInstallTargetGenerator(target, 
+            archiveGenerator = CreateInstallTargetGenerator(target,
                                                             archiveArgs, true);
             }
           if(!runtimeArgs.GetDestination().empty())
             {
             // The DLL uses the RUNTIME properties.
-            runtimeGenerator = CreateInstallTargetGenerator(target, 
+            runtimeGenerator = CreateInstallTargetGenerator(target,
                                                            runtimeArgs, false);
             }
           if ((archiveGenerator==0) && (runtimeGenerator==0))
@@ -467,7 +474,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
             // Use the FRAMEWORK properties.
             if (!frameworkArgs.GetDestination().empty())
               {
-              frameworkGenerator = CreateInstallTargetGenerator(target, 
+              frameworkGenerator = CreateInstallTargetGenerator(target,
                                                          frameworkArgs, false);
               }
             else
@@ -484,7 +491,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
             // The shared library uses the LIBRARY properties.
             if (!libraryArgs.GetDestination().empty())
               {
-              libraryGenerator = CreateInstallTargetGenerator(target, 
+              libraryGenerator = CreateInstallTargetGenerator(target,
                                                            libraryArgs, false);
               libraryGenerator->SetNamelinkMode(namelinkMode);
               namelinkOnly =
@@ -507,7 +514,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         // Static libraries use ARCHIVE properties.
         if (!archiveArgs.GetDestination().empty())
           {
-          archiveGenerator = CreateInstallTargetGenerator(target, archiveArgs, 
+          archiveGenerator = CreateInstallTargetGenerator(target, archiveArgs,
                                                           false);
           }
         else
@@ -525,7 +532,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
         // Modules use LIBRARY properties.
         if (!libraryArgs.GetDestination().empty())
           {
-          libraryGenerator = CreateInstallTargetGenerator(target, libraryArgs, 
+          libraryGenerator = CreateInstallTargetGenerator(target, libraryArgs,
                                                           false);
           libraryGenerator->SetNamelinkMode(namelinkMode);
           namelinkOnly =
@@ -548,7 +555,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
           // Application bundles use the BUNDLE properties.
           if (!bundleArgs.GetDestination().empty())
             {
-            bundleGenerator = CreateInstallTargetGenerator(target, bundleArgs, 
+            bundleGenerator = CreateInstallTargetGenerator(target, bundleArgs,
                                                            false);
             }
           else if(!runtimeArgs.GetDestination().empty())
@@ -580,7 +587,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
           // Executables use the RUNTIME properties.
           if (!runtimeArgs.GetDestination().empty())
             {
-            runtimeGenerator = CreateInstallTargetGenerator(target, 
+            runtimeGenerator = CreateInstallTargetGenerator(target,
                                                            runtimeArgs, false);
             }
           else
@@ -600,7 +607,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
            target.IsExecutableWithExports())
           {
           // The import library uses the ARCHIVE properties.
-          archiveGenerator = CreateInstallTargetGenerator(target, 
+          archiveGenerator = CreateInstallTargetGenerator(target,
                                                       archiveArgs, true, true);
           }
         }
@@ -710,7 +717,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     installsRuntime = installsRuntime || runtimeGenerator != 0;
     installsFramework = installsFramework || frameworkGenerator != 0;
     installsBundle = installsBundle || bundleGenerator != 0;
-    installsPrivateHeader = installsPrivateHeader 
+    installsPrivateHeader = installsPrivateHeader
       || privateHeaderGenerator != 0;
     installsPublicHeader = installsPublicHeader || publicHeaderGenerator != 0;
     installsResource = installsResource || resourceGenerator;
@@ -729,7 +736,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
     if(!exports.GetString().empty() && !namelinkOnly)
       {
       this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
-        ->AddTargetToExports(exports.GetCString(), &target, 
+        ->AddTargetToExports(exports.GetCString(), &target,
                              archiveGenerator, runtimeGenerator,
                              libraryGenerator, frameworkGenerator,
                              bundleGenerator, publicHeaderGenerator);
@@ -788,7 +795,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
 {
   // This is the FILES mode.
   bool programs = (args[0] == "PROGRAMS");
-  cmInstallCommandArguments ica;
+  cmInstallCommandArguments ica(this->DefaultComponentName);
   cmCAStringVector files(&ica.Parser, programs ? "PROGRAMS" : "FILES");
   files.Follows(0);
   ica.ArgumentGroup.Follows(&files);
@@ -803,7 +810,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
     this->SetError(e.str().c_str());
     return false;
     }
-  
+
   // Check if there is something to do.
   if(files.GetVector().empty())
     {
@@ -865,7 +872,7 @@ cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
   std::string permissions_file;
   std::string permissions_dir;
   std::vector<std::string> configurations;
-  std::string component = "Unspecified";
+  std::string component = this->DefaultComponentName;
   std::string literal_args;
   for(unsigned int i=1; i < args.size(); ++i)
     {
@@ -1179,7 +1186,7 @@ cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
 bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
 {
   // This is the EXPORT mode.
-  cmInstallCommandArguments ica;
+  cmInstallCommandArguments ica(this->DefaultComponentName);
   cmCAString exp(&ica.Parser, "EXPORT");
   cmCAString name_space(&ica.Parser, "NAMESPACE", &ica.ArgumentGroup);
   cmCAString filename(&ica.Parser, "FILE", &ica.ArgumentGroup);
diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h
index 3403c38..bf9fd9e 100644
--- a/Source/cmInstallCommand.h
+++ b/Source/cmInstallCommand.h
@@ -337,10 +337,12 @@ private:
   bool HandleFilesMode(std::vector<std::string> const& args);
   bool HandleDirectoryMode(std::vector<std::string> const& args);
   bool HandleExportMode(std::vector<std::string> const& args);
-  bool MakeFilesFullPath(const char* modeName, 
+  bool MakeFilesFullPath(const char* modeName,
                          const std::vector<std::string>& relFiles,
                          std::vector<std::string>& absFiles);
   bool CheckCMP0006(bool& failure);
+
+  std::string DefaultComponentName;
 };
 
 
diff --git a/Source/cmInstallCommandArguments.cxx b/Source/cmInstallCommandArguments.cxx
index 13ef8ed..0ba21c7 100644
--- a/Source/cmInstallCommandArguments.cxx
+++ b/Source/cmInstallCommandArguments.cxx
@@ -23,7 +23,8 @@ const char* cmInstallCommandArguments::PermissionsTable[] =
 
 const std::string cmInstallCommandArguments::EmptyString;
 
-cmInstallCommandArguments::cmInstallCommandArguments()
+cmInstallCommandArguments::cmInstallCommandArguments(
+                                           const std::string& defaultComponent)
 :Parser()
 ,ArgumentGroup()
 ,Destination   (&Parser, "DESTINATION"   , &ArgumentGroup)
@@ -35,7 +36,9 @@ cmInstallCommandArguments::cmInstallCommandArguments()
 ,NamelinkOnly  (&Parser, "NAMELINK_ONLY" , &ArgumentGroup)
 ,NamelinkSkip  (&Parser, "NAMELINK_SKIP" , &ArgumentGroup)
 ,GenericArguments(0)
-{}
+{
+  this->Component.SetDefaultString(defaultComponent.c_str());
+}
 
 const std::string& cmInstallCommandArguments::GetDestination() const
 {
@@ -130,7 +133,7 @@ bool cmInstallCommandArguments::GetNamelinkSkip() const
   return false;
 }
 
-const std::vector<std::string>& 
+const std::vector<std::string>&
     cmInstallCommandArguments::GetConfigurations() const
 {
   if (!this->Configurations.GetVector().empty())
@@ -156,7 +159,7 @@ bool cmInstallCommandArguments::Finalize()
   return true;
 }
 
-void cmInstallCommandArguments::Parse(const std::vector<std::string>* args, 
+void cmInstallCommandArguments::Parse(const std::vector<std::string>* args,
                                       std::vector<std::string>* unconsumedArgs)
 {
   this->Parser.Parse(args, unconsumedArgs);
@@ -166,9 +169,9 @@ void cmInstallCommandArguments::Parse(const std::vector<std::string>* args,
 bool cmInstallCommandArguments::CheckPermissions()
 {
   this->PermissionsString = "";
-  for(std::vector<std::string>::const_iterator 
-      permIt = this->Permissions.GetVector().begin(); 
-      permIt != this->Permissions.GetVector().end(); 
+  for(std::vector<std::string>::const_iterator
+      permIt = this->Permissions.GetVector().begin();
+      permIt != this->Permissions.GetVector().end();
       ++permIt)
     {
     if (!this->CheckPermissions(*permIt, this->PermissionsString))
@@ -183,7 +186,7 @@ bool cmInstallCommandArguments::CheckPermissions(
                     const std::string& onePermission, std::string& permissions)
 {
   // Check the permission against the table.
-  for(const char** valid = cmInstallCommandArguments::PermissionsTable; 
+  for(const char** valid = cmInstallCommandArguments::PermissionsTable;
       *valid; ++valid)
     {
     if(onePermission == *valid)
diff --git a/Source/cmInstallCommandArguments.h b/Source/cmInstallCommandArguments.h
index 16033ce..321454a 100644
--- a/Source/cmInstallCommandArguments.h
+++ b/Source/cmInstallCommandArguments.h
@@ -19,10 +19,10 @@
 class cmInstallCommandArguments
 {
   public:
-    cmInstallCommandArguments();
-    void SetGenericArguments(cmInstallCommandArguments* args) 
+    cmInstallCommandArguments(const std::string& defaultComponent);
+    void SetGenericArguments(cmInstallCommandArguments* args)
                                                {this->GenericArguments = args;}
-    void Parse(const std::vector<std::string>* args, 
+    void Parse(const std::vector<std::string>* args,
                std::vector<std::string>* unconsumedArgs);
 
     // Compute destination path.and check permissions
@@ -37,14 +37,15 @@ class cmInstallCommandArguments
     bool GetNamelinkOnly() const;
     bool GetNamelinkSkip() const;
 
-    // once HandleDirectoryMode() is also switched to using 
+    // once HandleDirectoryMode() is also switched to using
     // cmInstallCommandArguments then these two functions can become non-static
     // private member functions without arguments
-    static bool CheckPermissions(const std::string& onePerm, 
+    static bool CheckPermissions(const std::string& onePerm,
                                  std::string& perm);
     cmCommandArgumentsHelper Parser;
     cmCommandArgumentGroup ArgumentGroup;
   private:
+    cmInstallCommandArguments(); // disabled
     cmCAString Destination;
     cmCAString Component;
     cmCAString Rename;
diff --git a/Source/cmInstallFilesCommand.cxx b/Source/cmInstallFilesCommand.cxx
index 0ec3030..cc62c4b 100644
--- a/Source/cmInstallFilesCommand.cxx
+++ b/Source/cmInstallFilesCommand.cxx
@@ -34,7 +34,7 @@ bool cmInstallFilesCommand
 
   if((args.size() > 1) && (args[1] == "FILES"))
     {
-    this->IsFilesForm = true;    
+    this->IsFilesForm = true;
     for(std::vector<std::string>::const_iterator s = args.begin()+2;
         s != args.end(); ++s)
       {
@@ -53,45 +53,46 @@ bool cmInstallFilesCommand
       this->FinalArgs.push_back(*s);
       }
     }
-  
+
   this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
-                       ->AddInstallComponent("Unspecified");
+                      ->AddInstallComponent(this->Makefile->GetSafeDefinition(
+                                      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
 
   return true;
 }
 
-void cmInstallFilesCommand::FinalPass() 
+void cmInstallFilesCommand::FinalPass()
 {
   // No final pass for "FILES" form of arguments.
   if(this->IsFilesForm)
     {
     return;
     }
-  
+
   std::string testf;
   std::string ext = this->FinalArgs[0];
-  
+
   // two different options
   if (this->FinalArgs.size() > 1)
     {
     // now put the files into the list
     std::vector<std::string>::iterator s = this->FinalArgs.begin();
     ++s;
-    // for each argument, get the files 
+    // for each argument, get the files
     for (;s != this->FinalArgs.end(); ++s)
       {
       // replace any variables
       std::string temps = *s;
       if (cmSystemTools::GetFilenamePath(temps).size() > 0)
         {
-          testf = cmSystemTools::GetFilenamePath(temps) + "/" + 
+          testf = cmSystemTools::GetFilenamePath(temps) + "/" +
             cmSystemTools::GetFilenameWithoutLastExtension(temps) + ext;
         }
       else
         {
           testf = cmSystemTools::GetFilenameWithoutLastExtension(temps) + ext;
         }
-      
+
       // add to the result
       this->Files.push_back(this->FindInstallSource(testf.c_str()));
       }
@@ -102,9 +103,9 @@ void cmInstallFilesCommand::FinalPass()
     std::string regex = this->FinalArgs[0].c_str();
     cmSystemTools::Glob(this->Makefile->GetCurrentDirectory(),
                         regex.c_str(), files);
-    
+
     std::vector<std::string>::iterator s = files.begin();
-    // for each argument, get the files 
+    // for each argument, get the files
     for (;s != files.end(); ++s)
       {
       this->Files.push_back(this->FindInstallSource(s->c_str()));
@@ -128,13 +129,14 @@ void cmInstallFilesCommand::CreateInstallGenerator() const
   // Use a file install generator.
   const char* no_permissions = "";
   const char* no_rename = "";
-  const char* no_component = "Unspecified";
+  std::string no_component = this->Makefile->GetSafeDefinition(
+                                       "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
   std::vector<std::string> no_configurations;
   this->Makefile->AddInstallGenerator(
     new cmInstallFilesGenerator(this->Files,
                                 destination.c_str(), false,
                                 no_permissions, no_configurations,
-                                no_component, no_rename));
+                                no_component.c_str(), no_rename));
 }
 
 
@@ -151,7 +153,7 @@ std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
     // This is a full path.
     return name;
     }
-  
+
   // This is a relative path.
   std::string tb = this->Makefile->GetCurrentOutputDirectory();
   tb += "/";
@@ -159,7 +161,7 @@ std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
   std::string ts = this->Makefile->GetCurrentDirectory();
   ts += "/";
   ts += name;
-  
+
   if(cmSystemTools::FileExists(tb.c_str()))
     {
     // The file exists in the binary tree.  Use it.
diff --git a/Source/cmInstallGenerator.cxx b/Source/cmInstallGenerator.cxx
index 807168e..3be2c2b 100644
--- a/Source/cmInstallGenerator.cxx
+++ b/Source/cmInstallGenerator.cxx
@@ -60,7 +60,7 @@ void cmInstallGenerator
   std::string dest = this->GetInstallDestination();
   if (cmSystemTools::FileIsFullPath(dest.c_str()))
      {
-     os << "list(APPEND CPACK_ABSOLUTE_DESTINATION_FILES\n";
+     os << "list(APPEND CMAKE_ABSOLUTE_DESTINATION_FILES\n";
      os << indent << " \"";
      for(std::vector<std::string>::const_iterator fi = files.begin();
                fi != files.end(); ++fi)
@@ -80,6 +80,16 @@ void cmInstallGenerator
                  }
              }
      os << "\")\n";
+     os << indent << "IF (CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
+     os << indent << indent << "message(WARNING \"ABSOLUTE path INSTALL "
+        << "DESTINATION : ${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";
+     os << indent << "ENDIF (CMAKE_WARN_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
+
+     os << indent << "IF (CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
+     os << indent << indent << "message(FATAL_ERROR \"ABSOLUTE path INSTALL "
+        << "DESTINATION forbidden (by caller): "
+        << "${CMAKE_ABSOLUTE_DESTINATION_FILES}\")\n";
+     os << indent << "ENDIF (CMAKE_ERROR_ON_ABSOLUTE_INSTALL_DESTINATION)\n";
      }
   os << "FILE(INSTALL DESTINATION \"" << dest << "\" TYPE " << stype.c_str();
   if(optional)
diff --git a/Source/cmInstallProgramsCommand.cxx b/Source/cmInstallProgramsCommand.cxx
index 7e6c9ce..3a0a322 100644
--- a/Source/cmInstallProgramsCommand.cxx
+++ b/Source/cmInstallProgramsCommand.cxx
@@ -31,26 +31,27 @@ bool cmInstallProgramsCommand
   for (++s;s != args.end(); ++s)
     {
     this->FinalArgs.push_back(*s);
-    }  
-  
+    }
+
   this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
-                       ->AddInstallComponent("Unspecified");
+                       ->AddInstallComponent(this->Makefile->GetSafeDefinition(
+                                      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
 
   return true;
 }
 
-void cmInstallProgramsCommand::FinalPass() 
+void cmInstallProgramsCommand::FinalPass()
 {
   bool files_mode = false;
   if(!this->FinalArgs.empty() && this->FinalArgs[0] == "FILES")
     {
     files_mode = true;
     }
-  
+
   // two different options
   if (this->FinalArgs.size() > 1 || files_mode)
     {
-    // for each argument, get the programs 
+    // for each argument, get the programs
     std::vector<std::string>::iterator s = this->FinalArgs.begin();
     if(files_mode)
       {
@@ -68,9 +69,9 @@ void cmInstallProgramsCommand::FinalPass()
     std::vector<std::string> programs;
     cmSystemTools::Glob(this->Makefile->GetCurrentDirectory(),
                         this->FinalArgs[0].c_str(), programs);
-    
+
     std::vector<std::string>::iterator s = programs.begin();
-    // for each argument, get the programs 
+    // for each argument, get the programs
     for (;s != programs.end(); ++s)
       {
       this->Files.push_back(this->FindInstallSource(s->c_str()));
@@ -89,13 +90,14 @@ void cmInstallProgramsCommand::FinalPass()
   // Use a file install generator.
   const char* no_permissions = "";
   const char* no_rename = "";
-  const char* no_component = "Unspecified";
+  std::string no_component = this->Makefile->GetSafeDefinition(
+                                       "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME");
   std::vector<std::string> no_configurations;
   this->Makefile->AddInstallGenerator(
     new cmInstallFilesGenerator(this->Files,
                                 destination.c_str(), true,
                                 no_permissions, no_configurations,
-                                no_component, no_rename));
+                                no_component.c_str(), no_rename));
 }
 
 /**
@@ -112,7 +114,7 @@ std::string cmInstallProgramsCommand
     // This is a full path.
     return name;
     }
-  
+
   // This is a relative path.
   std::string tb = this->Makefile->GetCurrentOutputDirectory();
   tb += "/";
@@ -120,7 +122,7 @@ std::string cmInstallProgramsCommand
   std::string ts = this->Makefile->GetCurrentDirectory();
   ts += "/";
   ts += name;
-  
+
   if(cmSystemTools::FileExists(tb.c_str()))
     {
     // The file exists in the binary tree.  Use it.
diff --git a/Source/cmInstallTargetsCommand.cxx b/Source/cmInstallTargetsCommand.cxx
index 27fc175..277ccea 100644
--- a/Source/cmInstallTargetsCommand.cxx
+++ b/Source/cmInstallTargetsCommand.cxx
@@ -58,7 +58,8 @@ bool cmInstallTargetsCommand
     }
 
   this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
-                       ->AddInstallComponent("Unspecified");
+                       ->AddInstallComponent(this->Makefile->GetSafeDefinition(
+                                      "CMAKE_INSTALL_DEFAULT_COMPONENT_NAME"));
 
   return true;
 }
diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx
index 6362d80..8265d72 100644
--- a/Source/cmLocalGenerator.cxx
+++ b/Source/cmLocalGenerator.cxx
@@ -1548,13 +1548,10 @@ void cmLocalGenerator::GetTargetFlags(std::string& linkLibs,
            target.GetName());
         return;
         }
-      std::string langVar = "CMAKE_";
-      langVar += linkLanguage;
-      std::string flagsVar = langVar + "_FLAGS";
+      this->AddLanguageFlags(flags, linkLanguage, buildType.c_str());
       std::string sharedFlagsVar = "CMAKE_SHARED_LIBRARY_";
       sharedFlagsVar += linkLanguage;
       sharedFlagsVar += "_FLAGS";
-      flags += this->Makefile->GetSafeDefinition(flagsVar.c_str());
       flags += " ";
       flags += this->Makefile->GetSafeDefinition(sharedFlagsVar.c_str());
       flags += " ";
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 0a709ae..a60896f 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -354,6 +354,22 @@ bool cmMakefile::GetBacktrace(cmListFileBacktrace& backtrace) const
 }
 
 //----------------------------------------------------------------------------
+void cmMakefile::PrintCommandTrace(const cmListFileFunction& lff)
+{
+  cmOStringStream msg;
+  msg << lff.FilePath << "(" << lff.Line << "):  ";
+  msg << lff.Name << "(";
+  for(std::vector<cmListFileArgument>::const_iterator i =
+        lff.Arguments.begin(); i != lff.Arguments.end(); ++i)
+    {
+    msg << i->Value;
+    msg << " ";
+    }
+  msg << ")";
+  cmSystemTools::Message(msg.str().c_str());
+}
+
+//----------------------------------------------------------------------------
 bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
                                 cmExecutionStatus &status)
 {
@@ -385,20 +401,10 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
        || pcmd->IsScriptable()))
 
       {
-      // if trace is one, print out invoke information
+      // if trace is enabled, print out invoke information
       if(this->GetCMakeInstance()->GetTrace())
         {
-        cmOStringStream msg;
-        msg << lff.FilePath << "(" << lff.Line << "):  ";
-        msg << lff.Name << "(";
-        for(std::vector<cmListFileArgument>::const_iterator i =
-              lff.Arguments.begin(); i != lff.Arguments.end(); ++i)
-          {
-          msg << i->Value;
-          msg << " ";
-          }
-        msg << ")";
-        cmSystemTools::Message(msg.str().c_str());
+        this->PrintCommandTrace(lff);
         }
       // Try invoking the command.
       if(!pcmd->InvokeInitialPass(lff.Arguments,status) ||
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 9fc64d6..8a0088b 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -701,6 +701,11 @@ public:
 #endif
 
   /**
+   * Print a command's invocation
+   */
+  void PrintCommandTrace(const cmListFileFunction& lff);
+
+  /**
    * Execute a single CMake command.  Returns true if the command
    * succeeded or false if it failed.
    */
diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx
index a0e0481..408f287 100644
--- a/Source/cmMakefileTargetGenerator.cxx
+++ b/Source/cmMakefileTargetGenerator.cxx
@@ -153,14 +153,8 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules()
         }
       }
     }
-  for(std::vector<cmSourceFile*>::const_iterator
-        si = this->GeneratorTarget->OSXContent.begin();
-      si != this->GeneratorTarget->OSXContent.end(); ++si)
-    {
-    cmTarget::SourceFileFlags tsFlags =
-      this->Target->GetTargetSourceFileFlags(*si);
-    this->WriteMacOSXContentRules(**si, tsFlags.MacFolder);
-    }
+  this->WriteMacOSXContentRules(this->GeneratorTarget->HeaderSources);
+  this->WriteMacOSXContentRules(this->GeneratorTarget->ExtraSources);
   for(std::vector<cmSourceFile*>::const_iterator
         si = this->GeneratorTarget->ExternalObjects.begin();
       si != this->GeneratorTarget->ExternalObjects.end(); ++si)
@@ -354,6 +348,22 @@ void cmMakefileTargetGenerator::WriteTargetLanguageFlags()
 }
 
 //----------------------------------------------------------------------------
+void cmMakefileTargetGenerator::WriteMacOSXContentRules(
+  std::vector<cmSourceFile*> const& sources)
+{
+  for(std::vector<cmSourceFile*>::const_iterator
+        si = sources.begin(); si != sources.end(); ++si)
+    {
+    cmTarget::SourceFileFlags tsFlags =
+      this->Target->GetTargetSourceFileFlags(*si);
+    if(tsFlags.Type != cmTarget::SourceFileTypeNormal)
+      {
+      this->WriteMacOSXContentRules(**si, tsFlags.MacFolder);
+      }
+    }
+}
+
+//----------------------------------------------------------------------------
 void cmMakefileTargetGenerator::WriteMacOSXContentRules(cmSourceFile& source,
                                                         const char* pkgloc)
 {
diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h
index e1e554b..36a1f68 100644
--- a/Source/cmMakefileTargetGenerator.h
+++ b/Source/cmMakefileTargetGenerator.h
@@ -73,6 +73,7 @@ protected:
   void WriteTargetDependRules();
 
   // write rules for Mac OS X Application Bundle content.
+  void WriteMacOSXContentRules(std::vector<cmSourceFile*> const& sources);
   void WriteMacOSXContentRules(cmSourceFile& source, const char* pkgloc);
 
   // write the rules for an object
diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx
index 63ba58d..8b86a98 100644
--- a/Source/cmNinjaNormalTargetGenerator.cxx
+++ b/Source/cmNinjaNormalTargetGenerator.cxx
@@ -193,12 +193,13 @@ cmNinjaNormalTargetGenerator
     vars.LinkFlags = "$LINK_FLAGS";
 
     std::string langFlags;
-    this->GetLocalGenerator()->AddLanguageFlags(langFlags,
-                                                this->TargetLinkLanguage,
-                                                this->GetConfigName());
-    if (targetType != cmTarget::EXECUTABLE)
+    if (targetType != cmTarget::EXECUTABLE) {
+      this->GetLocalGenerator()->AddLanguageFlags(langFlags,
+                                                  this->TargetLinkLanguage,
+                                                  this->GetConfigName());
       langFlags += " $ARCH_FLAGS";
-    vars.LanguageCompileFlags = langFlags.c_str();
+      vars.LanguageCompileFlags = langFlags.c_str();
+    }
 
     // Rule for linking library.
     std::vector<std::string> linkCmds = this->ComputeLinkCmd();
diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx
index c6469f2..e419a4d 100644
--- a/Source/cmNinjaTargetGenerator.cxx
+++ b/Source/cmNinjaTargetGenerator.cxx
@@ -396,7 +396,6 @@ cmNinjaTargetGenerator
      cmCustomCommand const* cc = (*si)->GetCustomCommand();
      this->GetLocalGenerator()->AddCustomCommandTarget(cc, this->GetTarget());
      }
-  // TODO: this->GeneratorTarget->OSXContent
   for(std::vector<cmSourceFile*>::const_iterator
         si = this->GeneratorTarget->ExternalObjects.begin();
       si != this->GeneratorTarget->ExternalObjects.end(); ++si)
@@ -488,6 +487,39 @@ cmNinjaTargetGenerator
   vars["TARGET_PDB"] = this->GetLocalGenerator()->ConvertToOutputFormat(
     this->GetTargetPDB().c_str(), cmLocalGenerator::SHELL);
 
+  if(this->Makefile->IsOn("CMAKE_EXPORT_COMPILE_COMMANDS"))
+    {
+    cmLocalGenerator::RuleVariables compileObjectVars;
+    std::string lang = language;
+    compileObjectVars.Language = lang.c_str();
+    std::string escapedSourceFileName =
+      this->LocalGenerator->ConvertToOutputFormat(
+        sourceFileName.c_str(), cmLocalGenerator::SHELL);
+    compileObjectVars.Source = escapedSourceFileName.c_str();
+    compileObjectVars.Object = objectFileName.c_str();
+    compileObjectVars.Flags = vars["FLAGS"].c_str();
+    compileObjectVars.Defines = vars["DEFINES"].c_str();
+
+    // Rule for compiling object file.
+    std::string compileCmdVar = "CMAKE_";
+    compileCmdVar += language;
+    compileCmdVar += "_COMPILE_OBJECT";
+    std::string compileCmd =
+      this->GetMakefile()->GetRequiredDefinition(compileCmdVar.c_str());
+    std::vector<std::string> compileCmds;
+    cmSystemTools::ExpandListArgument(compileCmd, compileCmds);
+
+    for (std::vector<std::string>::iterator i = compileCmds.begin();
+        i != compileCmds.end(); ++i)
+      this->GetLocalGenerator()->ExpandRuleVariables(*i, compileObjectVars);
+
+    std::string cmdLine =
+      this->GetLocalGenerator()->BuildCommandLine(compileCmds);
+
+    this->GetGlobalGenerator()->AddCXXCompileCommand(cmdLine,
+                                                     sourceFileName);
+    }
+
   cmGlobalNinjaGenerator::WriteBuild(this->GetBuildFileStream(),
                                      comment,
                                      rule,
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 4789197..c5ef9ff 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -700,9 +700,9 @@ void cmTarget::DefineProperties(cmake *cm)
      "Setting this property tells CMake what imported configurations are "
      "suitable for use when building the <CONFIG> configuration.  "
      "The first configuration in the list found to be provided by the "
-     "imported target is selected.  If no matching configurations are "
-     "available the imported target is considered to be not found.  "
-     "This property is ignored for non-imported targets.",
+     "imported target is selected.  If this property is set and no matching "
+     "configurations are available, then the imported target is considered "
+     "to be not found.  This property is ignored for non-imported targets.",
      false /* TODO: make this chained */ );
 
   cm->DefineProperty
@@ -832,7 +832,7 @@ void cmTarget::DefineProperties(cmake *cm)
      "plugins. If you use it on normal shared libraries which other targets "
      "link against, on some platforms a linker will insert a full path to "
      "the library (as specified at link time) into the dynamic section of "
-     "the dependant binary. Therefore, once installed, dynamic linker may "
+     "the dependent binary. Therefore, once installed, dynamic loader may "
      "eventually fail to locate the library for the binary.");
 
   cm->DefineProperty
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 846aef5..2ffff42 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -70,6 +70,7 @@
 #    include "cmGlobalVisualStudio10Win64Generator.h"
 #    include "cmGlobalVisualStudio11Generator.h"
 #    include "cmGlobalVisualStudio11Win64Generator.h"
+#    include "cmGlobalVisualStudio11ARMGenerator.h"
 #    include "cmGlobalVisualStudio8Win64Generator.h"
 #    include "cmGlobalBorlandMakefileGenerator.h"
 #    include "cmGlobalNMakeMakefileGenerator.h"
@@ -2569,6 +2570,8 @@ void cmake::AddDefaultGenerators()
     &cmGlobalVisualStudio11Generator::New;
   this->Generators[cmGlobalVisualStudio11Win64Generator::GetActualName()] =
     &cmGlobalVisualStudio11Win64Generator::New;
+  this->Generators[cmGlobalVisualStudio11ARMGenerator::GetActualName()] =
+    &cmGlobalVisualStudio11ARMGenerator::New;
   this->Generators[cmGlobalVisualStudio71Generator::GetActualName()] =
     &cmGlobalVisualStudio71Generator::New;
   this->Generators[cmGlobalVisualStudio8Generator::GetActualName()] =
diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx
index 8ab580f..66850e9 100644
--- a/Source/kwsys/SystemTools.cxx
+++ b/Source/kwsys/SystemTools.cxx
@@ -81,11 +81,7 @@
 #endif
 
 #if !KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H
-# if defined(_WIN32)
-extern __declspec(dllimport) char **environ;
-# else
 extern char **environ;
-# endif
 #endif
 
 #ifdef __CYGWIN__
diff --git a/Source/kwsys/hashtable.hxx.in b/Source/kwsys/hashtable.hxx.in
index db52fc8..c835503 100644
--- a/Source/kwsys/hashtable.hxx.in
+++ b/Source/kwsys/hashtable.hxx.in
@@ -394,7 +394,7 @@ enum { _stl_num_primes = 31 };
 
 // create a function with a static local to that function that returns
 // the static
-inline const unsigned long* get_stl_prime_list() {
+static inline const unsigned long* get_stl_prime_list() {
 
 static const unsigned long _stl_prime_list[_stl_num_primes] =
 {