cgp_codeprimitives.h

Go to the documentation of this file.

/*
  FAU Discrete Event Systems Library (libFAUDES)

  Copyright (C) 2010, 2016, 2017 Thomas Moor

*/



#ifndef FAUDES_CODEPRIMITIVES_H
#define FAUDES_CODEPRIMITIVES_H

#include "libfaudes.h"
#include "cgp_codegenerator.h"

using namespace faudes;



class CodePrimitives : public CodeGenerator {

public:

  /*****************************************
   *****************************************
   *****************************************
   *****************************************/

  CodePrimitives(void);

  virtual ~CodePrimitives(void);

  virtual void Clear(void);

protected:

  virtual void LiteralPrepend(void);

  virtual void DeclareStatus(void);

  virtual void DeclareReset(void);

  virtual void DeclareRecentEvent(void);

  virtual void DeclareParallelState(void);

  virtual void DeclarePendingEvents(void);

  virtual void DeclareLoopState(void);

  virtual void DeclareTimers(void);

  virtual void DeclareAux(void);

  virtual void DeclareLargeCarray(void);

  virtual void DeclareSmallCarray(void);

  virtual void DeclareEventNameLookup(void);

  virtual void DeclareStateNameLookup(void);

  virtual void ResetState(void);

  virtual void ResetReturn(void);

  virtual void SenseInputs(void);

  virtual void SenseTimerElapse(void);

  virtual void BeginExecutionLoop(void);

  virtual void UpdateEnabled(void);

  virtual void ScheduleEvent(void);

  virtual void BreakExecutionLoop(void);

  virtual void ExecuteEvent(void);

  virtual void OperateTimers(void);

  virtual void OperateOutputs(void);

  virtual void EndExecutionLoop(void);

  virtual void LiteralAppend(void);

  virtual void InsertExecHooks(void);

  virtual void ExecuteEventBySwitching(void);

  virtual void ExecuteEventByInterpreter(void);

  virtual void UpdateEnabledBySwitching(void);

  virtual void UpdateEnabledByInterpreter(void);

  class AA : public std::string {
  public:
    explicit AA(void) : std::string() {};
    explicit AA(std::string src) : std::string(src) {};
    AA Sub(int subscript) const { return AA(std::string(*this) + "_" + ToStringInteger(subscript));};
  };
  class AX : public std::string {
  public:
    explicit AX(void) : std::string() {};
    explicit AX(std::string src) : std::string(src) {};
  };
  virtual std::string TargetAddress(const AA& address)=0;
  virtual AX TargetExpression(const AA& address)=0;
  virtual std::string TargetSymbol(const std::string& str);

