/local/lecs/lecs/risc_v0.4.0/sources/build/risc_v0.4.0/src/segment_graph/vertex_property_writer.h

Go to the documentation of this file.

#ifndef VERTEX_PROPERTY_WRITER_H_INCLUDED_
#define VERTEX_PROPERTY_WRITER_H_INCLUDED_

#include "rose.h"

#include "segment_graph.h"

namespace risc {

namespace sg {

struct VertexPropertyWriter {

  static bool print_read_write_access;

  VertexPropertyWriter(Graph& graph);

  template <class Vertex>
  void operator() (std::ostream &out, Vertex v)
  {
    out << "[shape=record,label=\"{ Segment ID: " << graph_[v].id_;

    if(graph_[v].boundary_node_) {
      std::string unparsed_stmt = graph_[v].boundary_node_->unparseToString();

      replace_escape_characters(unparsed_stmt);

      std::string temp =
        StringUtility::stripPathFromFileName(
            graph_[v].boundary_node_->get_file_info()->get_raw_filename());

      out << " (" << temp << ":"
          << graph_[v].boundary_node_->get_file_info()->get_line() << ")";

      // Here we writing the comment which is associated with the boundary
      // in the segment head
      const SgLocatedNode *located_node =
        isSgLocatedNode(graph_[v].boundary_node_);

      AttachedPreprocessingInfoType *comments =
        const_cast<SgLocatedNode*>(
            located_node)->getAttachedPreprocessingInfo();

      if(comments != NULL) {

        // We are iterating over all associated comments, however, we print
        // only the comment which is in the same line like the boundary
        // statement
        for(AttachedPreprocessingInfoType::iterator
            i  = comments->begin();
            i != comments->end();
            i++) {

          if(located_node->get_file_info()->get_line()
              == (*i)->getLineNumber()) {

            // parsing out the '//' at the beginning
            std::string str = (*i)->getString().substr(2,
                                                  (*i)->getString().length()-2);

            // deleting the line break break at the end
            str.erase(std::remove(str.begin(), str.end(), '\n'), str.end());
            out << "  " << str;
          }
        }
      }
    } else {

      SgNode *first_node = NULL;
      if(graph_[v].expressions_.size() != 0) {

        first_node = *(graph_[v].expressions_.begin());

        if(first_node) {
          SgFunctionDefinition *func_def =
            SageInterface::getEnclosingFunctionDefinition(first_node);

          if(func_def) {

            SgClassDefinition *class_def =
              SageInterface::getEnclosingClassDefinition(func_def);

            if(class_def) {

              out << " [" << SageInterface::get_name(class_def)
                  << "::" << SageInterface::get_name(func_def) << "]";
            }
          }
        }
      }
// Only for communication graphs
//      out << "  INIT";
    }

    if(!VertexPropertyWriter::print_read_write_access) {
      for(Segment::Expressions::iterator
          expr_iter  = graph_[v].expressions_.begin();
          expr_iter != graph_[v].expressions_.end();
          expr_iter++) {

        std::string unparsed_stmt = (*expr_iter)->unparseToString();

        replace_escape_characters(unparsed_stmt);

        std::string temp =
          StringUtility::stripPathFromFileName(
            (*expr_iter)->get_file_info()->get_raw_filename());

// Only for communication graphs
//        if(isSgFunctionCallExp((*expr_iter))) {
          out << "|" << temp << ":"
              << (*expr_iter)->get_file_info()->get_line() << " "
              << unparsed_stmt << "\\l";
//        }
      }
    } else {

      // printing write variables
      for(std::list<SgVariableSymbol*>::iterator
          var_symbol_iter  = graph_[v].write_variables_.begin();
          var_symbol_iter != graph_[v].write_variables_.end();
          var_symbol_iter++) {

        out << "| (W) "
            << SageInterface::get_name(*var_symbol_iter).erase(
                   SageInterface::get_name(*var_symbol_iter).length() - 8)
            << "\\l";
      }

      // printing read variables
      for(std::list<SgVariableSymbol*>::iterator
          var_symbol_iter  = graph_[v].read_variables_.begin();
          var_symbol_iter != graph_[v].read_variables_.end();
          var_symbol_iter++) {

        out << "| (R) "
            << SageInterface::get_name(*var_symbol_iter).erase(
                   SageInterface::get_name(*var_symbol_iter).length() - 8)
            << "\\l";
      }
    }

    out << "}\"]";

    /*
      // This is an alternative output strategy. Basically, everything is
      // represented in a (HTML) table, however, in my point of view it is
      // incredible ugly!
      out << "  [" << std::endl;
      out << "  shape = none" << std::endl;
      out << "  label = <<table border=\"1\" cellspacing=\"0\">" << std::endl;
      out << "            <tr><td>" << "ID: " << v << "</td></tr>" << std::endl;

      for(Segment::Statements::iterator
          stmt_iter  = graph_[v].statements_.begin();
          stmt_iter != graph_[v].statements_.end();
          stmt_iter++) {

        std::string unparsed_stmt = (*stmt_iter)->unparseToString();

        replace_escape_characters(unparsed_stmt);

        out << "            <tr><td>" << unparsed_stmt << "</td></tr>"
                                                       << std::endl;
      }
      out << "          </table>>" << std::endl;
      out << "  ]" << std::endl;
    */
  }

  void replace_escape_characters(std::string &unparsed_stmt);

  Graph& graph_;

  friend std::ostream& operator<< (std::ostream &out,
                           const VertexPropertyWriter &vpw)
  {
    return out;
  }
};

}; // end of namespace sg

}; // end of namespace risc

#endif /* VERTEX_PROPERTY_WRITER_H_INCLUDED_ */

/* ex: set softtabstop=2 tabstop=2 shiftwidth=2 expandtab: */

---