JDependencies.cc

Go to the documentation of this file.

#include <string>
#include <iostream>
#include <fstream>
#include <sstream>
#include <iomanip>
#include <cstdlib>
#include <vector>
#include <set>
#include <map>
#include <dirent.h>
 
#include "JSystem/JFilesystem.hh"
#include "JLang/JLangToolkit.hh"
 
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
 
namespace {
 
  static const char WILDCARD = '%';                                     //!< file name wild card
  
  static const char* const INCLUDE_DIRECTIVE    =   "#include";         //!< C++ include directive
  static const char* const NAMESPACE_DIRECTIVE  =   "namespace";        //!< C++ namespace directive
  static const char* const INCLUDE_EXTENSION    =   ".hh";              //!< Jpp include file extension
  static const char* const SOFTWARE_DIRECTORY   =   "software";         //!< Jpp software directory
 
  static const std::set<std::string> rm         =                       //!< discard sub-directories
    { "JMarkov" };
 
 
  /**
   * Auxiliary class to list dependencies of Jpp include files.
   */
  struct JDirectory :
    public std::map<std::string, std::set<std::string> >
  {
    static const char JPP_PREFIX           =  'J';    //!< Jpp file name prefix
    static const char DIRECTORY_SEPARATOR  =  '/';    //!< sub-directory
 
 
    /**
     * Auxiliary data structure for directory path.
     */
    struct path_type :
      public std::vector<std::string>
    {
      /**
       * Check validity of path.
       *
       * \param  key                   key
       * \return                       true if valid; else false
       */
      bool is_valid(const key_type& key) const
      {
        for (const_iterator p = this->begin(); p != this->end(); ++p) {
 
          if (key == *p) {
            return false;
          }
 
          for (const_iterator q = this->begin(); q != p; ++q) {
            if (*p == *q) {
              return false;
            }
          }
        }
        
        return true;
      }
    };
 
 
    /**
     * Default constructor.
     *
     * \param  dir                   top-level directory
     */
    JDirectory(const std::string& dir = "")
    {
      using namespace std;
      using namespace JPP;
      
      const string JPP_DIR = (dir != "" ? dir : getenv("JPP_DIR"));
      const string TOP     = JPP_DIR + DIRECTORY_SEPARATOR + SOFTWARE_DIRECTORY;
 
      for (const auto& top : ls(TOP)) {
 
        if (top[0] == JPP_PREFIX && rm.count(top) == 0) {
 
          const string SUB = TOP + DIRECTORY_SEPARATOR + top;
 
          for (const auto& file : ls(SUB)) {
 
            if (file.find(INCLUDE_EXTENSION) != string::npos) {
              
              const string file_name = SUB + DIRECTORY_SEPARATOR + file;
 
              ifstream in(file_name.c_str());
 
              for (string buffer; getline(in, buffer) && buffer.find(NAMESPACE_DIRECTIVE) == string::npos; ) {
 
                if (buffer.find(INCLUDE_DIRECTIVE) != string::npos) {
 
                  istringstream is(buffer);
 
                  string key, include_file;
 
                  is >> key >> include_file;
 
                  if (is_double_quoted(include_file) && include_file[1] == JPP_PREFIX) {
              
                    const size_t pos = include_file.find(DIRECTORY_SEPARATOR);
 
                    if (pos != string::npos) {
 
                      const string dir = include_file.substr(1, pos - 1);
 
                      if (dir != top) {
                        (*this)[top].insert(dir);
                      }
                    }
                  }
                }
              }
 
              in.close();
            }
          }
        }
      }
    }
 
 
    /**
     * Copy constructor.
     *
     * \param  input                 directory
     * \param  key                   key
     */
    JDirectory(const JDirectory& input, const key_type& key)
    {
      this->copy(input, key);
    }
 
    
    /**
     * Get mapped data for given key.
     *
     * \param  key                   key
     * \return                       mapped data
     */
    const mapped_type& get(const key_type& key) const
    {
      static const mapped_type buffer;
      
      const_iterator p = this->find(key);
 
      if (p != this->end())
        return p->second;
      else
        return buffer;
    }
 
 
    /**
     * Get circular dependency for given key.
     *
     * \param  key                   key
     * \return                       path
     */
    path_type getPath(const key_type& key) const
    {
      path.clear();
      
      evaluate(key, get(key));
        
      return path;
    }
 
    
    /**
     * Check recursively mapped data for given key.
     *
     * \param  key                   key
     * \return                       true if valid; else false
     */
    bool is_valid(const key_type& key) const
    {
      path.clear();
      
      return evaluate(key, get(key));
    }
 
 
    /**
     * Print data conform tikz format.
     *
     * \param  out                   output stream
     */
    inline void print(std::ostream& out) const
    {
      using namespace std;
      
      for (const_iterator i = this->begin(); i != this->end(); ++i) {
 
        out << i->first << " -> {";
  
        for (const auto& dir : i->second) {
          out << " " << dir << ",";
        }
 
        out << "}," << endl;
      }
    }
    
    
    /**
     * Print data conform tikz format.
     *
     * \param  out                   output stream
     * \param  key                   key
     */
    inline void print(std::ostream& out, const JDirectory::key_type& key) const
    {
      JDirectory(*this, key).print(out);
    }
 
  private:
    /**
     * Recursive copy of input data.
     *
     * \param  input                 directory
     * \param  key                   key
     */
    void copy(const JDirectory& input, const key_type& key)
    {
      (*this)[key] = input.get(key);
 
      for (const auto& dir : input.get(key)) {
        if (this->find(dir) == this->end()) {
          copy(input, dir);
        }
      }
    }
 
 
    /**
     * Check recursively mapped data for given key.
     *
     * \param  key                   key
     * \param  target                target data
     * \return                       true if valid; else false
     */
    bool evaluate(const key_type& key, const mapped_type& target) const
    {
      if (!path.is_valid(key)) {     // premature end
        return false;
      }
        
      for (mapped_type::const_iterator i = target.begin(); i != target.end(); ++i) {
 
        path.push_back(*i);          // grow
 
        if (!evaluate(key, this->get(*i))) {
          return false;
        }
 
        path.pop_back();             // shrink
      }
 
      return true;                   // normal end
    }
 
    mutable path_type path;          // internal buffer
  };
}
 
 
/**
 * \file
 * Example program to test dependencies of include files.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  string      outputFile;
  string      jpp;
  string      dir;
  int         debug;
 
  try {
 
    JParser<> zap("Example program to test dependencies of include files");
 
    zap['o'] = make_field(outputFile) = ""; 
    zap['J'] = make_field(jpp)        = "";
    zap['D'] = make_field(dir)        = "";
    zap['d'] = make_field(debug)      = 3;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
  
 
  const JDirectory directory(jpp);
 
  
  if (outputFile != "") {
 
    const size_t pos = outputFile.find(WILDCARD);
 
    if (pos != string::npos) {
      outputFile.replace(pos, 1, (dir != "" ? dir.c_str() : "Jpp"));
    }
    
    ofstream out(outputFile.c_str());
    
    out << "\\documentclass[border=5mm]{standalone}"   << endl;
    out << ""                                          << endl;
    out << "\\usepackage{tikz}"                        << endl;
    out << "\\usetikzlibrary{graphs, graphdrawing}"    << endl;
    out << "\\usegdlibrary{layered}"                   << endl;
    out << "\\begin{document}"                         << endl;
    out << ""                                          << endl;
    out << "\\tikz \\graph [layered layout]"           << endl;
    out << "{"                                         << endl;
 
    if (dir == "")
      directory.print(out);
    else
      directory.print(out, dir);
      
    out << "};"                                        << endl;
    out << ""                                          << endl;
    out << "\\end{document}"                           << endl;
    
    out.close();
  }
 
 
  for (JDirectory::const_iterator i = directory.begin(); i != directory.end(); ++i) {
 
    DEBUG(i->first << ": " << flush);
 
    if (!directory.is_valid(i->first)) {
 
      const JDirectory::path_type path = directory.getPath(i->first);
 
      for (JDirectory::path_type::const_iterator dir = path.begin(); dir != path.end(); ++dir) {
        DEBUG(' ' << *dir);
      }
    }
 
    DEBUG(endl);
  }
 
  for (JDirectory::const_iterator i = directory.begin(); i != directory.end(); ++i) {
    ASSERT(directory.is_valid(i->first), "check validity " << i->first);
  }
 
  return 0;
}