/local/lecs/lecs/risc_v0.2.0/build/risc_v0.2.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 "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() << ")";
    } 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) << "]";
            }
          }
        }
      }
    }

    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());

        out << "|" << temp << ":"
            << (*expr_iter)->get_file_info()->get_line() << " "
            << unparsed_stmt << "\\l";
      }
    } else {

      // printing write variables
      for(std::set<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::set<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: */

---