  virtual void IntegerDeclare(const AA& address) =0;
  virtual void IntegerDeclare(const AA& address, int val) =0;
  virtual void IntegerAssign(const AA& address, int val) =0;
  virtual void IntegerAssign(const AA& address, const AX& expression)=0;
  virtual void IntegerIncrement(const AA& address, int val=1)=0;
  virtual void IntegerDecrement(const AA& address, int val=1);
  virtual AX IntegerQuotient(const AX& expression, int val);
  virtual AX IntegerRemainder(const AX& expression, int val);
  virtual AX IntegerBitmask(const AX& expression);
  virtual AX IntegerIsEq(const AA& address, int val);
  virtual AX IntegerIsEq(const AA& address, const AX& expression);
  virtual AX IntegerIsNotEq(const AA& address, int val);
  virtual AX IntegerIsNotEq(const AA& address, const AX& expression);
  virtual AX IntegerIsGreater(const AA& address, int val);
  virtual AX IntegerIsLess(const AA& address, int val);
  virtual AX IntegerConstant(int val)=0;
  virtual bool HasIntmaths(void);
  virtual void WordDeclare(const AA& address);
  virtual void WordDeclare(const AA& address, word_t val);
  virtual void WordAssign(const AA& address, word_t val);
  virtual void WordAssign(const AA& address, const AX& expression);
  virtual void WordOr(const AA& address, word_t val);
  virtual void WordOr(const AA& address, const AX& expression);
  virtual void WordOr(const AA& address, const AA& op1, const AA& op2);
  virtual void WordOr(const AA& address, const AA& op1, word_t op2);
  virtual void WordAnd(const AA& address, word_t val);
  virtual void WordAnd(const AA& address, const AX& expression);
  virtual void WordAnd(const AA& address, const AA& op1, const AA& op2);
  virtual void WordAnd(const AA& address, const AA& op1, word_t op2);
  virtual void WordNand(const AA& address, const AX& expresson);
  virtual AX WordIsBitSet(const AA& address, int idx);
  virtual AX WordIsBitClr(const AA& address, int idx);
  virtual AX WordIsMaskSet(const AA& address, word_t mask);
  virtual AX WordIsEq(const AA& address, word_t val);
  virtual AX WordIsNotEq(const AA& address, word_t val);
  virtual AX WordConstant(word_t val);
  virtual void BooleanDeclare(const AA& address);
  virtual void BooleanDeclare(const AA& address, int val);
  virtual void BooleanAssign(const AA& address, int val);
  virtual void BooleanAssign(const AA& address, const AX& expression);
  virtual AX BooleanIsEq(const AA& op1, const AA& op2);
  virtual AX BooleanIsNotEq(const AA& op1, const AA& op2);
  virtual void CintarrayDeclare(const AA& address, int offset, const std::vector<int>& val);
  virtual AA CintarrayAccess(const AA& address, int index);
  virtual AA CintarrayAccess(const AA& address, const AA& indexaddr);
  virtual bool HasCintarray(void);
  virtual void CwordarrayDeclare(const AA& address, int offset, const std::vector<word_t>& val);
  virtual AA CwordarrayAccess(const AA& address, int index);
  virtual AA CwordarrayAccess(const AA& address, const AA& indexaddr);
  virtual bool HasCwordarray(void);
  virtual AX StringConstant(const std::string &val);
  virtual void CstrarrayDeclare(const AA& address, int offset, const std::vector<std::string>& val);
  virtual AA CstrarrayAccess(const AA& address, int index);
  virtual AA CstrarrayAccess(const AA& address, const AA& indexaddr);
  virtual bool HasCstrarray(void);
  virtual void IntarrayDeclare(const AA& address, int offset, int len);
  virtual void IntarrayDeclare(const AA& address, int offset, const std::vector<int>& val);
  virtual AA IntarrayAccess(const AA& address, int index);
  virtual AA IntarrayAccess(const AA& address, const AA& indexaddr);
  virtual bool HasIntarray(void);
  virtual void WordarrayDeclare(const AA& address, int offset, int len);
  virtual void WordarrayDeclare(const AA& address, int offset, const std::vector<word_t>& val);
  virtual AA WordarrayAccess(const AA& address, int index);
  virtual AA WordarrayAccess(const AA& address, const AA& indexaddr);
  virtual bool HasWordarray(void); 
  virtual void BitarrayDeclare(const AA& address, int blen);
  virtual void BitarrayDeclare(const AA& address, const std::vector<bool>& val);
  virtual void BitarrayAssign(const AA& address, const std::vector<bool>& val);
  virtual void BitarrayAssign(const AA& address, const AA& otherarray);
  virtual void BitarrayClear(const AA& address);
  virtual void BitarrayFull(const AA& address);
  virtual void BitarraySetBit(const AA& address, int bitaddr);
  virtual void BitarraySetBit(const AA& address, const AA& indexaddr, int offset=0, const std::vector<bool>& hint=std::vector<bool>() );
  virtual void BitarrayClrBit(const AA& address, int bitaddr);
  virtual void BitarrayClrBit(const AA& address, const AA& indexaddr, int offset=0, const std::vector<bool>& hint=std::vector<bool>() );
  virtual void BitarrayIsBitSet(const AA& address, const AA& indexaddr, const AA& result,int offset=0, const std::vector<bool>& hint=std::vector<bool>() );
  virtual void BitarrayOr(const AA& address, const std::vector<bool>& val);
  virtual void BitarrayOr(const AA& address, const AA& op1, const std::vector<bool>& op2);
  virtual void BitarrayOrAllWords(const AA& address, const AA& result);
  virtual void BitarrayAnd(const AA& address, const std::vector<bool>& val);
  virtual void BitarrayAnd(const AA& address, const AA& otherarray);
  virtual void BitarrayAnd(const AA& address, const AA& op1, const AA& op2);
  virtual void BitarrayAnd(const AA& address, const AA& op1, const std::vector<bool>& op2);
  virtual void BitarrayFindFirst(const AA& address, const AA& result, int offset=0);
  virtual void EventSetDeclare(const AA& address);
  virtual void EventSetDeclare(const AA& address, const EventSet& evset);
  virtual void EventSetAssign(const AA& address, const EventSet& evset);
  virtual void EventSetInsert(const AA& address, const EventSet& evset);
  virtual void EventSetInsert(const AA& address, Idx ev);
  virtual void EventSetInsert(const AA& address, const AA& evaddr);
  virtual void EventSetInsert(const AA& address, const AA& evaddr, const EventSet& hint);
  virtual void EventSetErase(const AA& address, const EventSet& evset);
  virtual void EventSetErase(const AA& address, Idx ev);
  virtual void EventSetErase(const AA& address, const AA& evaddr);
  virtual void EventSetErase(const AA& address, const AA& evaddr, const EventSet& hint);
  virtual void EventSetExists(const AA& address, const AA& evaddr, const AA& result, const EventSet& hint);
  virtual void EventSetRestrict(const AA& address, const AA& otherset);
  virtual void EventSetUnion(const AA& address, const AA& op1, const EventSet& op2);
  virtual void EventSetIntersection(const AA& address, const AA& op1, const EventSet& op2);
  virtual void EventSetClear(const AA& address);
  virtual void EventSetFull(const AA& address);
  virtual void EventSetIsNotEmpty(const AA& address, const AA& result);
  virtual void EventSetFindHighestPriority(const AA& address, const AA& result);
  virtual void IfTrue(const AX& expression);
  virtual void IfFalse(const AX& expression);
  virtual void IfWord(const AX& expression);
  virtual void IfElseIfTrue(const AX& expression);
  virtual void IfElse(void);
  virtual void IfEnd(void);

