cgp_iec61131st.h

Go to the documentation of this file.

/*
  FAU Discrete Event Systems Library (libFAUDES)

  Copyright (C) 2010, 2016, 2017 Thomas Moor

*/



#ifndef FAUDES_IEC61131stCode_H
#define FAUDES_IEC61131stCode_H

#include "libfaudes.h"
#include "cgp_codeprimitives.h"

using namespace faudes;



class Iec61131stCodeGenerator : public CodePrimitives {

public:

  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
  enum IECVariableType { LOCAL, TEMP, INPUT, OUTPUT, INOUT, EXTERNAL, GLOBAL, ACCESS, NONE };


  Iec61131stCodeGenerator(void);

  virtual ~Iec61131stCodeGenerator(void);


  virtual void Clear(void);


protected:

  std::string mIecDeclarePhysical;

  bool mHasIecTimeOperators;

  std::string mLiteralCyclic;

  void DoCompile(void);

  void DoGenerate(void);

  virtual void DoGenerateFunction(void);

  virtual void DoGenerateLookups(void);

  virtual void DecrementTimers(void);

  void BeginCyclicCode(void);

  void EndCyclicCode(void);

  virtual std::string TargetAddress(const AA& address);

  virtual AX TargetExpression(const AA& address);


   /* re-implement primitives */
  virtual void Comment(const std::string& text);

  /* re-implement primitives */
  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);

  /* re-implement primitives */
  virtual void IntegerDeclare(const AA& address);
  virtual void IntegerDeclare(const AA& address, int val);
  virtual void IntegerAssign(const AA& address, int val);
  virtual void IntegerAssign(const AA& address, const AX& expression);
  virtual void IntegerIncrement(const AA& address, int val);
  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);

  /* re-implement primitives */
  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& expression);
  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);

  /* re-implement primitives */
  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);

  /* re-implement primitives */
  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 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);


  /* re-implement primitives */
  virtual void IfTrue(const AX& expression);
  virtual void IfFalse(const AX& expression);
  virtual void IfWord(const AX& expression);
  virtual void IfElse(void);
  virtual void IfElseIfTrue(const AX& expression);
  virtual void IfEnd(void);

  /* re-implement primitives */
  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);

  /* re-implement primitives */
  virtual void LoopBegin(void);
  virtual void LoopBreak(const AX& expression);
  virtual void LoopEnd(void);
  virtual void FunctionReturn(void);


  /* re-implement primitives */
  virtual void RunActionSet(const std::string& address);
  virtual void RunActionClr(const std::string& address);
  virtual void RunActionExe(const AX& expression);

  /* re-implement primitives */
  virtual void TimerDeclare(const AA& address, const std::string& val);
  virtual void TimerStart(const AA& address);
  virtual void TimerStop(const AA& address);
  virtual void TimerReset(const AA& address, const std::string& val);
  virtual AX TimerIsElapsed(const AA& address);

  /* re-implement primitives */
  virtual void DeclareTimers(void);
  virtual void ResetState(void);


  /* code generator primitives, iec-specific helper */
  virtual AX TimeConstant(int val);
  virtual AX IntarrayConstant(const std::vector<int>& val);
  virtual AX WordarrayConstant(const std::vector<word_t>& val);
  virtual AX StringConstant(const std::string& val);
  virtual AX StrarrayConstant(const std::vector<std::string>& val);

  virtual void DeclareImportPhysicalIo(void);
  virtual void DeclareImportSymbolicIo(void);
  virtual int CountImportPhysicalIo(void);
  virtual int CountImportSymbolicIo(void);
  virtual void LiteralCyclic(void);
  virtual void DeclareSystime(void);
  virtual void UpdateSystime(void);
  virtual void InsertExecHooks(void);



  virtual void DoReadTargetConfiguration(TokenReader& rTr);

  virtual void DoWriteTargetConfiguration(TokenWriter& rTw) const;

  void CurrentVariableType(const IECVariableType& type);
  IECVariableType CurrentVariableType(void);

private:
  IECVariableType mCurrentVariableType;
  bool mDeclareIOVars;

};


#endif