cgp_codegenerator.h

Go to the documentation of this file.

 
/*
 
  FAU Discrete Event Systems Library (libFAUDES)
 
  Copyright (C) 2010, 2016-2019 Thomas Moor
 
*/
 
 
 
#ifndef FAUDES_CODEGENERATOR_H
#define FAUDES_CODEGENERATOR_H
 
#include "libfaudes.h"
#include "cgp_eventconfig.h"
 
 
using namespace faudes;
 
// diagnostic macros for CodeGenerator and derived classes
#define FCG_VERB0(msg) { if(mVerbLevel>=0)  *pErrStream << msg << std::endl; }
#define FCG_VERB1(msg) { if(mVerbLevel>=1)  *pErrStream << msg << std::endl; }
#define FCG_VERB2(msg) { if(mVerbLevel>=2)  *pErrStream << msg << std::endl; }
#define FCG_ERR(msg)   { *pErrStream << msg << std::endl; throw Exception("CodeGenerator()","internal error", 500); }
 
// set version string (overwrite by build system)
#ifndef COMPILEDES_VERSION
#define COMPILEDES_VERSION "3.0x"
#endif
 
 
class CodeGenerator : public Type {
 
 
public:
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
  enum OutSink { CONSOLE, FILE, STRING };
 
 
  CodeGenerator(void);
 
  virtual ~CodeGenerator(void);
 
  virtual void Clear(void);
 
 
  virtual void Name(const std::string& rName) { mName=rName;};
 
  virtual const std::string& Name(void) const { return mName;};
 
  virtual void Compile(void);
 
  static std::string VersionString(void);
 
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
  Idx Size(void) const;
        
  void Insert(const std::string& file);
 
  void Insert(const TimedGenerator& rGen);
 
  const TimedGenerator& At(int i)  const { return mGenerators.at(i); };
 
  typedef std::vector<TimedGenerator>::const_iterator Iterator;
 
  Iterator Begin(void) const { return mGenerators.begin(); };
 
  Iterator End(void) const   { return mGenerators.end(); };
 
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
  Idx EventIndex(const std::string& rName) const { return mAlphabet.Index(rName); };
 
  std::string EventName(Idx index) const { return mAlphabet.SymbolicName(index); };
   
 
  const AttributeCodeGeneratorEvent& EventAttribute(Idx ev) const;
 
  void EventAttribute(Idx ev, const AttributeCodeGeneratorEvent& attr);
 
  void Alphabet(const cgEventSet& rAlphabet);
 
  const cgEventSet& Alphabet(void) const { return mAlphabet; };
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
  virtual int EventTargetIdx(Idx idx);
  
  virtual int EventTargetIdx(const std::string& ev);
 
  int EventBitAddress(Idx idx);
 
  Idx EventFaudesIdx(int idx);
 
  std::vector<bool> EventBitMask(Idx idx);
 
  std::vector<bool> EventBitMask(const EventSet& eset);
 
  int EventBitMaskSize(void);
 
  typedef unsigned long word_t;
 
  word_t WordFromBitVector(const std::vector<bool>& vect, int wordindex);
 
  std::vector< word_t > WordVectorFromBitVector(const std::vector<bool>& vect);
 
  std::vector<int> mWordAddressVector;
 
  std::vector<word_t> mBitMaskVector;
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
  const std::vector<int>& TransitionVector(size_t git);
 
  virtual int StateTargetIdx(size_t git, Idx idx);
 
  virtual Idx StateFaudesIdx(size_t git, int idx);
 
  struct LineAddress {
    std::string mAddress;    
    int mBitAddress;         
    EventSet mPosEvents;     
    EventSet mNegEvents;     
    EventSet mPosStatics;    
    EventSet mNegStatics;    
    bool mStatic;            
  };
  typedef std::map<std::string, LineAddress>::iterator LineIterator ;
  LineIterator LinesBegin();
  LineIterator LinesEnd();
 
  struct FlagExpression {
    std::string mAddress;
    EventSet mEvents;
  };
  // access to flag data
  typedef std::map<std::string, FlagExpression>::iterator FlagIterator ;
  FlagIterator FlagsBegin();
  FlagIterator FlagsEnd();
 
  struct TimerConfiguration {
    std::string mAddress;
    std::string mElapseEvent;
    std::string mInitialValue;
    EventSet mStartEvents;
    EventSet mStopEvents;
    EventSet mResetEvents;
  };
  typedef std::map<std::string, TimerConfiguration>::iterator TimerIterator ;
  TimerIterator TimersBegin();
  TimerIterator TimersEnd();
 
  struct ActionAddress {
    std::string mAddress;
    bool mSetClr;
    bool mExe;
  };
  typedef std::map<std::string, ActionAddress>::iterator ActionAddressIterator ;
  ActionAddressIterator ActionAddressesBegin();
  ActionAddressIterator ActionAddressesEnd();
 
  class TimerAction {
  public:
    std::set< std::string > mTimerStarts;
    std::set< std::string > mTimerStops;
    std::set< std::string > mTimerResets;
    bool operator==(const TimerAction& other) {
      if(!(mTimerStarts==other.mTimerStarts)) return false;
      if(!(mTimerStops==other.mTimerStops)) return false;
      if(!(mTimerResets==other.mTimerResets)) return false;
      return true;
    }
    bool operator<(const TimerAction& other) const {
      if(mTimerStarts<other.mTimerStarts) return true;
      if(mTimerStarts>other.mTimerStarts) return false;
      if(mTimerResets<other.mTimerResets) return true;
      if(mTimerResets>other.mTimerResets) return false;
      if(mTimerStops<other.mTimerStops) return true;
      return false;
    }
  };
  typedef std::map<std::string, TimerAction>::iterator TimerActionIterator ;
  TimerActionIterator TimerActionsBegin();
  TimerActionIterator TimerActionsEnd();
 
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
   virtual void Generate(void);
 
