Source/cmDepends.cxx - third_party/cmake - Git at Google

 /*============================================================================
   CMake - Cross Platform Makefile Generator
   Copyright 2000-2009 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 "cmDepends.h"

 #include "cmLocalGenerator.h"
 #include "cmMakefile.h"
 #include "cmGeneratedFileStream.h"
 #include "cmSystemTools.h"
 #include "cmFileTimeComparison.h"
 #include <string.h>
 #include <cmsys/FStream.hxx>

 //----------------------------------------------------------------------------
 cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir):
   CompileDirectory(),
   LocalGenerator(lg),
   Verbose(false),
   FileComparison(0),
   TargetDirectory(targetDir),
   MaxPath(16384),
   Dependee(new char[MaxPath]),
   Depender(new char[MaxPath])
 {
 }

 //----------------------------------------------------------------------------
 cmDepends::~cmDepends()
 {
   delete [] this->Dependee;
   delete [] this->Depender;
 }

 //----------------------------------------------------------------------------
 bool cmDepends::Write(std::ostream &makeDepends,
                       std::ostream &internalDepends)
 {
   // Lookup the set of sources to scan.
   std::string srcLang = "CMAKE_DEPENDS_CHECK_";
   srcLang += this->Language;
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
   const char* srcStr = mf->GetSafeDefinition(srcLang.c_str());
   std::vector<std::string> pairs;
   cmSystemTools::ExpandListArgument(srcStr, pairs);

   std::map<std::string, std::set<std::string> > dependencies;
   for(std::vector<std::string>::iterator si = pairs.begin();
       si != pairs.end();)
     {
     // Get the source and object file.
     std::string const& src = *si++;
     if(si == pairs.end()) { break; }
     std::string obj = *si++;

     // Make sure the object file is relative to the top of the build tree.
     obj = this->LocalGenerator->Convert(obj.c_str(),
                                         cmLocalGenerator::HOME_OUTPUT,
                                         cmLocalGenerator::MAKEFILE);
     dependencies[obj].insert(src);
     }
   for(std::map<std::string, std::set<std::string> >::const_iterator
       it = dependencies.begin(); it != dependencies.end(); ++it)
     {

     // Write the dependencies for this pair.
     if(!this->WriteDependencies(it->second, it->first,
                                 makeDepends, internalDepends))
       {
       return false;
       }
     }

   return this->Finalize(makeDepends, internalDepends);
 }

 //----------------------------------------------------------------------------
 bool cmDepends::Finalize(std::ostream&,
                          std::ostream&)
 {
   return true;
 }

 //----------------------------------------------------------------------------
 bool cmDepends::Check(const char *makeFile, const char *internalFile,
                       std::map<std::string, DependencyVector>& validDeps)
 {
   // Dependency checks must be done in proper working directory.
   std::string oldcwd = ".";
   if(this->CompileDirectory != ".")
     {
     // Get the CWD but do not call CollapseFullPath because
     // we only need it to cd back, and the form does not matter
     oldcwd = cmSystemTools::GetCurrentWorkingDirectory(false);
     cmSystemTools::ChangeDirectory(this->CompileDirectory.c_str());
     }

   // Check whether dependencies must be regenerated.
   bool okay = true;
   cmsys::ifstream fin(internalFile);
   if(!(fin && this->CheckDependencies(fin, internalFile, validDeps)))
     {
     // Clear all dependencies so they will be regenerated.
     this->Clear(makeFile);
     cmSystemTools::RemoveFile(internalFile);
     okay = false;
     }

   // Restore working directory.
   if(oldcwd != ".")
     {
     cmSystemTools::ChangeDirectory(oldcwd.c_str());
     }

   return okay;
 }

 //----------------------------------------------------------------------------
 void cmDepends::Clear(const char *file)
 {
   // Print verbose output.
   if(this->Verbose)
     {
     cmOStringStream msg;
     msg << "Clearing dependencies in \"" << file << "\"." << std::endl;
     cmSystemTools::Stdout(msg.str().c_str());
     }

   // Write an empty dependency file.
   cmGeneratedFileStream depFileStream(file);
   depFileStream
     << "# Empty dependencies file\n"
     << "# This may be replaced when dependencies are built." << std::endl;
 }

 //----------------------------------------------------------------------------
 bool cmDepends::WriteDependencies(
     const std::set<std::string>&, const std::string&,
     std::ostream&, std::ostream&)
 {
   // This should be implemented by the subclass.
   return false;
 }

 //----------------------------------------------------------------------------
 bool cmDepends::CheckDependencies(std::istream& internalDepends,
                                   const char* internalDependsFileName,
                             std::map<std::string, DependencyVector>& validDeps)
 {
   // Parse dependencies from the stream.  If any dependee is missing
   // or newer than the depender then dependencies should be
   // regenerated.
   bool okay = true;
   bool dependerExists = false;
   DependencyVector* currentDependencies = 0;

   while(internalDepends.getline(this->Dependee, this->MaxPath))
     {
     if ( this->Dependee[0] == 0 || this->Dependee[0] == '#' ||
          this->Dependee[0] == '\r' )
       {
       continue;
       }
     size_t len = internalDepends.gcount()-1;
     if ( this->Dependee[len-1] == '\r' )
       {
       len --;
       this->Dependee[len] = 0;
       }
     if ( this->Dependee[0] != ' ' )
       {
       memcpy(this->Depender, this->Dependee, len+1);
       // Calling FileExists() for the depender here saves in many cases 50%
       // of the calls to FileExists() further down in the loop. E.g. for
       // kdelibs/khtml this reduces the number of calls from 184k down to 92k,
       // or the time for cmake -E cmake_depends from 0.3 s down to 0.21 s.
       dependerExists = cmSystemTools::FileExists(this->Depender);
       // If we erase validDeps[this->Depender] by overwriting it with an empty
       // vector, we lose dependencies for dependers that have multiple
       // entries. No need to initialize the entry, std::map will do so on first
       // access.
       currentDependencies = &validDeps[this->Depender];
       continue;
       }
     /*
     // Parse the dependency line.
     if(!this->ParseDependency(line.c_str()))
       {
       continue;
       }
       */

     // Dependencies must be regenerated
     // * if the dependee does not exist
     // * if the depender exists and is older than the dependee.
     // * if the depender does not exist, but the dependee is newer than the
     //   depends file
     bool regenerate = false;
     const char* dependee = this->Dependee+1;
     const char* depender = this->Depender;
     if (currentDependencies != 0)
       {
       currentDependencies->push_back(dependee);
       }

     if(!cmSystemTools::FileExists(dependee))
       {
       // The dependee does not exist.
       regenerate = true;

       // Print verbose output.
       if(this->Verbose)
         {
         cmOStringStream msg;
         msg << "Dependee \"" << dependee
             << "\" does not exist for depender \""
             << depender << "\"." << std::endl;
         cmSystemTools::Stdout(msg.str().c_str());
         }
       }
     else
       {
       if(dependerExists)
         {
         // The dependee and depender both exist.  Compare file times.
         int result = 0;
         if((!this->FileComparison->FileTimeCompare(depender, dependee,
                                               &result) || result < 0))
           {
           // The depender is older than the dependee.
           regenerate = true;

           // Print verbose output.
           if(this->Verbose)
             {
             cmOStringStream msg;
             msg << "Dependee \"" << dependee
                 << "\" is newer than depender \""
                 << depender << "\"." << std::endl;
             cmSystemTools::Stdout(msg.str().c_str());
             }
           }
         }
       else
         {
         // The dependee exists, but the depender doesn't. Regenerate if the
         // internalDepends file is older than the dependee.
         int result = 0;
         if((!this->FileComparison->FileTimeCompare(internalDependsFileName,
                                              dependee, &result) || result < 0))
           {
           // The depends-file is older than the dependee.
           regenerate = true;

           // Print verbose output.
           if(this->Verbose)
             {
             cmOStringStream msg;
             msg << "Dependee \"" << dependee
                 << "\" is newer than depends file \""
                 << internalDependsFileName << "\"." << std::endl;
             cmSystemTools::Stdout(msg.str().c_str());
             }
           }
         }
       }
     if(regenerate)
       {
       // Dependencies must be regenerated.
       okay = false;

       // Remove the information of this depender from the map, it needs
       // to be rescanned
       if (currentDependencies != 0)
         {
         validDeps.erase(this->Depender);
         currentDependencies = 0;
         }

       // Remove the depender to be sure it is rebuilt.
       if (dependerExists)
         {
         cmSystemTools::RemoveFile(depender);
         dependerExists = false;
         }
       }
     }

   return okay;
 }

 //----------------------------------------------------------------------------
 void cmDepends::SetIncludePathFromLanguage(const char* lang)
 {
   // Look for the new per "TARGET_" variant first:
   const char * includePath = 0;
   std::string includePathVar = "CMAKE_";
   includePathVar += lang;
   includePathVar += "_TARGET_INCLUDE_PATH";
   cmMakefile* mf = this->LocalGenerator->GetMakefile();
   includePath = mf->GetDefinition(includePathVar.c_str());
   if(includePath)
     {
     cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
     }
   else
     {
     // Fallback to the old directory level variable if no per-target var:
     includePathVar = "CMAKE_";
     includePathVar += lang;
     includePathVar += "_INCLUDE_PATH";
     includePath = mf->GetDefinition(includePathVar.c_str());
     if(includePath)
       {
       cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
       }
     }
 }
	/*============================================================================
	CMake - Cross Platform Makefile Generator
	Copyright 2000-2009 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 "cmDepends.h"

	#include "cmLocalGenerator.h"
	#include "cmMakefile.h"
	#include "cmGeneratedFileStream.h"
	#include "cmSystemTools.h"
	#include "cmFileTimeComparison.h"
	#include <string.h>
	#include <cmsys/FStream.hxx>

	//----------------------------------------------------------------------------
	cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir):
	CompileDirectory(),
	LocalGenerator(lg),
	Verbose(false),
	FileComparison(0),
	TargetDirectory(targetDir),
	MaxPath(16384),
	Dependee(new char[MaxPath]),
	Depender(new char[MaxPath])
	{
	}

	//----------------------------------------------------------------------------
	cmDepends::~cmDepends()
	{
	delete [] this->Dependee;
	delete [] this->Depender;
	}

	//----------------------------------------------------------------------------
	bool cmDepends::Write(std::ostream &makeDepends,
	std::ostream &internalDepends)
	{
	// Lookup the set of sources to scan.
	std::string srcLang = "CMAKE_DEPENDS_CHECK_";
	srcLang += this->Language;
	cmMakefile* mf = this->LocalGenerator->GetMakefile();
	const char* srcStr = mf->GetSafeDefinition(srcLang.c_str());
	std::vector<std::string> pairs;
	cmSystemTools::ExpandListArgument(srcStr, pairs);

	std::map<std::string, std::set<std::string> > dependencies;
	for(std::vector<std::string>::iterator si = pairs.begin();
	si != pairs.end();)
	{
	// Get the source and object file.
	std::string const& src = *si++;
	if(si == pairs.end()) { break; }
	std::string obj = *si++;

	// Make sure the object file is relative to the top of the build tree.
	obj = this->LocalGenerator->Convert(obj.c_str(),
	cmLocalGenerator::HOME_OUTPUT,
	cmLocalGenerator::MAKEFILE);
	dependencies[obj].insert(src);
	}
	for(std::map<std::string, std::set<std::string> >::const_iterator
	it = dependencies.begin(); it != dependencies.end(); ++it)
	{

	// Write the dependencies for this pair.
	if(!this->WriteDependencies(it->second, it->first,
	makeDepends, internalDepends))
	{
	return false;
	}
	}

	return this->Finalize(makeDepends, internalDepends);
	}

	//----------------------------------------------------------------------------
	bool cmDepends::Finalize(std::ostream&,
	std::ostream&)
	{
	return true;
	}

	//----------------------------------------------------------------------------
	bool cmDepends::Check(const char makeFile, const char internalFile,
	std::map<std::string, DependencyVector>& validDeps)
	{
	// Dependency checks must be done in proper working directory.
	std::string oldcwd = ".";
	if(this->CompileDirectory != ".")
	{
	// Get the CWD but do not call CollapseFullPath because
	// we only need it to cd back, and the form does not matter
	oldcwd = cmSystemTools::GetCurrentWorkingDirectory(false);
	cmSystemTools::ChangeDirectory(this->CompileDirectory.c_str());
	}

	// Check whether dependencies must be regenerated.
	bool okay = true;
	cmsys::ifstream fin(internalFile);
	if(!(fin && this->CheckDependencies(fin, internalFile, validDeps)))
	{
	// Clear all dependencies so they will be regenerated.
	this->Clear(makeFile);
	cmSystemTools::RemoveFile(internalFile);
	okay = false;
	}

	// Restore working directory.
	if(oldcwd != ".")
	{
	cmSystemTools::ChangeDirectory(oldcwd.c_str());
	}

	return okay;
	}

	//----------------------------------------------------------------------------
	void cmDepends::Clear(const char *file)
	{
	// Print verbose output.
	if(this->Verbose)
	{
	cmOStringStream msg;
	msg << "Clearing dependencies in \"" << file << "\"." << std::endl;
	cmSystemTools::Stdout(msg.str().c_str());
	}

	// Write an empty dependency file.
	cmGeneratedFileStream depFileStream(file);
	depFileStream
	<< "# Empty dependencies file\n"
	<< "# This may be replaced when dependencies are built." << std::endl;
	}

	//----------------------------------------------------------------------------
	bool cmDepends::WriteDependencies(
	const std::set<std::string>&, const std::string&,
	std::ostream&, std::ostream&)
	{
	// This should be implemented by the subclass.
	return false;
	}

	//----------------------------------------------------------------------------
	bool cmDepends::CheckDependencies(std::istream& internalDepends,
	const char* internalDependsFileName,
	std::map<std::string, DependencyVector>& validDeps)
	{
	// Parse dependencies from the stream. If any dependee is missing
	// or newer than the depender then dependencies should be
	// regenerated.
	bool okay = true;
	bool dependerExists = false;
	DependencyVector* currentDependencies = 0;

	while(internalDepends.getline(this->Dependee, this->MaxPath))
	{
	if ( this->Dependee[0] == 0 \|\| this->Dependee[0] == '#' \|\|
	this->Dependee[0] == '\r' )
	{
	continue;
	}
	size_t len = internalDepends.gcount()-1;
	if ( this->Dependee[len-1] == '\r' )
	{
	len --;
	this->Dependee[len] = 0;
	}
	if ( this->Dependee[0] != ' ' )
	{
	memcpy(this->Depender, this->Dependee, len+1);
	// Calling FileExists() for the depender here saves in many cases 50%
	// of the calls to FileExists() further down in the loop. E.g. for
	// kdelibs/khtml this reduces the number of calls from 184k down to 92k,
	// or the time for cmake -E cmake_depends from 0.3 s down to 0.21 s.
	dependerExists = cmSystemTools::FileExists(this->Depender);
	// If we erase validDeps[this->Depender] by overwriting it with an empty
	// vector, we lose dependencies for dependers that have multiple
	// entries. No need to initialize the entry, std::map will do so on first
	// access.
	currentDependencies = &validDeps[this->Depender];
	continue;
	}
	/*
	// Parse the dependency line.
	if(!this->ParseDependency(line.c_str()))
	{
	continue;
	}
	*/

	// Dependencies must be regenerated
	// * if the dependee does not exist
	// * if the depender exists and is older than the dependee.
	// * if the depender does not exist, but the dependee is newer than the
	// depends file
	bool regenerate = false;
	const char* dependee = this->Dependee+1;
	const char* depender = this->Depender;
	if (currentDependencies != 0)
	{
	currentDependencies->push_back(dependee);
	}

	if(!cmSystemTools::FileExists(dependee))
	{
	// The dependee does not exist.
	regenerate = true;

	// Print verbose output.
	if(this->Verbose)
	{
	cmOStringStream msg;
	msg << "Dependee \"" << dependee
	<< "\" does not exist for depender \""
	<< depender << "\"." << std::endl;
	cmSystemTools::Stdout(msg.str().c_str());
	}
	}
	else
	{
	if(dependerExists)
	{
	// The dependee and depender both exist. Compare file times.
	int result = 0;
	if((!this->FileComparison->FileTimeCompare(depender, dependee,
	&result) \|\| result < 0))
	{
	// The depender is older than the dependee.
	regenerate = true;

	// Print verbose output.
	if(this->Verbose)
	{
	cmOStringStream msg;
	msg << "Dependee \"" << dependee
	<< "\" is newer than depender \""
	<< depender << "\"." << std::endl;
	cmSystemTools::Stdout(msg.str().c_str());
	}
	}
	}
	else
	{
	// The dependee exists, but the depender doesn't. Regenerate if the
	// internalDepends file is older than the dependee.
	int result = 0;
	if((!this->FileComparison->FileTimeCompare(internalDependsFileName,
	dependee, &result) \|\| result < 0))
	{
	// The depends-file is older than the dependee.
	regenerate = true;

	// Print verbose output.
	if(this->Verbose)
	{
	cmOStringStream msg;
	msg << "Dependee \"" << dependee
	<< "\" is newer than depends file \""
	<< internalDependsFileName << "\"." << std::endl;
	cmSystemTools::Stdout(msg.str().c_str());
	}
	}
	}
	}
	if(regenerate)
	{
	// Dependencies must be regenerated.
	okay = false;

	// Remove the information of this depender from the map, it needs
	// to be rescanned
	if (currentDependencies != 0)
	{
	validDeps.erase(this->Depender);
	currentDependencies = 0;
	}

	// Remove the depender to be sure it is rebuilt.
	if (dependerExists)
	{
	cmSystemTools::RemoveFile(depender);
	dependerExists = false;
	}
	}
	}

	return okay;
	}

	//----------------------------------------------------------------------------
	void cmDepends::SetIncludePathFromLanguage(const char* lang)
	{
	// Look for the new per "TARGET_" variant first:
	const char * includePath = 0;
	std::string includePathVar = "CMAKE_";
	includePathVar += lang;
	includePathVar += "_TARGET_INCLUDE_PATH";
	cmMakefile* mf = this->LocalGenerator->GetMakefile();
	includePath = mf->GetDefinition(includePathVar.c_str());
	if(includePath)
	{
	cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
	}
	else
	{
	// Fallback to the old directory level variable if no per-target var:
	includePathVar = "CMAKE_";
	includePathVar += lang;
	includePathVar += "_INCLUDE_PATH";
	includePath = mf->GetDefinition(includePathVar.c_str());
	if(includePath)
	{
	cmSystemTools::ExpandListArgument(includePath, this->IncludePath);
	}
	}
	}