EntryFunctionContainer.h

Go to the documentation of this file.

//===-- src/EntryFunctionContainer.h - systec-clang class definition -------*-
// C++ -*-===//
//
//                     systemc-clang: SystemC Parser
//
// This file is distributed under the University of Illinois License.
// See LICENSE.mkd for details.
//
//===----------------------------------------------------------------------===//
//===----------------------------------------------------------------------===//
#ifndef _ENTRY_FUNCTION_CONTAINER_H_
#define _ENTRY_FUNCTION_CONTAINER_H_
 
#include <map>
#include <string>
#include "FindNotify.h"
#include "SensitivityMatcher.h"
#include "FindWait.h"
//#include "NotifyContainer.h"
#include "SuspensionAutomata.h"
#include "Utility.h"
//#include "WaitContainer.h"
//#include "clang/AST/DeclCXX.h"
 
namespace clang {
  class ValueDecl;
  class MemberExpr;
  class VarDecl;
  class ArraySubscriptExpr;
  class Stmt;
  class CXXMethodDecl;
  class Expr;
};
 
 
namespace systemc_clang {
 
  //
  //
  class WaitContainer;
  class NotifyContainer;
 
enum class ASTSTATE {
  EMPTY,
  DECLSTMT,
  MEMBEREXPR,
  CXXOPERATORCALLEXPR,
  CXXCONSTRUCTEXPR
};  // End enum ASTSTATE
 
enum class ReadWrite { RWINIT, READ, WRITE };  // End enum ReadWrite
 
enum class PROCESS_TYPE {
  NONE,
  THREAD,
  CTHREAD,
  METHOD
};  // End enum PROCESS_TYPE
 
class EntryFunctionContainer {
 public:
  typedef std::vector<WaitContainer *> waitContainerListType;
  typedef std::vector<NotifyContainer *> notifyContainerListType;
 
  typedef std::pair<int, SuspensionAutomata::transitionVectorType>
      instanceSautoPairType;
  typedef std::map<int, SuspensionAutomata::transitionVectorType>
      instanceSautoMapType;
 
  typedef std::pair<int, SuspensionAutomata::susCFGVectorType>
      instanceSusCFGPairType;
  typedef std::map<int, SuspensionAutomata::susCFGVectorType>
      instanceSusCFGMapType;
 
  // Sensitivity information
  typedef std::tuple<std::string, clang::ValueDecl *, clang::MemberExpr *,
                     clang::VarDecl*, clang::ArraySubscriptExpr *, clang::ForStmt *>
      SensitivityTupleType;
  typedef std::pair<std::string, std::vector<SensitivityTupleType>>
      SensitivityPairType;
 
  typedef std::map<std::string, std::vector<SensitivityTupleType>> SenseMapType;
 
  EntryFunctionContainer();
  EntryFunctionContainer(std::string, PROCESS_TYPE, clang::CXXMethodDecl *,
                         clang::Stmt *);
  EntryFunctionContainer(const EntryFunctionContainer &);
 
  virtual ~EntryFunctionContainer();
 
  // Accessors.
  std::string getName();
  clang::CXXMethodDecl *getEntryMethod();
  // Stmt *getConstructorStmt ();
  PROCESS_TYPE getProcessType();
 
  waitContainerListType getWaitCalls();
  notifyContainerListType getNotifyCalls();
  SenseMapType getSenseMap();
  SuspensionAutomata::susCFGVectorType getSusCFG();
  SuspensionAutomata::transitionVectorType getSusAuto();
  instanceSautoMapType getInstanceSautoMap();
  instanceSusCFGMapType getInstanceSusCFGMap();
 
  // Add waits.
  // void addSensitivityInfo(FindSensitivity &);
  void addSensitivityInfo(SenseMapType &);
  void addWaits(FindWait &);
  void addNotifys(FindNotify &);
  void addSusCFGAuto(SuspensionAutomata &);
  // void setConstructorStmt (Stmt *);
  void setName(std::string);
  void setProcessType(PROCESS_TYPE);
  void setEntryMethod(clang::CXXMethodDecl *);
  void dumpSusCFG(llvm::raw_ostream &);
  void dumpSauto(llvm::raw_ostream &);
  void dump(llvm::raw_ostream &);
 
 
  // Reset signal handling
  void addResetSignal(std::pair<std::string, const clang::Expr*> reset_signal);
  void addResetEdge(std::pair<std::string, const clang::Expr*> reset_edge);
  void addResetType(bool reset_type);
 
  const std::pair<std::string, const clang::Expr*> getResetSignal() const;
  const std::pair<std::string, const clang::Expr*> getResetEdge() const;
  bool isResetAsync() const;
 
 
  // private:
  std::string entry_name_;
  PROCESS_TYPE process_type_;
  clang::CXXMethodDecl *entry_method_decl_;
 
  // Hold all the waits.
  waitContainerListType _waitCalls;
  notifyContainerListType _notifyCalls;
 
  // Sensitivity information
  SenseMapType senseMap_;
 
  std::vector<Transition *> _susAuto;
  std::vector<SusCFG *> _susCFG;
 
  std::pair<std::string, const clang::Expr*> reset_signal_;
  std::pair<std::string, const clang::Expr*> reset_edge_;
  bool reset_type_async_;
 
 
};
}  // namespace systemc_clang
#endif