ngcdcsSEQ_PRG.hpp

Go to the documentation of this file.

#ifndef ngcdcsSEQ_PRG_H
#define ngcdcsSEQ_PRG_H
 
 
#ifndef __cplusplus
#error This is a C++ include file and cannot be used from plain C
#endif
 
#include <ngc/core/ngcbAddr.h>
#include <ngc/core/ngcdcsSLX.hpp>

struct ngcdcs_ticks_t {
  int ticks;  //< Ticks
  int mticks; //< Megaticks

  ngcdcs_ticks_t() {
    mticks = 0; ticks = 0;
  }

  ngcdcs_ticks_t(int mt, int t) {mticks = mt; ticks = t;}

  void Reset() {mticks = 0; ticks = 0;}

  void Set(ngcdcs_ticks_t t) {mticks = t.mticks; ticks = t.ticks;}

  void Add(int t) {
    mticks += ((ticks + t) / 1000000);
    ticks = (ticks + t) % 1000000;
  }

  void Sub(int t) {
    if (ticks >= t)
      {
      ticks -= t;
      }
    else
      {
      ticks = 1000000 + ticks - t;
      mticks--;
      }
  }

  void Add(ngcdcs_ticks_t t) {
    mticks += t.mticks + ((ticks + t.ticks) / 1000000);
    ticks = (ticks + t.ticks) % 1000000;
  }

  void Sub(ngcdcs_ticks_t t) {
    mticks -= t.mticks;
    if (ticks >= t.ticks)
      {
      ticks -= t.ticks;
      }
    else
      {
      ticks = 1000000 + ticks - t.ticks;
      mticks--;
      }
  }
 
  /*
   * Check if zero
   */
  int EqZero() {
    if ((ticks == 0) && (mticks == 0)) return (1);
    else return (0);
  }
 
  /*
   * Check if greater than zero
   */
  int GtZero() {
    if (mticks > 0) return (1);
    else if (mticks < 0) return (0);
    else if (ticks >= 0) return (1);    
    else return (0);
  }
};

struct ngcdcs_subrt_t {
  int addr;       //< Start address (relative to RAM base)
  int index;      //< Reference index
  int length;     //< Subroutine code length
  double time;    //< Execution time in seconds
  char name[256]; //< Subroutine name       

  ngcdcs_subrt_t() {
    addr = 0; index = 0; length = 0; time = 0.0;
    memset(name, 0, sizeof(name));
  }
};

struct ngcdcs_seqp_t {
public:
  int code[ngcbSEQ_RAM_SIZE];              //< Sequencer program code
  int length;                              //< Program code length 
  ngcdcs_subrt_t subRt[ngcbSEQ_MAX_SUBRT]; //< Subroutines
  int numSubRt;                            //< Number of subroutines
  int stored;                              //< Program is stored in controller
  ngcdcs_seqp_t() {code[0] = 0x0; length = 0; numSubRt = 0; stored = 0;}
};

struct ngcdcs_loop_t {
  int pos;      //< Loop start position
  int cnt;      //< Loop counter
  int infinite; //< Infinite sequence flag

  ngcdcs_loop_t() {pos = 0; cnt = 0; infinite = 0;}
};

class ngcdcsSEQ_TOK
{
public:
  int code; //< Command code
  int addr; //< Address field
  int cnt;  //< Counter field

  ngcdcsSEQ_TOK() {code = 0x0; addr = 0; cnt = 0;}

  explicit ngcdcsSEQ_TOK(int instr) {Instruction(instr);
  }
  
  void Instruction(int instr) {
    code = (instr & ngcbSEQ_RAM_CODE) >> 28;
 
    switch (code)
      {
      case ngcbSEQ_CODE_JSR:
        {
    addr = instr & ngcbSEQ_RAM_ADDR;
    cnt = (instr & ngcbSEQ_RAM_CNT) >> 11;
    break;
    }
      case ngcbSEQ_CODE_LOOP:
        {
    addr = 0;
        cnt = (instr & ngcbSEQ_RAM_CNT) >> 11;
    break;
    }
      case ngcbSEQ_CODE_LOOP_INF:
        {
    addr = 0;
    cnt = -1;
    break;
    }
      case ngcbSEQ_CODE_EXEC:
        {
    addr = instr & ngcbSEQ_RAM_ADDR;
    cnt = (instr & ngcbSEQ_RAM_CNT) >> 11;
    break;
    }
      default:
        {
    addr = 0;
        cnt = 1;
    break;
    }
      }
  }
 
protected:
private:
};

class ngcdcsSEQ_EMU
{
public:
  int id;               //< Sequencer module reference id
  int address;          //< Actual adresss field
  int counter;          //< Actual counter field
  int infiniteLoopRuns; //< Infinite loop replacement
  int offset;           //< Offset maintained by the application

  ngcdcsSEQ_EMU() {
    id = -1; // not yet assigned
    infiniteLoopRuns = 0;
    prg_ = &program_;
    Init();
  }

  explicit ngcdcsSEQ_EMU(ngcdcs_seqp_t *prg) {
    id = -1; // not yet assigned
    infiniteLoopRuns = 0;
    prg_ = prg;
    Init();
  }

  virtual ~ngcdcsSEQ_EMU() {}
  
  ngcdcs_seqp_t *Program() {return prg_;}

  void Init() {
    int i;
    for (i=0;i<ngcbSEQ_MAX_SUBRT;i++)
      {
      returnPos_[i] = 0;
      }
    returnNr_ = 0; loopNr_ = 0; pos_ = 0;
    error_ = 0; erms_[0] = '\0';
    terminate_ = 0;
    callBack_ = 0;
    breakPoint_ = 0;
    infinite_ = 0;
    address = -1; counter = 0; offset = 0;
  }

