CMakeLua/Source/cmMakeDepend.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmMakeDepend.cxx,v $
   5   Language:  C++
   6 <<<<<<< cmMakeDepend.cxx
   7   Date:      $Date: 2007/12/15 01:31:27 $
   8   Version:   $Revision: 1.46 $
   9 =======
  10   Date:      $Date: 2009-03-16 18:30:19 $
  11   Version:   $Revision: 1.47 $
  12 >>>>>>> 1.47
  13
  14   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  15   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  16
  17      This software is distributed WITHOUT ANY WARRANTY; without even
  18      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  19      PURPOSE.  See the above copyright notices for more information.
  20
  21 =========================================================================*/
  22 #include "cmMakeDepend.h"
  23 #include "cmSystemTools.h"
  24
  25 #include <cmsys/RegularExpression.hxx>
  26
  27 void cmDependInformation::AddDependencies(cmDependInformation* info)
  28 {
  29   if(this != info)
  30     {
  31     this->DependencySet.insert(info);
  32     }
  33 }
  34
  35 cmMakeDepend::cmMakeDepend()
  36 {
  37   this->Verbose = false;
  38   this->IncludeFileRegularExpression.compile("^.*$");
  39   this->ComplainFileRegularExpression.compile("^$");
  40 }
  41
  42
  43 cmMakeDepend::~cmMakeDepend()
  44 {
  45   for(DependInformationMapType::iterator i =
  46         this->DependInformationMap.begin();
  47       i != this->DependInformationMap.end(); ++i)
  48     {
  49     delete i->second;
  50     }
  51 }
  52
  53
  54 // Set the makefile that depends will be made from.
  55 // The pointer is kept so the cmSourceFile array can
  56 // be updated with the depend information in the cmMakefile.
  57
  58 void cmMakeDepend::SetMakefile(cmMakefile* makefile)
  59 {
  60   this->Makefile = makefile;
  61
  62   // Now extract the include file regular expression from the makefile.
  63   this->IncludeFileRegularExpression.compile(
  64     this->Makefile->IncludeFileRegularExpression.c_str());
  65   this->ComplainFileRegularExpression.compile(
  66     this->Makefile->ComplainFileRegularExpression.c_str());
  67
  68   // Now extract any include paths from the makefile flags
  69   const std::vector<std::string>& includes =
  70     this->Makefile->GetIncludeDirectories();
  71   for(std::vector<std::string>::const_iterator j = includes.begin();
  72       j != includes.end(); ++j)
  73     {
  74     std::string path = *j;
  75     this->Makefile->ExpandVariablesInString(path);
  76     this->AddSearchPath(path.c_str());
  77     }
  78 }
  79
  80
  81 const cmDependInformation* cmMakeDepend::FindDependencies(const char* file)
  82 {
  83   cmDependInformation* info = this->GetDependInformation(file,0);
  84   this->GenerateDependInformation(info);
  85   return info;
  86 }
  87
  88 void cmMakeDepend::GenerateDependInformation(cmDependInformation* info)
  89 {
  90   // If dependencies are already done, stop now.
  91   if(info->DependDone)
  92     {
  93     return;
  94     }
  95   else
  96     {
  97     // Make sure we don't visit the same file more than once.
  98     info->DependDone = true;
  99     }
 100   const char* path = info->FullPath.c_str();
 101   if(!path)
 102     {
 103     cmSystemTools::Error(
 104       "Attempt to find dependencies for file without path!");
 105     return;
 106     }
 107
 108   bool found = false;
 109
 110   // If the file exists, use it to find dependency information.
 111   if(cmSystemTools::FileExists(path, true))
 112     {
 113     // Use the real file to find its dependencies.
 114     this->DependWalk(info);
 115     found = true;
 116     }
 117
 118
 119   // See if the cmSourceFile for it has any files specified as
 120   // dependency hints.
 121   if(info->SourceFile != 0)
 122     {
 123
 124     // Get the cmSourceFile corresponding to this.
 125     const cmSourceFile& cFile = *(info->SourceFile);
 126     // See if there are any hints for finding dependencies for the missing
 127     // file.
 128     if(!cFile.GetDepends().empty())
 129       {
 130       // Dependency hints have been given.  Use them to begin the
 131       // recursion.
 132       for(std::vector<std::string>::const_iterator file =
 133             cFile.GetDepends().begin(); file != cFile.GetDepends().end();
 134           ++file)
 135         {
 136         this->AddDependency(info, file->c_str());
 137         }
 138
 139       // Found dependency information.  We are done.
 140       found = true;
 141       }
 142     }
 143
 144   if(!found)
 145     {
 146     // Try to find the file amongst the sources
 147     cmSourceFile *srcFile = this->Makefile->GetSource
 148       (cmSystemTools::GetFilenameWithoutExtension(path).c_str());
 149     if (srcFile)
 150       {
 151       if (srcFile->GetFullPath() == path)
 152         {
 153         found=true;
 154         }
 155       else
 156         {
 157         //try to guess which include path to use
 158         for(std::vector<std::string>::iterator t =
 159               this->IncludeDirectories.begin();
 160             t != this->IncludeDirectories.end(); ++t)
 161           {
 162           std::string incpath = *t;
 163           if (incpath.size() && incpath[incpath.size() - 1] != '/')
 164             {
 165             incpath = incpath + "/";
 166             }
 167           incpath = incpath + path;
 168           if (srcFile->GetFullPath() == incpath)
 169             {
 170             // set the path to the guessed path
 171             info->FullPath = incpath;
 172             found=true;
 173             }
 174           }
 175         }
 176       }
 177     }
 178
 179   if(!found)
 180     {
 181     // Couldn't find any dependency information.
 182     if(this->ComplainFileRegularExpression.find(info->IncludeName.c_str()))
 183       {
 184       cmSystemTools::Error("error cannot find dependencies for ", path);
 185       }
 186     else
 187       {
 188       // Destroy the name of the file so that it won't be output as a
 189       // dependency.
 190       info->FullPath = "";
 191       }
 192     }
 193 }
 194
 195 // This function actually reads the file specified and scans it for
 196 // #include directives
 197 void cmMakeDepend::DependWalk(cmDependInformation* info)
 198 {
 199   cmsys::RegularExpression includeLine
 200     ("^[ \t]*#[ \t]*include[ \t]*[<\"]([^\">]+)[\">]");
 201   std::ifstream fin(info->FullPath.c_str());
 202   if(!fin)
 203     {
 204     cmSystemTools::Error("Cannot open ", info->FullPath.c_str());
 205     return;
 206     }
 207
 208   // TODO: Write real read loop (see cmSystemTools::CopyFile).
 209   std::string line;
 210   while( cmSystemTools::GetLineFromStream(fin, line) )
 211     {
 212     if(includeLine.find(line.c_str()))
 213       {
 214       // extract the file being included
 215       std::string includeFile = includeLine.match(1);
 216       // see if the include matches the regular expression
 217       if(!this->IncludeFileRegularExpression.find(includeFile))
 218         {
 219         if(this->Verbose)
 220           {
 221           std::string message = "Skipping ";
 222           message += includeFile;
 223           message += " for file ";
 224           message += info->FullPath.c_str();
 225           cmSystemTools::Error(message.c_str(), 0);
 226           }
 227         continue;
 228         }
 229
 230       // Add this file and all its dependencies.
 231       this->AddDependency(info, includeFile.c_str());
 232       }
 233     }
 234 }
 235
 236
 237 void cmMakeDepend::AddDependency(cmDependInformation* info, const char* file)
 238 {
 239   cmDependInformation* dependInfo =
 240     this->GetDependInformation(file, info->PathOnly.c_str());
 241   this->GenerateDependInformation(dependInfo);
 242   info->AddDependencies(dependInfo);
 243 }
 244
 245 cmDependInformation* cmMakeDepend::GetDependInformation(const char* file,
 246                                                         const char *extraPath)
 247 {
 248   // Get the full path for the file so that lookup is unambiguous.
 249   std::string fullPath = this->FullPath(file, extraPath);
 250
 251   // Try to find the file's instance of cmDependInformation.
 252   DependInformationMapType::const_iterator result =
 253     this->DependInformationMap.find(fullPath);
 254   if(result != this->DependInformationMap.end())
 255     {
 256     // Found an instance, return it.
 257     return result->second;
 258     }
 259   else
 260     {
 261     // Didn't find an instance.  Create a new one and save it.
 262     cmDependInformation* info = new cmDependInformation;
 263     info->FullPath = fullPath;
 264     info->PathOnly = cmSystemTools::GetFilenamePath(fullPath.c_str());
 265     info->IncludeName = file;
 266     this->DependInformationMap[fullPath] = info;
 267     return info;
 268     }
 269 }
 270
 271
 272 // find the full path to fname by searching the this->IncludeDirectories array
 273 std::string cmMakeDepend::FullPath(const char* fname, const char *extraPath)
 274 {
 275   DirectoryToFileToPathMapType::iterator m;
 276   if(extraPath)
 277     {
 278     m = this->DirectoryToFileToPathMap.find(extraPath);
 279     }
 280   else
 281     {
 282     m = this->DirectoryToFileToPathMap.find("");
 283     }
 284
 285   if(m != this->DirectoryToFileToPathMap.end())
 286     {
 287     FileToPathMapType& map = m->second;
 288     FileToPathMapType::iterator p = map.find(fname);
 289     if(p != map.end())
 290       {
 291       return p->second;
 292       }
 293     }
 294
 295   if(cmSystemTools::FileExists(fname, true))
 296     {
 297     std::string fp = cmSystemTools::CollapseFullPath(fname);
 298     this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
 299     return fp;
 300     }
 301
 302   for(std::vector<std::string>::iterator i = this->IncludeDirectories.begin();
 303       i != this->IncludeDirectories.end(); ++i)
 304     {
 305     std::string path = *i;
 306     if (path.size() && path[path.size() - 1] != '/')
 307       {
 308       path = path + "/";
 309       }
 310     path = path + fname;
 311     if(cmSystemTools::FileExists(path.c_str(), true)
 312        && !cmSystemTools::FileIsDirectory(path.c_str()))
 313       {
 314       std::string fp = cmSystemTools::CollapseFullPath(path.c_str());
 315       this->DirectoryToFileToPathMap[extraPath? extraPath: ""][fname] = fp;
 316       return fp;
 317       }
 318     }
 319
 320   if (extraPath)
 321     {
 322     std::string path = extraPath;
 323     if (path.size() && path[path.size() - 1] != '/')
 324       {
 325       path = path + "/";
 326       }
 327     path = path + fname;
 328     if(cmSystemTools::FileExists(path.c_str(), true)
 329        && !cmSystemTools::FileIsDirectory(path.c_str()))
 330       {
 331       std::string fp = cmSystemTools::CollapseFullPath(path.c_str());
 332       this->DirectoryToFileToPathMap[extraPath][fname] = fp;
 333       return fp;
 334       }
 335     }
 336
 337   // Couldn't find the file.
 338   return std::string(fname);
 339 }
 340
 341 // Add a directory to the search path
 342 void cmMakeDepend::AddSearchPath(const char* path)
 343 {
 344   this->IncludeDirectories.push_back(path);
 345 }