NewExprTree.hpp

Go to the documentation of this file.

#ifndef NewExprTree_H
#define NewExprTree_H
#include <set>
#include <map>

// OpenAnalysis headers
#include <OpenAnalysis/IRInterface/IRHandles.hpp>
#include <OpenAnalysis/Utils/OA_ptr.hpp>
#include <OpenAnalysis/Utils/Tree.hpp>
#include <OpenAnalysis/IRInterface/ConstValBasicInterface.hpp>
#include <OpenAnalysis/IRInterface/OpBasicInterface.hpp>
#include <OpenAnalysis/MemRefExpr/MemRefExpr.hpp>

#include <OpenAnalysis/ExprTree/ExprTree.hpp>

namespace OA {
using namespace std;

class NewExprTree;

// to avoid circular reference in header files
class NewExprTreeVisitor;



//--------------------------------------------------------------------
  class NewExprTree : public ExprTree {
public:
  class Node;
  class Edge;

public:
  NewExprTree();
  virtual ~NewExprTree();
  
  OA_ptr<Node>  getRoot() { 
    OA_ptr<Tree::Node> n = Tree::getRoot();
    return n.convert<Node>(); 
  }


  void acceptVisitor(NewExprTreeVisitor& pVisitor);

  //-------------------------------------
  // construction
  //-------------------------------------
  void connect(OA_ptr<Node> src, OA_ptr<Node> dst) 
      { OA_ptr<Edge> e; e = new Edge(src,dst); addEdge(e); }
  void disconnect(OA_ptr<Edge> e) { removeEdge(e.convert<Tree::Edge>()); }
  void copyAndConnectSubTree(OA_ptr<Node> src, OA_ptr<NewExprTree> subtree);
  

  //*****************************************************************
  // Ordering Operations
  //*****************************************************************
  // an ordering for expression trees, needed for use within STL containers
  bool operator<(NewExprTree &rhs);
  bool operator==(NewExprTree &rhs);
private:
  bool compareTreesRootedAt(OA_ptr<Node> rootLHS, OA_ptr<Node> rootRHS);
public:

  //--------------------------------------------------------
  class Node : public Tree::Node {
  public:
    Node()
      : Tree::Node() { }
    Node(const std::string& x)
      : Tree::Node(), mName(x) { }
    virtual ~Node() { }
    
    // A name for this node (useful for debugging)
    std::string& getName() { return mName; }

    virtual OA_ptr<Node> copy() = 0;

    virtual bool isaOpNode() { return false; }
    virtual bool isaCallNode() { return false; }
    virtual bool isaMemRefNode() { return false; }
    virtual bool isaConstSymNode() { return false; }
    virtual bool isaConstValNode() { return false; }

    // NOTE: could give this a default implementation if wanted to
    // have ExprTree visitors have default implementation for nodes
    // they don't know about
    virtual void acceptVisitor(NewExprTreeVisitor&) = 0;
    virtual void dump(std::ostream& os) { Tree::Node::dump(os); }
    virtual void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    virtual void output(IRHandlesIRInterface& ir) { Tree::Node::output(ir); }
   
    //*****************************************************************
    // Ordering Operations
    //*****************************************************************
    virtual bool operator<(Node& rhs) = 0;
    virtual int getOrder() = 0;

  private:
    std::string mName;
    //std::string mAttr;
  }; // end of Node

  class OpNode : public Node {
  public:
    OpNode() : Node("OpNode") { }
    OpNode(OA_ptr<OpBasicInterface> op) : Node("OpNode"), mOpInterface(op) {}
    virtual ~OpNode() { }

    OA_ptr<Node> copy() 
      { OA_ptr<Node> ret; ret = new OpNode(mOpInterface); return ret; }

    bool isaOpNode() { return true; }
    OA_ptr<OpBasicInterface> getOpInterface() { return mOpInterface; }
    void dump(std::ostream& os) { Node::dump(os); }
    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

    void acceptVisitor(NewExprTreeVisitor& pVisitor);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir);

    //*****************************************************************
    // Ordering Operations
    //*****************************************************************
    bool operator<(Node& rhs);
    bool operator<(OpNode& rhs);
    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 100;
    OA_ptr<OpBasicInterface> mOpInterface;
  };

