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