? ? ? ? ? ?

---

cmtshowuses.cxx

Go to the documentation of this file.

#include "Package.h"
#include "tree_node.h"
#include "dot.h"

static bool debug ()
{
  static bool state = ::getenv ("CMTGRAPHERDEBUG");

  return (state);
}

/*
void qsort ( void* base, 
             size_t num, 
             size_t width, 
             int (*compare)(const void* elem1, const void* elem2));
*/


class UsesGraphBuilder : public PAwk
{
  public:

  UsesGraphBuilder (const cmt_string& package,
                    const cmt_string& version,
                    const cmt_string& path)
  {
    //
    // A tree starting from the specified package is built.
    //
    Package& p = Package::create (package, version, path);
    top_node.set (0, &p);
  }

  void start (bool collapse, const cmt_string& tags)
  {
    cmt_string command = "cmt.exe show uses -use=";

    const Package* p = top_node.get_package ();

    command += p->get_name ();
    command += ":";
    command += p->get_version ();
    if (p->get_path () != "")
      {
        command += ":";
        command += p->get_path ();
      }

    if (tags != "")
      {
        command += " -tag=";
        command += tags;
      }

    do_collapse = collapse;
    m_tags = tags;
    
    run (command);
  }

  void begin ()
  {
  }

  void filter (const cmt_string& line)
  {
    if (debug ())
      {
        cout << "filter> [" << line << "]" << endl;
      }

    bool in_use = true;

    if (line[0] != '#') return;

    CmtSystem::cmt_string_vector words;

    CmtSystem::split (line, " ", words);

    if (words[1] == "use")
      {
        // this is a normal use specification
        in_use = true;
      }
    else if (words[1] == "package")
      {
        // this happens when a package is not found
        in_use = false;
      }
    else 
      {
        //
        // This should never happen but we ignore it just in case.
        // We only consider lines starting with
        //     # use ...
        // or  # package ...
        //
        return;
      }

    cmt_string package;
    cmt_string version;
    cmt_string path;

    if (words.size () > 2) package = words[2];
    if (words.size () > 3) version = words[3];
    if (words.size () > 4) 
      {
        path = words[4];

        if ((path == "(no_version_directory)") ||
            (path == "(private)") ||
            (path == "(no_auto_imports)") ||
            (path.find ("(native_version=" == 0)))
          {
            path = "";
          }
      }

    if (package == "CMT") path = "";

    Package& p = Package::create (package, version, path);

    for (int i = 2; i < words.size (); ++i)
      {
        const cmt_string& w = words[i];

        if (w == "(no_version_directory)")
          {
            p.set_has_version_directory (false);
          }
        else if (w == "(private)")
          {
            p.set_is_public (false);
          }
        else if (w == "(no_auto_imports)")
          {
            p.set_auto_imports (false);
          }
        else if (w.find ("(native_version=") == 0)
          {
          }
      }

    p.set_done ();

    tree_node* current_node = &top_node;

    if (debug ())
      {
        cout << "filter> 1-current_node=" << current_node->get_name () << endl;
      }

    if (in_use)
      {
        //
        // count the number of spaces before "use"
        //   . the usual syntax from cmt show uses starts with "# "
        //   . then each sublevel is indented by 2 spaces
        // deduce from it the level in the tree
        //

        int level = line.find ("use");
        level -= 2;
        level /= 2;

        //
        // move down the tree. At each level, we consider the last entry (ie. back ())
        // since indentation is always relative to the current package.
        //
        for (int i = 0; i < level; i++)
          {
            tree_node* n = current_node->get_last_sub_node ();
            if (n != 0)
              {
                current_node = n;

                if (debug ())
                  {
                    cout << "filter> 2-current_node=" << current_node->get_name () << endl;
                  }
              }
            else
              {
                break;
              }
          }
      }

    if (debug ())
      {
        cout << "filter> 3-current_node=" << current_node->get_name () << endl;
      }

    if (current_node->check_cycle (p))
      {
        cout << "cycle detected between packages " << 
            current_node->get_name () <<
            " and " << p.get_name () << endl;
          //return;
      }

    current_node->install_as_reference_node ();

    current_node->append (p);

    if (!in_use)
      {
        //
        // This package is specified in the use list but not reachable
        //

        p.set_unreachable ();
        return;
      }

    if (package == "CMT") cmt = &p;
  }

  tree_node& get_top_node ()
  {
    return (top_node);
  }

  void end ()
  {
    DotGenerator generator;

    generator.run (top_node, "forward", do_collapse, m_tags);
  }


  private:
  tree_node top_node;
  Package* cmt;
  bool do_collapse;
  cmt_string m_tags;
};

int main (int argc, char* argv[])
{
  bool collapse = false;
  cmt_string tags;
  
  if (argc < 3) 
    {
      cerr << "cmtshowuses.exe [-collapse]   [] " << endl;
      return (1);
    }
  
  cmt_string option;
  cmt_string p;
  cmt_string v;
  cmt_string pp;

  for (;;)
    {
      option = argv[1];
      if (option[0] == '-')
        {
          if (option == "-collapse")
            {
              collapse = true;
              argv++;
              argc--;
            }
          else if (option.substr (0, 5) == "-tag=")
            {
              option.erase (0, 5);
              tags = option;

              argv++;
              argc--;
            }
        }
      else
        {
          p = argv[1];
          v = argv[2];
          if (argc >= 3) pp = argv[3];

          break;
        }
    }
  
  UsesGraphBuilder builder (p, v, pp);
  
  builder.start (collapse, tags);
  
  return (0);
}

---