CMakeLua/Source/cmOutputRequiredFilesCommand.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmOutputRequiredFilesCommand.cxx,v $
   5   Language:  C++
   6 <<<<<<< cmOutputRequiredFilesCommand.cxx
   7   Date:      $Date: 2008/01/23 15:27:59 $
   8   Version:   $Revision: 1.16 $
   9 =======
  10   Date:      $Date: 2008-10-10 14:48:10 $
  11   Version:   $Revision: 1.17 $
  12 >>>>>>> 1.17
  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 "cmOutputRequiredFilesCommand.h"
  23 #include "cmMakeDepend.h"
  24
  25 class cmLBDepend : public cmMakeDepend
  26 {
  27   /**
  28    * Compute the depend information for this class.
  29    */
  30   virtual void DependWalk(cmDependInformation* info);
  31 };
  32
  33 void cmLBDepend::DependWalk(cmDependInformation* info)
  34 {
  35   std::ifstream fin(info->FullPath.c_str());
  36   if(!fin)
  37     {
  38     cmSystemTools::Error("error can not open ", info->FullPath.c_str());
  39     return;
  40     }
  41
  42   std::string line;
  43   while(cmSystemTools::GetLineFromStream(fin, line))
  44     {
  45     if(!strncmp(line.c_str(), "#include", 8))
  46       {
  47       // if it is an include line then create a string class
  48       std::string currentline = line;
  49       size_t qstart = currentline.find('\"', 8);
  50       size_t qend;
  51       // if a quote is not found look for a <
  52       if(qstart == std::string::npos)
  53         {
  54         qstart = currentline.find('<', 8);
  55         // if a < is not found then move on
  56         if(qstart == std::string::npos)
  57           {
  58           cmSystemTools::Error("unknown include directive ",
  59                                currentline.c_str() );
  60           continue;
  61           }
  62         else
  63           {
  64           qend = currentline.find('>', qstart+1);
  65           }
  66         }
  67       else
  68         {
  69         qend = currentline.find('\"', qstart+1);
  70         }
  71       // extract the file being included
  72       std::string includeFile = currentline.substr(qstart+1, qend - qstart-1);
  73       // see if the include matches the regular expression
  74       if(!this->IncludeFileRegularExpression.find(includeFile))
  75         {
  76         if(this->Verbose)
  77           {
  78           std::string message = "Skipping ";
  79           message += includeFile;
  80           message += " for file ";
  81           message += info->FullPath.c_str();
  82           cmSystemTools::Error(message.c_str(), 0);
  83           }
  84         continue;
  85         }
  86
  87       // Add this file and all its dependencies.
  88       this->AddDependency(info, includeFile.c_str());
  89       /// add the cxx file if it exists
  90       std::string cxxFile = includeFile;
  91       std::string::size_type pos = cxxFile.rfind('.');
  92       if(pos != std::string::npos)
  93         {
  94         std::string root = cxxFile.substr(0, pos);
  95         cxxFile = root + ".cxx";
  96         bool found = false;
  97         // try jumping to .cxx .cpp and .c in order
  98         if(cmSystemTools::FileExists(cxxFile.c_str()))
  99           {
 100           found = true;
 101           }
 102         for(std::vector<std::string>::iterator i =
 103               this->IncludeDirectories.begin();
 104             i != this->IncludeDirectories.end(); ++i)
 105           {
 106           std::string path = *i;
 107           path = path + "/";
 108           path = path + cxxFile;
 109           if(cmSystemTools::FileExists(path.c_str()))
 110             {
 111             found = true;
 112             }
 113           }
 114         if (!found)
 115           {
 116           cxxFile = root + ".cpp";
 117           if(cmSystemTools::FileExists(cxxFile.c_str()))
 118             {
 119             found = true;
 120             }
 121           for(std::vector<std::string>::iterator i =
 122                 this->IncludeDirectories.begin();
 123               i != this->IncludeDirectories.end(); ++i)
 124             {
 125             std::string path = *i;
 126             path = path + "/";
 127             path = path + cxxFile;
 128             if(cmSystemTools::FileExists(path.c_str()))
 129               {
 130               found = true;
 131               }
 132             }
 133           }
 134         if (!found)
 135           {
 136           cxxFile = root + ".c";
 137           if(cmSystemTools::FileExists(cxxFile.c_str()))
 138             {
 139             found = true;
 140             }
 141           for(std::vector<std::string>::iterator i =
 142                 this->IncludeDirectories.begin();
 143               i != this->IncludeDirectories.end(); ++i)
 144             {
 145             std::string path = *i;
 146             path = path + "/";
 147             path = path + cxxFile;
 148             if(cmSystemTools::FileExists(path.c_str()))
 149               {
 150               found = true;
 151               }
 152             }
 153           }
 154         if (!found)
 155           {
 156           cxxFile = root + ".txx";
 157           if(cmSystemTools::FileExists(cxxFile.c_str()))
 158             {
 159             found = true;
 160             }
 161           for(std::vector<std::string>::iterator i =
 162                 this->IncludeDirectories.begin();
 163               i != this->IncludeDirectories.end(); ++i)
 164             {
 165             std::string path = *i;
 166             path = path + "/";
 167             path = path + cxxFile;
 168             if(cmSystemTools::FileExists(path.c_str()))
 169               {
 170               found = true;
 171               }
 172             }
 173           }
 174         if (found)
 175           {
 176           this->AddDependency(info, cxxFile.c_str());
 177           }
 178         }
 179       }
 180     }
 181 }
 182
 183 // cmOutputRequiredFilesCommand
 184 bool cmOutputRequiredFilesCommand
 185 ::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
 186 {
 187   if(args.size() != 2 )
 188     {
 189     this->SetError("called with incorrect number of arguments");
 190     return false;
 191     }
 192
 193   // store the arg for final pass
 194   this->File = args[0];
 195   this->OutputFile = args[1];
 196
 197   // compute the list of files
 198   cmLBDepend md;
 199   md.SetMakefile(this->Makefile);
 200   md.AddSearchPath(this->Makefile->GetStartDirectory());
 201   // find the depends for a file
 202   const cmDependInformation *info = md.FindDependencies(this->File.c_str());
 203   if (info)
 204     {
 205     // write them out
 206     FILE *fout = fopen(this->OutputFile.c_str(),"w");
 207     if(!fout)
 208       {
 209       std::string err = "Can not open output file: ";
 210       err += this->OutputFile;
 211       this->SetError(err.c_str());
 212       return false;
 213       }
 214     std::set<cmDependInformation const*> visited;
 215     this->ListDependencies(info,fout, &visited);
 216     fclose(fout);
 217     }
 218
 219   return true;
 220 }
 221
 222 void cmOutputRequiredFilesCommand::
 223 ListDependencies(cmDependInformation const *info,
 224                  FILE *fout,
 225                  std::set<cmDependInformation const*> *visited)
 226 {
 227   // add info to the visited set
 228   visited->insert(info);
 229   // now recurse with info's dependencies
 230   for(cmDependInformation::DependencySetType::const_iterator d =
 231         info->DependencySet.begin();
 232       d != info->DependencySet.end(); ++d)
 233     {
 234     if (visited->find(*d) == visited->end())
 235       {
 236       if(info->FullPath != "")
 237         {
 238         std::string tmp = (*d)->FullPath;
 239         std::string::size_type pos = tmp.rfind('.');
 240         if(pos != std::string::npos && (tmp.substr(pos) != ".h"))
 241           {
 242           tmp = tmp.substr(0, pos);
 243           fprintf(fout,"%s\n",(*d)->FullPath.c_str());
 244           }
 245         }
 246       this->ListDependencies(*d,fout,visited);
 247       }
 248     }
 249 }
 250