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