   void Verbose(int level, std::ostream* altout=0);
 
   virtual void OutputMode(const std::string& mode) {mOutMode=mode;};
 
 
   std::string OutputMode(void) { return mOutMode; }
 
 
   virtual std::ostream& Output(void);
 
 
   const std::string& OutputString(void);
 
 
   void OutputString(const std::string& strbuf);
 
 
   virtual void MuteMode(char mode);
 
   virtual void MuteCond(char mode);
 
   virtual void LineFeed(int lines=1);
 
   virtual std::string LineCount(void);
 
   virtual void IndentInc();
 
   virtual void IndentDec();
 
   virtual void Comment(const std::string& text);
 
   std::string RecentComment(void) {return mRecentMutedComment;};
 
   virtual void XmlTextEscape(bool on);
 
   virtual void XmlCdataEscape(bool on);
 
   virtual void MuteComments(bool on);
 
   virtual void MuteVspace(bool on);
 
   /*****************************************
    *****************************************
    *****************************************
    *****************************************/
 
    static void Register(const std::string& type, CodeGenerator* (*newcg)(void));
 
   static std::vector< std::string > Registry(void);
 
   static CodeGenerator* New(const std::string& type);
 
   template< class T > class Registration {
   public:
     Registration(const std::string& type) { CodeGenerator::Register(type,&New);};
     static CodeGenerator* New(void) { return new T();};
   };
 
   #define FAUDES_REGISTERCODEGENERATOR(ftype,ctype) static CodeGenerator::Registration<ctype> gRegister(ftype)
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
protected:
 
  std::string mName;
 
  std::vector<TimedGenerator> mGenerators;
 
  std::vector<std::string> mGeneratorNames;
 
  cgEventSet mAlphabet;   
 
  int mWordSize;
 
  int mIntegerSize;
 
  std::map<Idx,int> mEventBitAddress;
 
  std::map<int,Idx> mEventFaudesIdx;
 
  int mLastInputEvent;
 
  int mLastOutputEvent;
 
  std::vector< std::map<Idx,int> > mStateVectorAddress;
 
  std::vector< std::map<int,Idx> > mStateFaudesIndex;
 
  std::vector< bool > mUsingVectorAddressStates;
 
  std::vector< std::vector<int> > mTransitionVector;
 
  EventSet mUsedEvents;
 
  EventSet mOutputEvents;
 
  EventSet mInputEvents;
 
  EventSet mInternalEvents;
 
  std::map<std::string, LineAddress> mLines;
 
  std::map<std::string, FlagExpression> mFlags;
 
  std::map<std::string, TimerConfiguration> mTimers;
 
  std::map<std::string, ActionAddress> mActionAddresses;
 
  std::map<std::string, TimerAction> mTimerActions;
 
  int mVerbLevel;
 
  std::string mOutMode;
 
  char mMuteMode;
 
  bool mMuteComments;
 
  std::string mRecentMutedComment;
 
  std::ostream* pOutStream;
 
  std::ostream* pErrStream;
 
  virtual void DoCompile(void);
 
  virtual void DoGenerate(void) = 0;
 
  virtual void DoRead(TokenReader& rTr,const std::string& rLabel="", const Type* pContext=0);
 
 
  virtual void DoWrite(TokenWriter& rTw,const std::string& rLabel="", const Type* pContext=0) const;
 
  virtual void DoReadTargetConfiguration(TokenReader& rTr);
 
  virtual void DoWriteTargetConfiguration(TokenWriter& rTw) const;
 
private:
 
  // private data: code generator type registry
  static std::map< std::string, CodeGenerator* (*)(void) >* mpsRegistry;
 
  // private method: code organisation: read generators
  void DoReadGenerators(TokenReader& rTr);
 
  // private method: code organisation: write generators
  void DoWriteGenerators(TokenWriter& rTw) const;
 
 
  // cheap filtering streambuf for line-count/indentation/xml-escape
  class cgp_streambuf : public std::streambuf {
  public:
    // construct by dst filename (alt. "std::string" for string-buffer only, "std::cout" for console),
    cgp_streambuf(std::string mode);
    // destruct
    ~cgp_streambuf();
    // report
    int LineCount();
    // Indentation
    void IndentInc();
    void IndentDec();
    // control
    void Mute(bool on);
    bool Mute(void);
    void MuteVspace(bool on);
    void XmlTextEscape(bool on);
    void XmlCdataEscape(bool on);
    void Flush();
    // access
    const std::string& Buffer();
    void Clear(void);
 
  protected:
    // use overflow hook to see individual characters one by one
    // this is a perhaps inefficient but cheap way to build a filter
    // --- implementation assumes "char-8bit-ascii" output
    virtual int_type overflow (int_type c);
    // my config data
    std::string mBuffer;
    std::ostream* pOutStream;
    std::ofstream* mpFOutStream;
    std::stringstream* mpSOutStream;
    std::string mMode;
    int mLines;
    bool mBeginOfLine;
    int mIndent;
    bool mMute;
    bool mMuteVspace;
    bool mTextEscape;
    bool mCdataEscape;
    
  };
 
  // private instance
  cgp_streambuf* pOutBuffer;
 
 
};
 
 
#endif