  int Instr() {
    if ((pos_ >= 0) && (pos_ < ngcbSEQ_RAM_SIZE))
      {
      return (prg_->code[pos_]);
      }
    else
      {
      sprintf(erms_, "invalid program address");
      error_ = 1;
      return (ngcbSEQ_CODE_EXIT);
      }
  }

  int Step() {
    ngcdcsSEQ_TOK token;
 
    terminate_ = 0; 
    error_ = 0;
    callBack_ = 0;
    address = -1;
    counter = 0;
    while (!terminate_ && !error_ && !callBack_)
      {
      token.Instruction(Instr());
      
      switch (token.code)
    {
    case ngcbSEQ_CODE_LOOP_INF:
    case ngcbSEQ_CODE_LOOP:
          {
      OpenLoop(token.cnt);
      break;
      }
    case ngcbSEQ_CODE_LOOP_END:
          {
      CloseLoop();
      break;
      }
    case ngcbSEQ_CODE_JSR:
          {
      Jsr(token.addr);
      break;
      }
        case ngcbSEQ_CODE_RETURN:
          {
      Return();
      break;
      }
    case ngcbSEQ_CODE_EXIT:
          {
      if (loopNr_ > 0)
        {
        sprintf(erms_, "error parsing loop (loop not closed)");
        error_ = 1;
        }
      else
        {
        terminate_ = 1;
        }
      break;
      }
    case ngcbSEQ_CODE_EXEC:
      { 
      if ((token.addr < 0) || (token.addr >= ngcbSEQ_PATRAM_SIZE))
        {
        sprintf(erms_, "invalid pattern address");
        error_ = 1;
        break;;
        }
 
      if (token.cnt < 0)
        {
        sprintf(erms_, "error parsing loop (negative rep. factor)");
        error_ = 1;
        break;
        }
      
      if (token.cnt == 0)
        {
        Next();
        break;
        }
 
      address = token.addr; 
      counter = token.cnt;
      callBack_ = 1;
      break;
      }          
    default:
          {
      /*
       * We ignore all other tokens
       */
      Next();
      break;
      }
    }
      }
    
    return (terminate_);
  }
  
  void OpenLoop(int cnt) {
    if ((cnt < -1) || (cnt == 0))
      {
      sprintf(erms_, "error parsing loop (invalid loop counter %d)", cnt);
      error_ = 1;
      return;
      }
 
    if (loopNr_ >= ngcbSEQ_MAX_OPEN_LOOPS)
      {
      sprintf(erms_, "error parsing loop (too many open loops)");
      error_ = 1;
      return;
      }
 
    if (cnt == -1)
      {
      loop_[loopNr_].infinite = 1;
      breakPoint_ = 0;
      if (infiniteLoopRuns > 0) cnt = infiniteLoopRuns;
      }
    else
      {
      loop_[loopNr_].infinite = 0;
      }
 
    loop_[loopNr_].cnt = cnt;
    loop_[loopNr_++].pos = pos_ + 1;
 
    Next();
  }

  int Infinite() {return (infinite_);
  }

  void BreakPoint() {breakPoint_ = 1;}

  void CloseLoop() {
    int n = loopNr_ - 1;
 
    if (n < 0)
      {
      sprintf(erms_, "error parsing loop (skip over loop end)");
      error_ = 1;
      return;
      }
 
    if (loop_[n].infinite && !breakPoint_) infinite_ = 1;
    if (loop_[n].cnt >= 0) loop_[n].cnt--;
    if (loop_[n].cnt == 0)
      {
      /*
       * One less open loop
       */
      loopNr_--;
 
      if (loop_[n].infinite)
    {
    /*
     * We can exit as the following code would 
     * never be executed
     */
    terminate_ = 1;
    }
 
      /* 
       * We can continue with the next code position
       */
      Next();
      }
    else
      {
      /*
       * Jump back to loop body start position
       */
      Goto(loop_[n].pos);
      }
  }

  void Jsr(int addr){
    if ((addr < 0) || (addr >= ngcbSEQ_RAM_SIZE))
      {
      sprintf(erms_, 
          "error parsing loop (invalid subroutine address 0x%04x)",
          addr);
      error_ = 1;
      return;
      }
 
    if (returnNr_ >= ngcbSEQ_MAX_SUBRT)
      {
      sprintf(erms_, 
          "error parsing loop (too many nested subroutines)");
      error_ = 1;
      return;     
      }
    
    /*
     * Store address where we have to return
     */
    returnPos_[returnNr_++] = pos_ + 1;
    
    /*
     * Jump to sub-routine address
     */
    Goto(addr);
  }

  void Return() {
    if (returnNr_ <= 0)
      {
      if (loopNr_ > 0)
    {
    sprintf(erms_, "error parsing loop (loop not closed)");
    error_ = 1;
    return;
    }
      
      /*
       * We can exit
       */
      terminate_ = 1;
      }
    else
      {
      /*
       * Go back to address from where the routine has been called
       */
      Goto(returnPos_[--returnNr_]);
      }
  }
  
  void Next() {pos_++;}

  void Goto(int newPos) {pos_ = newPos;}

  int Error() {return (error_);}

  char *ErrMsg() {return (erms_);}
 
protected: 
 
private:
  int returnPos_[ngcbSEQ_MAX_SUBRT];

  int returnNr_;

  ngcdcs_loop_t loop_[ngcbSEQ_MAX_OPEN_LOOPS];

  int loopNr_;

  int pos_;

  char erms_[256];

  int error_;

  int terminate_;

  int callBack_;

  int breakPoint_;

  int infinite_;

  ngcdcs_seqp_t *prg_;

  ngcdcs_seqp_t program_;
};
 
#endif