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;
 
  std::string mIecDeclareSymbolic;
 
  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