  class CallNode : public Node {
  public:
    CallNode() : Node("CallNode") { }
    CallNode(CallHandle h) : Node("CallNode"), mHandle(h) {}
    virtual ~CallNode() { }

    OA_ptr<Node> copy() 
      { OA_ptr<Node> ret; ret = new CallNode(mHandle); return ret; }

    bool isaCallNode() { return true; }
    CallHandle getHandle() { return mHandle; }
    void dump(std::ostream& os) { Node::dump(os); }
    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

    void acceptVisitor(NewExprTreeVisitor& pVisitor);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir) ;

    //*****************************************************************
    // Ordering Operations
    //*****************************************************************
    bool operator<(Node& rhs);
    bool operator<(CallNode& rhs);
    virtual int getOrder() { return sOrder; }

  private:
    //Changed from ExprHandle to CallHandle by LMR. 6.8.06
     static const int sOrder = 500;
     CallHandle mHandle;
  };

  class MemRefNode : public Node {
  public:
    MemRefNode() : Node("MemRefNode") { }
    MemRefNode(OA_ptr<MemRefExpr> mre) : Node("MemRefNode"), mMRE(mre) {}
    virtual ~MemRefNode() { }

    OA_ptr<Node> copy() 
      { OA_ptr<Node> ret; ret = new MemRefNode(mMRE); return ret; }

    bool isaMemRefNode() { return true; }
    OA_ptr<MemRefExpr> getMRE() { return mMRE; }
    void dump(std::ostream& os) { Node::dump(os); }
    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

    void acceptVisitor(NewExprTreeVisitor& pVisitor);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir) ;

    //*****************************************************************
    // Ordering Operations
    //*****************************************************************
    bool operator<(Node& rhs);
    bool operator<(MemRefNode& rhs);
    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 200;
    OA_ptr<MemRefExpr> mMRE;
  };

  class ConstSymNode : public Node {
  public:
    ConstSymNode() : Node("ConstSymNode") { }
    ConstSymNode(ConstSymHandle h) : Node("ConstSymNode"), mHandle(h) {}
    virtual ~ConstSymNode() { }

    OA_ptr<Node> copy() 
      { OA_ptr<Node> ret; ret = new ConstSymNode(mHandle); return ret; }

    bool isaConstSymNode() { return true; }
    ConstSymHandle getHandle() { return mHandle; }
    void dump(std::ostream& os) { Node::dump(os); }
    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

    void acceptVisitor(NewExprTreeVisitor& pVisitor);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir) ;

    //*****************************************************************
    // Ordering Operations
    //*****************************************************************
    bool operator<(Node& rhs);
    bool operator<(ConstSymNode& rhs);
    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 300;
    ConstSymHandle mHandle;
  };

  class ConstValNode : public Node {
  public:
    ConstValNode() : Node("ConstValNode") { }
    ConstValNode(OA_ptr<ConstValBasicInterface> constInter) :
        Node("ConstValNode"),
        mConstValInter(constInter)
    { }
    virtual ~ConstValNode() { }

    OA_ptr<Node> copy() 
      { OA_ptr<Node> ret; ret = new ConstValNode(mConstValInter); return ret; }

    bool isaConstValNode() { return true; }
    OA_ptr<ConstValBasicInterface> getConstValInterface() {
        return mConstValInter;
    }
    void dump(std::ostream& os) { Node::dump(os); }
    void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);

    void acceptVisitor(NewExprTreeVisitor& pVisitor);

    //*****************************************************************
    // Annotation Interface
    //*****************************************************************
    void output(IRHandlesIRInterface& ir) ;

    //*****************************************************************
    // Ordering Operations
    //*****************************************************************
    bool operator<(Node& rhs);
    bool operator<(ConstValNode& rhs);
    virtual int getOrder() { return sOrder; }

  private:
    static const int sOrder = 400;
    OA_ptr<ConstValBasicInterface> mConstValInter;
  };
  
  //--------------------------------------------------------
  class Edge : public Tree::Edge {
  public:
    Edge(OA_ptr<Node> n1, OA_ptr<Node> n2)
      : Tree::Edge(n1, n2) { }
    virtual ~Edge() { }
    
    // included here to return subclass node type
    OA_ptr<Node>  parent () const { 
      OA_ptr<Tree::Node> n = Tree::Edge::parent();
      return n.convert<Node>();
    }
    OA_ptr<Node>  source () const { return parent(); }
    OA_ptr<Node>  tail () const { return parent(); }
    OA_ptr<Node>  child () const { 
      OA_ptr<Tree::Node> n = Tree::Edge::child();
      return n.convert<Node>(); 
    }
    OA_ptr<Node>  sink () const { return child(); }
    OA_ptr<Node>  head () const { return child(); }

    void dump(std::ostream& os);
    void dump() { dump(std::cout); }

  private:
  };  
  //--------------------------------------------------------
  
  //------------------------------------------------------------------
  class NodesIterator : public Tree::NodesIterator {
  public:
    NodesIterator (Tree& t) : Tree::NodesIterator(t) {}
    virtual ~NodesIterator () {}
    OA_ptr<Node>  current() const { 
      OA_ptr<Tree::Node> n = Tree::NodesIterator::current();
      return n.convert<Node>(); 
    }
  };
  
  //------------------------------------------------------------------
  class EdgesIterator : public Tree::EdgesIterator {
  public:
    EdgesIterator (Tree& t) : Tree::EdgesIterator(t) {}
    virtual ~EdgesIterator () {}
    OA_ptr<Edge>  current() const { 
      OA_ptr<Tree::Edge> e = Tree::EdgesIterator::current();
      return e.convert<Edge>(); 
    }
  };

  //------------------------------------------------------------------
  class OutEdgesIterator : public Tree::OutEdgesIterator {
  public:
    OutEdgesIterator (Node&  n) : Tree::OutEdgesIterator(n) {}
    virtual ~OutEdgesIterator () {}
    OA_ptr<Edge>  current() const { 
      OA_ptr<Tree::Edge> e = Tree::OutEdgesIterator::current();
      return e.convert<Edge>(); 
    }
  };
  
  //------------------------------------------------------------------
  class ChildNodesIterator : public Tree::ChildNodesIterator {
  public:
    ChildNodesIterator (Node&  n) : Tree::ChildNodesIterator(n) {}
    ~ChildNodesIterator () {}
    OA_ptr<Node>  current() const { 
      OA_ptr<Tree::Node> n = Tree::ChildNodesIterator::current();
      return n.convert<Node>();
    }
  };
 
  void str(std::ostream& os);
  
  void dump(std::ostream& os, OA_ptr<IRHandlesIRInterface> ir);
  //void dump() { dump(std::cout); }

  //*****************************************************************
  // Annotation Interface
  //*****************************************************************
  void output(IRHandlesIRInterface& ir) ;

  //------------------------------------------------------------------
  class PreOrderIterator : public Tree::PreOrderIterator {
  public:
    PreOrderIterator (Tree& t) : Tree::PreOrderIterator(t) {}
    virtual ~PreOrderIterator () {}
    OA_ptr<Node>  current() const { 
      OA_ptr<Tree::Node> n = PreOrderIterator::current();
      return n.convert<Node>();
    }
  };
  //------------------------------------------------------------------
  class PostOrderIterator : public Tree::PostOrderIterator {
  public:
    PostOrderIterator (Tree& t) : Tree::PostOrderIterator(t) {}
    virtual ~PostOrderIterator () {}
    OA_ptr<Node>  current() const { 
      OA_ptr<Tree::Node> n = PostOrderIterator::current();
      return n.convert<Node>();
    }
  };
  //------------------------------------------------------------------
  class ReversePostOrderIterator : public Tree::ReversePostOrderIterator {
  public:
    ReversePostOrderIterator (Tree& t) : Tree::ReversePostOrderIterator(t) {}
    virtual ~ReversePostOrderIterator () {}
    OA_ptr<Node>  current() const { 
      OA_ptr<Tree::Node> n = Tree::ReversePostOrderIterator::current();
      return n.convert<Node>(); 
    }
  };
 //--------------------------------------------------------------------
};


} // end of OA namespace

#endif