  virtual void SwitchBegin(const AA& address);
  virtual void SwitchCase(const AA& address, int val);
  virtual void SwitchCases(const AA& address, int from, int to);
  virtual void SwitchCases(const AA& address, const std::set< int>& vals);
  virtual void SwitchBreak(void);
  virtual void SwitchEnd(void);
  virtual bool HasMultiCase(void);

  virtual void LoopBegin(void);
  virtual void LoopBreak(const AX& expression);
  virtual void LoopEnd(void);

  virtual void FunctionReturn(void);
  virtual void RunActionSet(const std::string& address);
  virtual void RunActionClr(const std::string& address);
  virtual void RunActionExe(const AX& expression);

  virtual AX ReadInputLine(const std::string& address);
  virtual AX InputExpression(const std::string& expression);
  virtual void TimerDeclare(const AA& address, const std::string& litval);
  virtual void TimerStart(const AA& address);
  virtual void TimerStop(const AA& address);
  virtual void TimerReset(const AA& address, const std::string& litval);
  virtual AX TimerIsElapsed(const AA& address);
  virtual int StateTargetIdx(size_t git, Idx idx);
  virtual Idx StateFaudesIdx(size_t git, int idx);

  virtual void Comment(const std::string& text);

  virtual void VariableDeclare(const std::string& laddr, const std::string& ltype);
  virtual void VariableDeclare(const std::string& laddr, const std::string& ltype, const std::string& lval);


  /*****************************************
   *****************************************
   *****************************************
   *****************************************/

 protected:

  std::string mWordType;

  std::string mIntegerType;

  std::string mPrefix;  

  bool mArrayForTransitions;

  bool mMaintainStateIndices;

  bool mBitAddressArithmetic;
  
  bool mArrayForBitmasks;

  bool mArrayForBitarray;

  bool mBisectionForBitfind;

  bool mArrayForState;

  bool mEventsetsForPerformance;

  bool mLoopPendingInputs;

  bool mLoopEnabledOutputs;

  bool mStrictEventSynchronisation;

  bool mEventNameLookup;

  bool mStateNameLookup;

  std::vector<bool> mHasStateNames;

  bool mExistStateNames;

  std::string mEventExecutionHook;

  std::string mStateUpdateHook;

  std::string mLiteralPrepend;

  std::string mLiteralAppend;

  struct bitarray_rec {
    int blen;
    std::vector<bool> value;
  };
  std::map<std::string,bitarray_rec> mBitarrays;

  virtual void DoCompile(void);

  virtual void DoGenerate(void);

  virtual void DoGenerateDeclarations(void);

  virtual void DoGenerateResetCode(void);

  virtual void DoGenerateCyclicCode(void);

  virtual void DoReadTargetConfiguration(TokenReader& rTr);

  virtual void DoWriteTargetConfiguration(TokenWriter& rTw) const;

  private:

  template<class Data> void ConsolidateCaseRanges(std::map< int, Data>& caseData, std::map< int, int>& caseFromTo) {
    // prepare result
    caseFromTo.clear();
    // bail out
    if(caseData.empty()) return;
    // inititialise from-to-range to first case data record
    int fcase=caseData.begin()->first;
    int tcase=caseData.begin()->first;
    caseFromTo[fcase]=tcase;
    // loop over all other cases
    typename std::map< int, Data>::iterator cit=caseData.begin();
    for(++cit; cit!=caseData.end(); ++cit) {
      // current case condition
      int ccase = cit->first;
      // if we are meant to merge; and there is no gap; and the data matches ...
      if(HasMultiCase())
        if(tcase+1 == ccase)
          if(caseData[tcase]==caseData[ccase]) {
              // ... extend the range
              tcase=ccase;
              caseFromTo[fcase]=tcase;
              continue;
          }
      // so we did not want extend the range ... start a new range to extend
      fcase=ccase;
      tcase=ccase;
      caseFromTo[fcase]=tcase;
    }
  }

  template<class Data> void ConsolidateCaseSets(std::map< int, Data>& caseData, std::set< std::set< int > >& caseSets) {
    // prepare result
    caseSets.clear();
    // bail out
    if(caseData.empty()) return;
    // if we are not meant to consolidate, produce trivial sets
    if(!HasMultiCase()) {
      typename std::map< int , Data >::const_iterator dit=caseData.begin();
      for(; dit!=caseData.end(); ++dit) {
        std::set< int > sngl;
        sngl.insert(dit->first);
        caseSets.insert(sngl);
      }
      return;
    }
    // setup reverse map
    std::map< Data , std::set<int> > rmap;
    typename std::map< int , Data >::const_iterator dit=caseData.begin();
    for(; dit!=caseData.end(); ++dit)
      rmap[dit->second].insert(dit->first);
    // strip result
    typename std::map< Data , std::set<int> >::iterator rit=rmap.begin();
    for(; rit!=rmap.end(); ++rit)
      caseSets.insert(rit->second);
  }

 };


#endif