cgp_embeddedc.h

Go to the documentation of this file.

 
/*
  FAU Discrete Event Systems Library (libFAUDES)
 
  Copyright (C) 2010, 2016 Thomas Moor
 
*/
 
 
 
#ifndef FAUDES_EMBEDDEDC_H
#define FAUDES_EMBEDDEDC_H
 
#include "libfaudes.h"
#include "cgp_codeprimitives.h"
 
using namespace faudes;
 
 
 
class EmbeddedcCodeGenerator : public CodePrimitives {
 
public:
 
  /*****************************************
   *****************************************
   *****************************************
   *****************************************/
 
  EmbeddedcCodeGenerator(void);
 
  virtual ~EmbeddedcCodeGenerator(void);
 
  virtual void Clear(void);
 
 
protected:
 
  void DoCompile(void);
 
  void DoGenerate(void);
 
  virtual void DecrementTimers(void);
  void InsertExecHooks(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 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=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);
 
  /* 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 AX StringConstant(const std::string& val);
 
  /* 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& 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);
 
  // code generator primitives, embeddedc-only helper
  AX IntarrayConstant(int offset, const std::vector<int>& val);
  AX WordarrayConstant(int offset, const std::vector<word_t>& val);
  AX StrarrayConstant(int offset, const std::vector<std::string>& val);
 
 
 
  virtual void DoReadTargetConfiguration(TokenReader& rTr);
 
  virtual void DoWriteTargetConfiguration(TokenWriter& rTw) const;
 
};
 
 
#endif