Source/cmOutputRequiredFilesCommand.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 "cmOutputRequiredFilesCommand.h"
 #include "cmAlgorithms.h"
 #include <cmsys/FStream.hxx>

 /** \class cmDependInformation
  * \brief Store dependency information for a single source file.
  *
  * This structure stores the depend information for a single source file.
  */
 class cmDependInformation
 {
 public:
   /**
    * Construct with dependency generation marked not done; instance
    * not placed in cmMakefile's list.
    */
   cmDependInformation(): DependDone(false), SourceFile(0) {}

   /**
    * The set of files on which this one depends.
    */
   typedef std::set<cmDependInformation*> DependencySetType;
   DependencySetType DependencySet;

   /**
    * This flag indicates whether dependency checking has been
    * performed for this file.
    */
   bool DependDone;

   /**
    * If this object corresponds to a cmSourceFile instance, this points
    * to it.
    */
   const cmSourceFile *SourceFile;

   /**
    * Full path to this file.
    */
   std::string FullPath;

   /**
    * Full path not including file name.
    */
   std::string PathOnly;

   /**
    * Name used to #include this file.
    */
   std::string IncludeName;

   /**
    * This method adds the dependencies of another file to this one.
    */
   void AddDependencies(cmDependInformation* info)
   {
   if(this != info)
     {
     this->DependencySet.insert(info);
     }
   }
 };

 class cmLBDepend
 {
 public:
   /**
    * Construct the object with verbose turned off.
    */
   cmLBDepend()
   {
     this->Verbose = false;
     this->IncludeFileRegularExpression.compile("^.*$");
     this->ComplainFileRegularExpression.compile("^$");
   }

   /**
    * Destructor.
    */
   ~cmLBDepend()
   {
     cmDeleteAll(this->DependInformationMap);
   }

   /**
    * Set the makefile that is used as a source of classes.
    */
   void SetMakefile(cmMakefile* makefile)
   {
     this->Makefile = makefile;

     // Now extract the include file regular expression from the makefile.
     this->IncludeFileRegularExpression.compile(
           this->Makefile->GetIncludeRegularExpression());
     this->ComplainFileRegularExpression.compile(
           this->Makefile->GetComplainRegularExpression());

     // Now extract any include paths from the targets
     std::set<std::string> uniqueIncludes;
     std::vector<std::string> orderedAndUniqueIncludes;
     cmTargets &targets = this->Makefile->GetTargets();
     for (cmTargets::iterator l = targets.begin();
          l != targets.end(); ++l)
       {
       const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
       if (!incDirProp)
         {
         continue;
         }

       std::string incDirs =
           cmGeneratorExpression::Preprocess(incDirProp,
               cmGeneratorExpression::StripAllGeneratorExpressions);

       std::vector<std::string> includes;
       cmSystemTools::ExpandListArgument(incDirs, includes);

       for(std::vector<std::string>::const_iterator j = includes.begin();
           j != includes.end(); ++j)
         {
         std::string path = *j;
         this->Makefile->ExpandVariablesInString(path);
         if(uniqueIncludes.insert(path).second)
           {
           orderedAndUniqueIncludes.push_back(path);
           }
         }
       }

     for(std::vector<std::string>::const_iterator
         it = orderedAndUniqueIncludes.begin();
         it != orderedAndUniqueIncludes.end();
         ++it)
       {
       this->AddSearchPath(*it);
       }
   }

   /**
    * Add a directory to the search path for include files.
    */
   void AddSearchPath(const std::string& path)
   {
     this->IncludeDirectories.push_back(path);
   }

   /**
    * Generate dependencies for the file given.  Returns a pointer to
    * the cmDependInformation object for the file.
    */
   const cmDependInformation* FindDependencies(const char* file)
   {
     cmDependInformation* info = this->GetDependInformation(file,0);
     this->GenerateDependInformation(info);
     return info;
   }

 protected:
   /**
    * Compute the depend information for this class.
    */

   void DependWalk(cmDependInformation* info)
   {
     cmsys::ifstream fin(info->FullPath.c_str());
     if(!fin)
       {
       cmSystemTools::Error("error can not open ", info->FullPath.c_str());
       return;
       }

     std::string line;
     while(cmSystemTools::GetLineFromStream(fin, line))
       {
       if(cmHasLiteralPrefix(line.c_str(), "#include"))
         {
         // if it is an include line then create a string class
         std::string currentline = line;
         size_t qstart = currentline.find('\"', 8);
         size_t qend;
         // if a quote is not found look for a <
         if(qstart == std::string::npos)
           {
           qstart = currentline.find('<', 8);
           // if a < is not found then move on
           if(qstart == std::string::npos)
             {
             cmSystemTools::Error("unknown include directive ",
                                  currentline.c_str() );
             continue;
             }
           else
             {
             qend = currentline.find('>', qstart+1);
             }
           }
         else
           {
           qend = currentline.find('\"', qstart+1);
           }
         // extract the file being included
         std::string includeFile =
           currentline.substr(qstart+1, qend - qstart-1);
         // see if the include matches the regular expression
         if(!this->IncludeFileRegularExpression.find(includeFile))
           {
           if(this->Verbose)
             {
             std::string message = "Skipping ";
             message += includeFile;
             message += " for file ";
             message += info->FullPath.c_str();
             cmSystemTools::Error(message.c_str(), 0);
             }
           continue;
           }

         // Add this file and all its dependencies.
         this->AddDependency(info, includeFile.c_str());
         /// add the cxx file if it exists
         std::string cxxFile = includeFile;
         std::string::size_type pos = cxxFile.rfind('.');
         if(pos != std::string::npos)
           {
           std::string root = cxxFile.substr(0, pos);
           cxxFile = root + ".cxx";
           bool found = false;
           // try jumping to .cxx .cpp and .c in order
           if(cmSystemTools::FileExists(cxxFile.c_str()))
             {
             found = true;
             }
           for(std::vector<std::string>::iterator i =
               this->IncludeDirectories.begin();
               i != this->IncludeDirectories.end(); ++i)
             {
             std::string path = *i;
             path = path + "/";
             path = path + cxxFile;
             if(cmSystemTools::FileExists(path.c_str()))
               {
               found = true;
               }
             }
           if (!found)
             {
             cxxFile = root + ".cpp";
             if(cmSystemTools::FileExists(cxxFile.c_str()))
               {
               found = true;
               }
             for(std::vector<std::string>::iterator i =
                 this->IncludeDirectories.begin();
                 i != this->IncludeDirectories.end(); ++i)
               {
               std::string path = *i;
               path = path + "/";
               path = path + cxxFile;
               if(cmSystemTools::FileExists(path.c_str()))
                 {
                 found = true;
                 }
               }
             }
           if (!found)
             {
             cxxFile = root + ".c";
             if(cmSystemTools::FileExists(cxxFile.c_str()))
               {
               found = true;
               }
             for(std::vector<std::string>::iterator i =
                 this->IncludeDirectories.begin();
                 i != this->IncludeDirectories.end(); ++i)
               {
               std::string path = *i;
               path = path + "/";
               path = path + cxxFile;
               if(cmSystemTools::FileExists(path.c_str()))
                 {
                 found = true;
                 }
               }
             }
           if (!found)
             {
             cxxFile = root + ".txx";
             if(cmSystemTools::FileExists(cxxFile.c_str()))
               {
               found = true;
               }
             for(std::vector<std::string>::iterator i =
                 this->IncludeDirectories.begin();
                 i != this->IncludeDirectories.end(); ++i)
               {
               std::string path = *i;
               path = path + "/";
               path = path + cxxFile;
               if(cmSystemTools::FileExists(path.c_str()))
                 {
                 found = true;
                 }
               }
             }
           if (found)
             {
             this->AddDependency(info, cxxFile.c_str());
             }
           }
         }
       }
   }

   /**
    * Add a dependency.  Possibly walk it for more dependencies.
    */
   void AddDependency(cmDependInformation* info, const char* file)
   {
     cmDependInformation* dependInfo =
         this->GetDependInformation(file, info->PathOnly.c_str());
     this->GenerateDependInformation(dependInfo);
     info->AddDependencies(dependInfo);
   }

   /**
    * Fill in the given object with dependency information.  If the
    * information is already complete, nothing is done.
    */
   void GenerateDependInformation(cmDependInformation* info)
   {
     // If dependencies are already done, stop now.
     if(info->DependDone)
       {
       return;
       }
     else
       {
       // Make sure we don't visit the same file more than once.
       info->DependDone = true;
       }
     const char* path = info->FullPath.c_str();
     if(!path)
       {
       cmSystemTools::Error(
             "Attempt to find dependencies for file without path!");
       return;
       }

     bool found = false;

     // If the file exists, use it to find dependency information.
     if(cmSystemTools::FileExists(path, true))
       {
       // Use the real file to find its dependencies.
       this->DependWalk(info);
       found = true;
       }


     // See if the cmSourceFile for it has any files specified as
     // dependency hints.
     if(info->SourceFile != 0)
       {

       // Get the cmSourceFile corresponding to this.
       const cmSourceFile& cFile = *(info->SourceFile);
       // See if there are any hints for finding dependencies for the missing
       // file.
       if(!cFile.GetDepends().empty())
         {
         // Dependency hints have been given.  Use them to begin the
         // recursion.
         for(std::vector<std::string>::const_iterator file =
             cFile.GetDepends().begin(); file != cFile.GetDepends().end();
             ++file)
           {
           this->AddDependency(info, file->c_str());
           }

         // Found dependency information.  We are done.
         found = true;
         }
       }

     if(!found)
       {
       // Try to find the file amongst the sources
       cmSourceFile *srcFile = this->Makefile->GetSource
           (cmSystemTools::GetFilenameWithoutExtension(path));
       if (srcFile)
         {
         if (srcFile->GetFullPath() == path)
           {
           found=true;
           }
         else
           {
           //try to guess which include path to use
           for(std::vector<std::string>::iterator t =
               this->IncludeDirectories.begin();
               t != this->IncludeDirectories.end(); ++t)
             {
             std::string incpath = *t;
             if (!incpath.empty() && incpath[incpath.size() - 1] != '/')
               {
               incpath = incpath + "/";
               }
             incpath = incpath + path;
             if (srcFile->GetFullPath() == incpath)
               {
               // set the path to the guessed path
               info->FullPath = incpath;
               found=true;
               }
             }
           }
         }
       }

     if(!found)
       {
       // Couldn't find any dependency information.
       if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str()))
         {
         cmSystemTools::Error("error cannot find dependencies for ", path);
         }
       else
         {
         // Destroy the name of the file so that it won't be output as a
         // dependency.
         info->FullPath = "";
         }
       }
   }

   /**
    * Get an instance of cmDependInformation corresponding to the given file
    * name.
    */
   cmDependInformation* GetDependInformation(const char* file,
                                             const char *extraPath)
   {
     // Get the full path for the file so that lookup is unambiguous.
     std::string fullPath = this->FullPath(file, extraPath);

     // Try to find the file's instance of cmDependInformation.
     DependInformationMapType::const_iterator result =
         this->DependInformationMap.find(fullPath);
     if(result != this->DependInformationMap.end())
       {
       // Found an instance, return it.
       return result->second;
       }
     else
       {
       // Didn't find an instance.  Create a new one and save it.
       cmDependInformation* info = new cmDependInformation;
       info->FullPath = fullPath;
       info->PathOnly = cmSystemTools::GetFilenamePath(fullPath);
       info->IncludeName = file;
       this->DependInformationMap[fullPath] = info;
       return info;
       }
   }

   /**
    * Find the full path name for the given file name.
    * This uses the include directories.
    * TODO: Cache path conversions to reduce FileExists calls.
    */
   std::string FullPath(const char *fname, const char *extraPath)
   {
     DirectoryToFileToPathMapType::iterator m;
     if(extraPath)
       {
       m = this->DirectoryToFileToPathMap.find(extraPath);
       }
     else
       {
       m = this->DirectoryToFileToPathMap.find("");
       }

     if(m != this->DirectoryToFileToPathMap.end())
       {
       FileToPathMapType& map = m->second;
       FileToPathMapType::iterator p = map.find(fname);
       if(p != map.end())
         {
         return p->second;
         }
       }

     if(cmSystemTools::FileExists(fname, true))
       {
       std::string fp = cmSystemTools::CollapseFullPath(fname);
       this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
       return fp;
       }

     for(std::vector<std::string>::iterator i =
         this->IncludeDirectories.begin();
         i != this->IncludeDirectories.end(); ++i)
       {
       std::string path = *i;
       if (!path.empty() && path[path.size() - 1] != '/')
         {
         path = path + "/";
         }
       path = path + fname;
       if(cmSystemTools::FileExists(path.c_str(), true)
          && !cmSystemTools::FileIsDirectory(path))
         {
         std::string fp = cmSystemTools::CollapseFullPath(path);
         this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
         return fp;
         }
       }

     if (extraPath)
       {
       std::string path = extraPath;
       if (!path.empty() && path[path.size() - 1] != '/')
         {
         path = path + "/";
         }
       path = path + fname;
       if(cmSystemTools::FileExists(path.c_str(), true)
          && !cmSystemTools::FileIsDirectory(path))
         {
         std::string fp = cmSystemTools::CollapseFullPath(path);
         this->DirectoryToFileToPathMap[extraPath][fname] = fp;
         return fp;
         }
       }

     // Couldn't find the file.
     return std::string(fname);
   }

   cmMakefile* Makefile;
   bool Verbose;
   cmsys::RegularExpression IncludeFileRegularExpression;
   cmsys::RegularExpression ComplainFileRegularExpression;
   std::vector<std::string> IncludeDirectories;
   typedef std::map<std::string, std::string> FileToPathMapType;
   typedef std::map<std::string, FileToPathMapType>
   DirectoryToFileToPathMapType;
   typedef std::map<std::string, cmDependInformation*>
   DependInformationMapType;
   DependInformationMapType DependInformationMap;
   DirectoryToFileToPathMapType DirectoryToFileToPathMap;
 };

 // cmOutputRequiredFilesCommand
 bool cmOutputRequiredFilesCommand
 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 {
   if(this->Disallowed(cmPolicies::CMP0032,
       "The output_required_files command should not be called; see CMP0032."))
     { return true; }
   if(args.size() != 2 )
     {
     this->SetError("called with incorrect number of arguments");
     return false;
     }

   // store the arg for final pass
   this->File = args[0];
   this->OutputFile = args[1];

   // compute the list of files
   cmLBDepend md;
   md.SetMakefile(this->Makefile);
   md.AddSearchPath(this->Makefile->GetCurrentSourceDirectory());
   // find the depends for a file
   const cmDependInformation *info = md.FindDependencies(this->File.c_str());
   if (info)
     {
     // write them out
     FILE *fout = cmsys::SystemTools::Fopen(this->OutputFile.c_str(),"w");
     if(!fout)
       {
       std::string err = "Can not open output file: ";
       err += this->OutputFile;
       this->SetError(err);
       return false;
       }
     std::set<cmDependInformation const*> visited;
     this->ListDependencies(info,fout, &visited);
     fclose(fout);
     }

   return true;
 }

 void cmOutputRequiredFilesCommand::
 ListDependencies(cmDependInformation const *info,
                  FILE *fout,
                  std::set<cmDependInformation const*> *visited)
 {
   // add info to the visited set
   visited->insert(info);
   // now recurse with info's dependencies
   for(cmDependInformation::DependencySetType::const_iterator d =
         info->DependencySet.begin();
       d != info->DependencySet.end(); ++d)
     {
     if (visited->find(*d) == visited->end())
       {
       if(info->FullPath != "")
         {
         std::string tmp = (*d)->FullPath;
         std::string::size_type pos = tmp.rfind('.');
         if(pos != std::string::npos && (tmp.substr(pos) != ".h"))
           {
           tmp = tmp.substr(0, pos);
           fprintf(fout,"%s\n",(*d)->FullPath.c_str());
           }
         }
       this->ListDependencies(*d,fout,visited);
       }
     }
 }
	/*============================================================================
	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 "cmOutputRequiredFilesCommand.h"
	#include "cmAlgorithms.h"
	#include <cmsys/FStream.hxx>

	/** \class cmDependInformation
	* \brief Store dependency information for a single source file.
	*
	* This structure stores the depend information for a single source file.
	*/
	class cmDependInformation
	{
	public:
	/**
	* Construct with dependency generation marked not done; instance
	* not placed in cmMakefile's list.
	*/
	cmDependInformation(): DependDone(false), SourceFile(0) {}

	/**
	* The set of files on which this one depends.
	*/
	typedef std::set<cmDependInformation*> DependencySetType;
	DependencySetType DependencySet;

	/**
	* This flag indicates whether dependency checking has been
	* performed for this file.
	*/
	bool DependDone;

	/**
	* If this object corresponds to a cmSourceFile instance, this points
	* to it.
	*/
	const cmSourceFile *SourceFile;

	/**
	* Full path to this file.
	*/
	std::string FullPath;

	/**
	* Full path not including file name.
	*/
	std::string PathOnly;

	/**
	* Name used to #include this file.
	*/
	std::string IncludeName;

	/**
	* This method adds the dependencies of another file to this one.
	*/
	void AddDependencies(cmDependInformation* info)
	{
	if(this != info)
	{
	this->DependencySet.insert(info);
	}
	}
	};

	class cmLBDepend
	{
	public:
	/**
	* Construct the object with verbose turned off.
	*/
	cmLBDepend()
	{
	this->Verbose = false;
	this->IncludeFileRegularExpression.compile("^.*$");
	this->ComplainFileRegularExpression.compile("^$");
	}

	/**
	* Destructor.
	*/
	~cmLBDepend()
	{
	cmDeleteAll(this->DependInformationMap);
	}

	/**
	* Set the makefile that is used as a source of classes.
	*/
	void SetMakefile(cmMakefile* makefile)
	{
	this->Makefile = makefile;

	// Now extract the include file regular expression from the makefile.
	this->IncludeFileRegularExpression.compile(
	this->Makefile->GetIncludeRegularExpression());
	this->ComplainFileRegularExpression.compile(
	this->Makefile->GetComplainRegularExpression());

	// Now extract any include paths from the targets
	std::set<std::string> uniqueIncludes;
	std::vector<std::string> orderedAndUniqueIncludes;
	cmTargets &targets = this->Makefile->GetTargets();
	for (cmTargets::iterator l = targets.begin();
	l != targets.end(); ++l)
	{
	const char *incDirProp = l->second.GetProperty("INCLUDE_DIRECTORIES");
	if (!incDirProp)
	{
	continue;
	}

	std::string incDirs =
	cmGeneratorExpression::Preprocess(incDirProp,
	cmGeneratorExpression::StripAllGeneratorExpressions);

	std::vector<std::string> includes;
	cmSystemTools::ExpandListArgument(incDirs, includes);

	for(std::vector<std::string>::const_iterator j = includes.begin();
	j != includes.end(); ++j)
	{
	std::string path = *j;
	this->Makefile->ExpandVariablesInString(path);
	if(uniqueIncludes.insert(path).second)
	{
	orderedAndUniqueIncludes.push_back(path);
	}
	}
	}

	for(std::vector<std::string>::const_iterator
	it = orderedAndUniqueIncludes.begin();
	it != orderedAndUniqueIncludes.end();
	++it)
	{
	this->AddSearchPath(*it);
	}
	}

	/**
	* Add a directory to the search path for include files.
	*/
	void AddSearchPath(const std::string& path)
	{
	this->IncludeDirectories.push_back(path);
	}

	/**
	* Generate dependencies for the file given. Returns a pointer to
	* the cmDependInformation object for the file.
	*/
	const cmDependInformation* FindDependencies(const char* file)
	{
	cmDependInformation* info = this->GetDependInformation(file,0);
	this->GenerateDependInformation(info);
	return info;
	}

	protected:
	/**
	* Compute the depend information for this class.
	*/

	void DependWalk(cmDependInformation* info)
	{
	cmsys::ifstream fin(info->FullPath.c_str());
	if(!fin)
	{
	cmSystemTools::Error("error can not open ", info->FullPath.c_str());
	return;
	}

	std::string line;
	while(cmSystemTools::GetLineFromStream(fin, line))
	{
	if(cmHasLiteralPrefix(line.c_str(), "#include"))
	{
	// if it is an include line then create a string class
	std::string currentline = line;
	size_t qstart = currentline.find('\"', 8);
	size_t qend;
	// if a quote is not found look for a <
	if(qstart == std::string::npos)
	{
	qstart = currentline.find('<', 8);
	// if a < is not found then move on
	if(qstart == std::string::npos)
	{
	cmSystemTools::Error("unknown include directive ",
	currentline.c_str() );
	continue;
	}
	else
	{
	qend = currentline.find('>', qstart+1);
	}
	}
	else
	{
	qend = currentline.find('\"', qstart+1);
	}
	// extract the file being included
	std::string includeFile =
	currentline.substr(qstart+1, qend - qstart-1);
	// see if the include matches the regular expression
	if(!this->IncludeFileRegularExpression.find(includeFile))
	{
	if(this->Verbose)
	{
	std::string message = "Skipping ";
	message += includeFile;
	message += " for file ";
	message += info->FullPath.c_str();
	cmSystemTools::Error(message.c_str(), 0);
	}
	continue;
	}

	// Add this file and all its dependencies.
	this->AddDependency(info, includeFile.c_str());
	/// add the cxx file if it exists
	std::string cxxFile = includeFile;
	std::string::size_type pos = cxxFile.rfind('.');
	if(pos != std::string::npos)
	{
	std::string root = cxxFile.substr(0, pos);
	cxxFile = root + ".cxx";
	bool found = false;
	// try jumping to .cxx .cpp and .c in order
	if(cmSystemTools::FileExists(cxxFile.c_str()))
	{
	found = true;
	}
	for(std::vector<std::string>::iterator i =
	this->IncludeDirectories.begin();
	i != this->IncludeDirectories.end(); ++i)
	{
	std::string path = *i;
	path = path + "/";
	path = path + cxxFile;
	if(cmSystemTools::FileExists(path.c_str()))
	{
	found = true;
	}
	}
	if (!found)
	{
	cxxFile = root + ".cpp";
	if(cmSystemTools::FileExists(cxxFile.c_str()))
	{
	found = true;
	}
	for(std::vector<std::string>::iterator i =
	this->IncludeDirectories.begin();
	i != this->IncludeDirectories.end(); ++i)
	{
	std::string path = *i;
	path = path + "/";
	path = path + cxxFile;
	if(cmSystemTools::FileExists(path.c_str()))
	{
	found = true;
	}
	}
	}
	if (!found)
	{
	cxxFile = root + ".c";
	if(cmSystemTools::FileExists(cxxFile.c_str()))
	{
	found = true;
	}
	for(std::vector<std::string>::iterator i =
	this->IncludeDirectories.begin();
	i != this->IncludeDirectories.end(); ++i)
	{
	std::string path = *i;
	path = path + "/";
	path = path + cxxFile;
	if(cmSystemTools::FileExists(path.c_str()))
	{
	found = true;
	}
	}
	}
	if (!found)
	{
	cxxFile = root + ".txx";
	if(cmSystemTools::FileExists(cxxFile.c_str()))
	{
	found = true;
	}
	for(std::vector<std::string>::iterator i =
	this->IncludeDirectories.begin();
	i != this->IncludeDirectories.end(); ++i)
	{
	std::string path = *i;
	path = path + "/";
	path = path + cxxFile;
	if(cmSystemTools::FileExists(path.c_str()))
	{
	found = true;
	}
	}
	}
	if (found)
	{
	this->AddDependency(info, cxxFile.c_str());
	}
	}
	}
	}
	}

	/**
	* Add a dependency. Possibly walk it for more dependencies.
	*/
	void AddDependency(cmDependInformation* info, const char* file)
	{
	cmDependInformation* dependInfo =
	this->GetDependInformation(file, info->PathOnly.c_str());
	this->GenerateDependInformation(dependInfo);
	info->AddDependencies(dependInfo);
	}

	/**
	* Fill in the given object with dependency information. If the
	* information is already complete, nothing is done.
	*/
	void GenerateDependInformation(cmDependInformation* info)
	{
	// If dependencies are already done, stop now.
	if(info->DependDone)
	{
	return;
	}
	else
	{
	// Make sure we don't visit the same file more than once.
	info->DependDone = true;
	}
	const char* path = info->FullPath.c_str();
	if(!path)
	{
	cmSystemTools::Error(
	"Attempt to find dependencies for file without path!");
	return;
	}

	bool found = false;

	// If the file exists, use it to find dependency information.
	if(cmSystemTools::FileExists(path, true))
	{
	// Use the real file to find its dependencies.
	this->DependWalk(info);
	found = true;
	}


	// See if the cmSourceFile for it has any files specified as
	// dependency hints.
	if(info->SourceFile != 0)
	{

	// Get the cmSourceFile corresponding to this.
	const cmSourceFile& cFile = *(info->SourceFile);
	// See if there are any hints for finding dependencies for the missing
	// file.
	if(!cFile.GetDepends().empty())
	{
	// Dependency hints have been given. Use them to begin the
	// recursion.
	for(std::vector<std::string>::const_iterator file =
	cFile.GetDepends().begin(); file != cFile.GetDepends().end();
	++file)
	{
	this->AddDependency(info, file->c_str());
	}

	// Found dependency information. We are done.
	found = true;
	}
	}

	if(!found)
	{
	// Try to find the file amongst the sources
	cmSourceFile *srcFile = this->Makefile->GetSource
	(cmSystemTools::GetFilenameWithoutExtension(path));
	if (srcFile)
	{
	if (srcFile->GetFullPath() == path)
	{
	found=true;
	}
	else
	{
	//try to guess which include path to use
	for(std::vector<std::string>::iterator t =
	this->IncludeDirectories.begin();
	t != this->IncludeDirectories.end(); ++t)
	{
	std::string incpath = *t;
	if (!incpath.empty() && incpath[incpath.size() - 1] != '/')
	{
	incpath = incpath + "/";
	}
	incpath = incpath + path;
	if (srcFile->GetFullPath() == incpath)
	{
	// set the path to the guessed path
	info->FullPath = incpath;
	found=true;
	}
	}
	}
	}
	}

	if(!found)
	{
	// Couldn't find any dependency information.
	if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str()))
	{
	cmSystemTools::Error("error cannot find dependencies for ", path);
	}
	else
	{
	// Destroy the name of the file so that it won't be output as a
	// dependency.
	info->FullPath = "";
	}
	}
	}

	/**
	* Get an instance of cmDependInformation corresponding to the given file
	* name.
	*/
	cmDependInformation* GetDependInformation(const char* file,
	const char *extraPath)
	{
	// Get the full path for the file so that lookup is unambiguous.
	std::string fullPath = this->FullPath(file, extraPath);

	// Try to find the file's instance of cmDependInformation.
	DependInformationMapType::const_iterator result =
	this->DependInformationMap.find(fullPath);
	if(result != this->DependInformationMap.end())
	{
	// Found an instance, return it.
	return result->second;
	}
	else
	{
	// Didn't find an instance. Create a new one and save it.
	cmDependInformation* info = new cmDependInformation;
	info->FullPath = fullPath;
	info->PathOnly = cmSystemTools::GetFilenamePath(fullPath);
	info->IncludeName = file;
	this->DependInformationMap[fullPath] = info;
	return info;
	}
	}

	/**
	* Find the full path name for the given file name.
	* This uses the include directories.
	* TODO: Cache path conversions to reduce FileExists calls.
	*/
	std::string FullPath(const char fname, const char extraPath)
	{
	DirectoryToFileToPathMapType::iterator m;
	if(extraPath)
	{
	m = this->DirectoryToFileToPathMap.find(extraPath);
	}
	else
	{
	m = this->DirectoryToFileToPathMap.find("");
	}

	if(m != this->DirectoryToFileToPathMap.end())
	{
	FileToPathMapType& map = m->second;
	FileToPathMapType::iterator p = map.find(fname);
	if(p != map.end())
	{
	return p->second;
	}
	}

	if(cmSystemTools::FileExists(fname, true))
	{
	std::string fp = cmSystemTools::CollapseFullPath(fname);
	this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
	return fp;
	}

	for(std::vector<std::string>::iterator i =
	this->IncludeDirectories.begin();
	i != this->IncludeDirectories.end(); ++i)
	{
	std::string path = *i;
	if (!path.empty() && path[path.size() - 1] != '/')
	{
	path = path + "/";
	}
	path = path + fname;
	if(cmSystemTools::FileExists(path.c_str(), true)
	&& !cmSystemTools::FileIsDirectory(path))
	{
	std::string fp = cmSystemTools::CollapseFullPath(path);
	this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
	return fp;
	}
	}

	if (extraPath)
	{
	std::string path = extraPath;
	if (!path.empty() && path[path.size() - 1] != '/')
	{
	path = path + "/";
	}
	path = path + fname;
	if(cmSystemTools::FileExists(path.c_str(), true)
	&& !cmSystemTools::FileIsDirectory(path))
	{
	std::string fp = cmSystemTools::CollapseFullPath(path);
	this->DirectoryToFileToPathMap[extraPath][fname] = fp;
	return fp;
	}
	}

	// Couldn't find the file.
	return std::string(fname);
	}

	cmMakefile* Makefile;
	bool Verbose;
	cmsys::RegularExpression IncludeFileRegularExpression;
	cmsys::RegularExpression ComplainFileRegularExpression;
	std::vector<std::string> IncludeDirectories;
	typedef std::map<std::string, std::string> FileToPathMapType;
	typedef std::map<std::string, FileToPathMapType>
	DirectoryToFileToPathMapType;
	typedef std::map<std::string, cmDependInformation*>
	DependInformationMapType;
	DependInformationMapType DependInformationMap;
	DirectoryToFileToPathMapType DirectoryToFileToPathMap;
	};

	// cmOutputRequiredFilesCommand
	bool cmOutputRequiredFilesCommand
	::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
	{
	if(this->Disallowed(cmPolicies::CMP0032,
	"The output_required_files command should not be called; see CMP0032."))
	{ return true; }
	if(args.size() != 2 )
	{
	this->SetError("called with incorrect number of arguments");
	return false;
	}

	// store the arg for final pass
	this->File = args[0];
	this->OutputFile = args[1];

	// compute the list of files
	cmLBDepend md;
	md.SetMakefile(this->Makefile);
	md.AddSearchPath(this->Makefile->GetCurrentSourceDirectory());
	// find the depends for a file
	const cmDependInformation *info = md.FindDependencies(this->File.c_str());
	if (info)
	{
	// write them out
	FILE *fout = cmsys::SystemTools::Fopen(this->OutputFile.c_str(),"w");
	if(!fout)
	{
	std::string err = "Can not open output file: ";
	err += this->OutputFile;
	this->SetError(err);
	return false;
	}
	std::set<cmDependInformation const*> visited;
	this->ListDependencies(info,fout, &visited);
	fclose(fout);
	}

	return true;
	}

	void cmOutputRequiredFilesCommand::
	ListDependencies(cmDependInformation const *info,
	FILE *fout,
	std::set<cmDependInformation const> visited)
	{
	// add info to the visited set
	visited->insert(info);
	// now recurse with info's dependencies
	for(cmDependInformation::DependencySetType::const_iterator d =
	info->DependencySet.begin();
	d != info->DependencySet.end(); ++d)
	{
	if (visited->find(*d) == visited->end())
	{
	if(info->FullPath != "")
	{
	std::string tmp = (*d)->FullPath;
	std::string::size_type pos = tmp.rfind('.');
	if(pos != std::string::npos && (tmp.substr(pos) != ".h"))
	{
	tmp = tmp.substr(0, pos);
	fprintf(fout,"%s\n",(*d)->FullPath.c_str());
	}
	}
	this->ListDependencies(*d,fout,visited);
	}
	}
	}