CompileDES  3.09
Executable-Code Generation from Synchronised libFAUDES Automata
cgp_codeprimitives.h
Go to the documentation of this file.
1 
3 /*
4  FAU Discrete Event Systems Library (libFAUDES)
5 
6  Copyright (C) 2010, 2016, 2017 Thomas Moor
7 
8 */
9 
10 
11 
12 #ifndef FAUDES_CODEPRIMITIVES_H
13 #define FAUDES_CODEPRIMITIVES_H
14 
15 #include "libfaudes.h"
16 #include "cgp_codegenerator.h"
17 
18 using namespace faudes;
19 
20 
21 
244 class CodePrimitives : public CodeGenerator {
245 
246 public:
247 
248  /*****************************************
249  *****************************************
250  *****************************************
251  *****************************************/
252 
264  CodePrimitives(void);
265 
269  virtual ~CodePrimitives(void);
270 
275  virtual void Clear(void);
276 
279 protected:
280 
292  virtual void LiteralPrepend(void);
293 
295  virtual void DeclareStatus(void);
296 
298  virtual void DeclareReset(void);
299 
301  virtual void DeclareRecentEvent(void);
302 
304  virtual void DeclareParallelState(void);
305 
307  virtual void DeclarePendingEvents(void);
308 
310  virtual void DeclareLoopState(void);
311 
313  virtual void DeclareTimers(void);
314 
316  virtual void DeclareAux(void);
317 
319  virtual void DeclareLargeCarray(void);
320 
322  virtual void DeclareSmallCarray(void);
323 
325  virtual void DeclareEventNameLookup(void);
326 
328  virtual void DeclareStateNameLookup(void);
329 
331  virtual void ResetState(void);
332 
334  virtual void ResetReturn(void);
335 
337  virtual void SenseInputs(void);
338 
340  virtual void SenseTimerElapse(void);
341 
343  virtual void BeginExecutionLoop(void);
344 
346  virtual void UpdateEnabled(void);
347 
349  virtual void ScheduleEvent(void);
350 
352  virtual void BreakExecutionLoop(void);
353 
355  virtual void ExecuteEvent(void);
356 
358  virtual void OperateTimers(void);
359 
361  virtual void OperateOutputs(void);
362 
364  virtual void EndExecutionLoop(void);
365 
367  virtual void LiteralAppend(void);
368 
370  virtual void InsertExecHooks(void);
371 
373  virtual void ExecuteEventBySwitching(void);
374 
376  virtual void ExecuteEventByInterpreter(void);
377 
379  virtual void UpdateEnabledBySwitching(void);
380 
382  virtual void UpdateEnabledByInterpreter(void);
383 
410  class AA : public std::string {
411  public:
412  explicit AA(void) : std::string() {};
413  explicit AA(std::string src) : std::string(src) {};
414  AA Sub(int subscript) const { return AA(std::string(*this) + "_" + ToStringInteger(subscript));};
415  };
417  class AX : public std::string {
418  public:
419  explicit AX(void) : std::string() {};
420  explicit AX(std::string src) : std::string(src) {};
421  };
423  virtual std::string TargetAddress(const AA& address)=0;
425  virtual AX TargetExpression(const AA& address)=0;
427  virtual std::string TargetSymbol(const std::string& str);
428 
465  virtual void IntegerDeclare(const AA& address) =0;
466  virtual void IntegerDeclare(const AA& address, int val) =0;
467  virtual void IntegerAssign(const AA& address, int val) =0;
468  virtual void IntegerAssign(const AA& address, const AX& expression)=0;
469  virtual void IntegerIncrement(const AA& address, int val=1)=0;
470  virtual void IntegerDecrement(const AA& address, int val=1);
471  virtual AX IntegerQuotient(const AX& expression, int val);
472  virtual AX IntegerRemainder(const AX& expression, int val);
473  virtual AX IntegerBitmask(const AX& expression);
474  virtual AX IntegerIsEq(const AA& address, int val);
475  virtual AX IntegerIsEq(const AA& address, const AX& expression);
476  virtual AX IntegerIsNotEq(const AA& address, int val);
477  virtual AX IntegerIsNotEq(const AA& address, const AX& expression);
478  virtual AX IntegerIsGreater(const AA& address, int val);
479  virtual AX IntegerIsLess(const AA& address, int val);
480  virtual AX IntegerConstant(int val)=0;
481  virtual bool HasIntmaths(void);
497  virtual void WordDeclare(const AA& address);
498  virtual void WordDeclare(const AA& address, word_t val);
499  virtual void WordAssign(const AA& address, word_t val);
500  virtual void WordAssign(const AA& address, const AX& expression);
501  virtual void WordOr(const AA& address, word_t val);
502  virtual void WordOr(const AA& address, const AX& expression);
503  virtual void WordOr(const AA& address, const AA& op1, const AA& op2);
504  virtual void WordOr(const AA& address, const AA& op1, word_t op2);
505  virtual void WordAnd(const AA& address, word_t val);
506  virtual void WordAnd(const AA& address, const AX& expression);
507  virtual void WordAnd(const AA& address, const AA& op1, const AA& op2);
508  virtual void WordAnd(const AA& address, const AA& op1, word_t op2);
509  virtual void WordNand(const AA& address, const AX& expresson);
510  virtual AX WordIsBitSet(const AA& address, int idx);
511  virtual AX WordIsBitClr(const AA& address, int idx);
512  virtual AX WordIsMaskSet(const AA& address, word_t mask);
513  virtual AX WordIsEq(const AA& address, word_t val);
514  virtual AX WordIsNotEq(const AA& address, word_t val);
515  virtual AX WordConstant(word_t val);
531  virtual void BooleanDeclare(const AA& address);
532  virtual void BooleanDeclare(const AA& address, int val);
533  virtual void BooleanAssign(const AA& address, int val);
534  virtual void BooleanAssign(const AA& address, const AX& expression);
535  virtual AX BooleanIsEq(const AA& op1, const AA& op2);
536  virtual AX BooleanIsNotEq(const AA& op1, const AA& op2);
551  virtual void CintarrayDeclare(const AA& address, const std::vector<int>& val);
552  virtual AA CintarrayAccess(const AA& address, int index);
553  virtual AA CintarrayAccess(const AA& address, const AA& indexaddr);
554  virtual bool HasCintarray(void);
569  virtual void CwordarrayDeclare(const AA& address, const std::vector<word_t>& val);
570  virtual AA CwordarrayAccess(const AA& address, int index);
571  virtual AA CwordarrayAccess(const AA& address, const AA& indexaddr);
572  virtual bool HasCwordarray(void);
586  virtual AX StringConstant(const std::string &val);
587  virtual void CstrarrayDeclare(const AA& address, const std::vector<std::string>& val);
588  virtual AA CstrarrayAccess(const AA& address, int index);
589  virtual AA CstrarrayAccess(const AA& address, const AA& indexaddr);
590  virtual bool HasCstrarray(void);
605  virtual void IntarrayDeclare(const AA& address, int len);
606  virtual void IntarrayDeclare(const AA& address, const std::vector<int>& val);
607  virtual AA IntarrayAccess(const AA& address, int index);
608  virtual AA IntarrayAccess(const AA& address, const AA& indexaddr);
609  virtual bool HasIntarray(void);
624  virtual void WordarrayDeclare(const AA& address, int len);
625  virtual void WordarrayDeclare(const AA& address, const std::vector<word_t>& val);
626  virtual AA WordarrayAccess(const AA& address, int index);
627  virtual AA WordarrayAccess(const AA& address, const AA& indexaddr);
628  virtual bool HasWordarray(void);
656  virtual void BitarrayDeclare(const AA& address, int blen);
657  virtual void BitarrayDeclare(const AA& address, const std::vector<bool>& val);
658  virtual void BitarrayAssign(const AA& address, const std::vector<bool>& val);
659  virtual void BitarrayAssign(const AA& address, const AA& otherarray);
660  virtual void BitarrayClear(const AA& address);
661  virtual void BitarrayFull(const AA& address);
662  virtual void BitarraySetBit(const AA& address, int bitaddr);
663  virtual void BitarraySetBit(const AA& address, const AA& indexaddr, int offset=0, const std::vector<bool>& hint=std::vector<bool>() );
664  virtual void BitarrayClrBit(const AA& address, int bitaddr);
665  virtual void BitarrayClrBit(const AA& address, const AA& indexaddr, int offset=0, const std::vector<bool>& hint=std::vector<bool>() );
666  virtual void BitarrayIsBitSet(const AA& address, const AA& indexaddr, const AA& result,int offset=0, const std::vector<bool>& hint=std::vector<bool>() );
667  virtual void BitarrayOr(const AA& address, const std::vector<bool>& val);
668  virtual void BitarrayOr(const AA& address, const AA& op1, const std::vector<bool>& op2);
669  virtual void BitarrayOrAllWords(const AA& address, const AA& result);
670  virtual void BitarrayAnd(const AA& address, const std::vector<bool>& val);
671  virtual void BitarrayAnd(const AA& address, const AA& otherarray);
672  virtual void BitarrayAnd(const AA& address, const AA& op1, const AA& op2);
673  virtual void BitarrayAnd(const AA& address, const AA& op1, const std::vector<bool>& op2);
674  virtual void BitarrayFindFirst(const AA& address, const AA& result, int offset=0);
690  virtual void EventSetDeclare(const AA& address);
691  virtual void EventSetDeclare(const AA& address, const EventSet& evset);
692  virtual void EventSetAssign(const AA& address, const EventSet& evset);
693  virtual void EventSetInsert(const AA& address, const EventSet& evset);
694  virtual void EventSetInsert(const AA& address, Idx ev);
695  virtual void EventSetInsert(const AA& address, const AA& evaddr);
696  virtual void EventSetInsert(const AA& address, const AA& evaddr, const EventSet& hint);
697  virtual void EventSetErase(const AA& address, const EventSet& evset);
698  virtual void EventSetErase(const AA& address, Idx ev);
699  virtual void EventSetErase(const AA& address, const AA& evaddr);
700  virtual void EventSetErase(const AA& address, const AA& evaddr, const EventSet& hint);
701  virtual void EventSetExists(const AA& address, const AA& evaddr, const AA& result, const EventSet& hint);
702  virtual void EventSetRestrict(const AA& address, const AA& otherset);
703  virtual void EventSetUnion(const AA& address, const AA& op1, const EventSet& op2);
704  virtual void EventSetIntersection(const AA& address, const AA& op1, const EventSet& op2);
705  virtual void EventSetClear(const AA& address);
706  virtual void EventSetFull(const AA& address);
707  virtual void EventSetIsNotEmpty(const AA& address, const AA& result);
708  virtual void EventSetFindHighestPriority(const AA& address, const AA& result);
724  virtual void IfTrue(const AX& expression);
725  virtual void IfFalse(const AX& expression);
726  virtual void IfWord(const AX& expression);
727  virtual void IfElseIfTrue(const AX& expression);
728  virtual void IfElse(void);
729  virtual void IfEnd(void);
730 
731  virtual void SwitchBegin(const AA& address);
732  virtual void SwitchCase(const AA& address, int val);
733  virtual void SwitchCases(const AA& address, int from, int to);
734  virtual void SwitchCases(const AA& address, const std::set< int>& vals);
735  virtual void SwitchBreak(void);
736  virtual void SwitchEnd(void);
737  virtual bool HasMultiCase(void);
738 
739  virtual void LoopBegin(void);
740  virtual void LoopBreak(const AX& expression);
741  virtual void LoopEnd(void);
742 
743  virtual void FunctionReturn(void);
753  virtual void RunActionSet(const std::string& address);
754  virtual void RunActionClr(const std::string& address);
755  virtual void RunActionExe(const AX& expression);
756 
757  virtual AX ReadInputLine(const std::string& address);
758  virtual AX InputExpression(const std::string& expression);
766  virtual void TimerDeclare(const AA& address, const std::string& litval);
767  virtual void TimerStart(const AA& address);
768  virtual void TimerStop(const AA& address);
769  virtual void TimerReset(const AA& address, const std::string& litval);
770  virtual AX TimerIsElapsed(const AA& address);
778  virtual int StateTargetIdx(size_t git, Idx idx);
779  virtual Idx StateFaudesIdx(size_t git, int idx);
780 
782  virtual void Comment(const std::string& text);
783 
785  virtual void VariableDeclare(const std::string& laddr, const std::string& ltype);
786  virtual void VariableDeclare(const std::string& laddr, const std::string& ltype, const std::string& lval);
787 
788 
791  /*****************************************
792  *****************************************
793  *****************************************
794  *****************************************/
795 
796  protected:
797 
799  std::string mWordType;
800 
802  std::string mIntegerType;
803 
805  std::string mPrefix;
806 
808  bool mArrayForTransitions;
809 
811  bool mMaintainStateIndices;
812 
814  bool mBitAddressArithmetic;
815 
817  bool mArrayForBitmasks;
818 
820  bool mArrayForBitarray;
821 
823  bool mBisectionForBitfind;
824 
826  bool mArrayForState;
827 
829  bool mEventsetsForPerformance;
830 
832  bool mLoopPendingInputs;
833 
835  bool mLoopEnabledOutputs;
836 
838  bool mStrictEventSynchronisation;
839 
841  bool mEventNameLookup;
842 
844  bool mStateNameLookup;
845 
847  std::vector<bool> mHasStateNames;
848 
850  std::string mEventExecutionHook;
851 
853  std::string mStateUpdateHook;
854 
856  std::string mLiteralPrepend;
857 
859  std::string mLiteralAppend;
860 
866  struct bitarray_rec {
868  int blen;
870  std::vector<bool> value;
871  };
873  std::map<std::string,bitarray_rec> mBitarrays;
874 
876  virtual void DoCompile(void);
877 
879  virtual void DoGenerate(void);
880 
882  virtual void DoGenerateDeclarations(void);
883 
885  virtual void DoGenerateResetCode(void);
886 
888  virtual void DoGenerateCyclicCode(void);
889 
891  virtual void DoReadTargetConfiguration(TokenReader& rTr);
892 
894  virtual void DoWriteTargetConfiguration(TokenWriter& rTw) const;
895 
896  private:
897 
898  /*
899  * Templated helperfunction to consolidate consecutive switch-cases.
900  *
901  * The template parameter Data is meant to parameterise the code that will be
902  * generated if the case condition is satisfied. The procedures inspects caseData to
903  * figure case consitions that effectively will generate the same code. Therefore,
904  * the Data class must support the boolean operator==. The result is returned by
905  * the map of ranges caseFromTo; i.e., each entry represents a consecutive range of
906  * case consitions that share the same to-be-generated execution code.
907  *
908  * See also the below varuation ConsolidateCaseSets.
909  */
910  template<class Data> void ConsolidateCaseRanges(std::map< int, Data>& caseData, std::map< int, int>& caseFromTo) {
911  // prepare result
912  caseFromTo.clear();
913  // bail out
914  if(caseData.empty()) return;
915  // inititialise from-to-range to first case data record
916  int fcase=caseData.begin()->first;
917  int tcase=caseData.begin()->first;
918  caseFromTo[fcase]=tcase;
919  // loop over all other cases
920  typename std::map< int, Data>::iterator cit=caseData.begin();
921  for(++cit; cit!=caseData.end(); ++cit) {
922  // current case condition
923  int ccase = cit->first;
924  // if we are meant to merge; and there is no gap; and the data matches ...
925  if(HasMultiCase())
926  if(tcase+1 == ccase)
927  if(caseData[tcase]==caseData[ccase]) {
928  // ... extend the range
929  tcase=ccase;
930  caseFromTo[fcase]=tcase;
931  continue;
932  }
933  // so we did not want extend the range ... start a new range to extend
934  fcase=ccase;
935  tcase=ccase;
936  caseFromTo[fcase]=tcase;
937  }
938  }
939 
940  /*
941  * Templated helperfunction to consolidate switch-cases
942  *
943  * This is a variant of the above procedure ConsolidateCaseRanges. It takes the same
944  * template parameter and the same argument caseData, however, it returns sets of case conditions
945  * as oposed to ranges of case conditions. Here, it is left to the target compiler to optimize
946  * space versus time if consecutive ranges are detected in the respective sets.
947  *
948  * This method is currently used in OperateTimers() and EcecuteEventBySwitching().
949  */
950  template<class Data> void ConsolidateCaseSets(std::map< int, Data>& caseData, std::set< std::set< int > >& caseSets) {
951  // prepare result
952  caseSets.clear();
953  // bail out
954  if(caseData.empty()) return;
955  // if we are not meant to consolidate, produce trivial sets
956  if(!HasMultiCase()) {
957  typename std::map< int , Data >::const_iterator dit=caseData.begin();
958  for(; dit!=caseData.end(); ++dit) {
959  std::set< int > sngl;
960  sngl.insert(dit->first);
961  caseSets.insert(sngl);
962  }
963  return;
964  }
965  // setup reverse map
966  std::map< Data , std::set<int> > rmap;
967  typename std::map< int , Data >::const_iterator dit=caseData.begin();
968  for(; dit!=caseData.end(); ++dit)
969  rmap[dit->second].insert(dit->first);
970  // strip result
971  typename std::map< Data , std::set<int> >::iterator rit=rmap.begin();
972  for(; rit!=rmap.end(); ++rit)
973  caseSets.insert(rit->second);
974  }
975 
976 };
977 
978 
979 #endif