• ADDED: finally block of code which is executed after any state of the process. This “post-state common code” block is the counterpart of the common block executed before any state. common and finally blocks are perfect locations to check resp. pre- and post-conditions.

  ​x
   
  1
  ​
  2
  processdef A_Proc()
  3
  {
  4
      /* pre-state common code executed first whatever the current state */
  5
      common {
  6
          IO.println("pre-state common code");
  7
      }
  8
      
  9
      state First {
  10
          /* state-specific code goes here */
  11
          IO.println("state code");
  12
      }
  13
      
  14
      /* post-state common code executed last whatever the current state */
  15
      finally {
  16
          IO.println("post-state common code");
  17
      }
  18
  }
  19
  ​
  20
  process A_Proc: p1[1s]();
  21
  ​
  

  processdef A_Proc() { /* pre-state common code executed first whatever the current state */ common { IO.println("pre-state common code"); } state First { /* state-specific code goes here */ IO.println("state code"); } /* post-state common code executed last whatever the current state */ finally { IO.println("post-state common code"); } } process A_Proc: p1[1s](); Run
• ADDED: self.continue allows to execute several states of a FSM in a row before relinquishing the CPU (similar in the spirit to “forced states” in Opnet). In the example below, the execution of state First will always be followed by the execution of state Second:

  25
   
  1
  ​
  2
  processdef Simple()
  3
  {
  4
      state First {
  5
          IO.println("Time %t  - executing state First", time64.time());
  6
          self.continue = true;
  7
      }
  8
      on (true)
  9
        to Second;
  10
  ​
  11
      state Second {
  12
          IO.println("Time %t - Executing state Second", time64.time());
  13
      }
  14
      on (true)
  15
        to Third;
  16
  ​
  17
      state Third {
  18
          IO.println("Time %t - Executing state Third", time64.time());
  19
      }
  20
      on (true)
  21
        to First;
  22
  }
  23
  ​
  24
  process Simple: p1[1s]();
  25
  ​
  

  processdef Simple() { state First { IO.println("Time %t - executing state First", time64.time()); self.continue = true; } on (true) to Second; state Second { IO.println("Time %t - Executing state Second", time64.time()); } on (true) to Third; state Third { IO.println("Time %t - Executing state Third", time64.time()); } on (true) to First; } process Simple: p1[1s](); Run
• ADDED: possibility to affect the result of a function through a mechanism called “currying”:

  14
   
  1
  ​
  2
  double(
  3
      in  uint8: x,
  4
      out uint8: y)
  5
  {
  6
      y = 2 * x;
  7
  }
  8
  ​
  9
  init()
  10
  {
  11
      var uint8:   result =     double(5);
  12
      IO.println("result = %u", result);
  13
  }
  14
  ​
  

  double( in uint8: x, out uint8: y) { y = 2 * x; } init() { var uint8: result = double(5); IO.println("result = %u", result); } Run
• ADDED: possibility to test the result of a function (currying again):

  15
   
  1
  ​
  2
  add_1ms(
  3
      in  time64: a,
  4
      out time64: res)
  5
  {
  6
      res = a + 1ms;
  7
  }
  8
  ​
  9
  init()
  10
  {
  11
      var time64: t1       = 999ms;
  12
      var time64: expected = 1s;
  13
      assert(expected == add_1ms(t1));
  14
  }
  15
  ​
  

  add_1ms( in time64: a, out time64: res) { res = a + 1ms; } init() { var time64: t1 = 999ms; var time64: expected = 1s; assert(expected == add_1ms(t1)); } Run
• ADDED: possibility to test and store the state of a process, from within the process through self.current_state and from another process through a Process_State variable. The latter case is illustrated below:

  36
   
  1
  ​
  2
  processdef Simple()
  3
  {
  4
      static var bool: change_state = false;
  5
      common {
  6
          change_state = bool.rand_uniform();
  7
      }
  8
  ​
  9
      state First {
  10
      }
  11
      on (change_state)
  12
        to Second;
  13
  ​
  14
      state Second {
  15
      }
  16
      on (change_state)
  17
        to First;
  18
  }
  19
  ​
  20
  process Simple: p1[1s]();
  21
  ​
  22
  processdef Observer()
  23
  {
  24
      static var Process_State: previous;
  25
      state Single {
  26
          IO.print("Current state of p1: ");
  27
          if (p1.process_state == Process_State.First) {
  28
              IO.println("First");
  29
          } else {
  30
                IO.println("Second");
  31
              }
  32
      }
  33
  }
  34
  ​
  35
  process Observer: p2[1s](); 
  36
  ​
  

  processdef Simple() { static var bool: change_state = false; common { change_state = bool.rand_uniform(); } state First { } on (change_state) to Second; state Second { } on (change_state) to First; } process Simple: p1[1s](); processdef Observer() { static var Process_State: previous; state Single { IO.print("Current state of p1: "); if (p1.process_state == Process_State.First) { IO.println("First"); } else { IO.println("Second"); } } } process Observer: p2[1s](); Run

What has been fixed or changed

• FIXED: Named blocks can be declared anywhere, e.g. inside if statement (#318):

  14
   
  1
  ​
  2
  processdef Proc()
  3
  {
  4
    state Main {
  5
      var bool: b;
  6
      valid1: {
  7
      }
  8
      if (b) {
  9
        valid2: {
  10
        }
  11
      }
  12
    }
  13
  }
  14
  ​
  

• CHANGED: break statement now forbidden in states, reserved for loops (#343).
• CHANGED: @cpal:unknown annotations are rejected by the parser, user-defined annotations must be prefixed by anything other than @cpal) (#354).
• CHANGED: Queue iteration: no more implicit continue statement after a call to remove_current() (#49). remove_current() does not support anymore the options restart and break (#49,#269) whose behavior can be achieved programmatically.

  19
   
  1
      
  2
  init(){
  3
    var queue<uint8>: my_data[4] = {1, 5, 7, 9 };
  4
    loop over my_data with it {
  5
      IO.println("%u", it.current);
  6
      if (it.current == 1) {
  7
        it.remove_current(); 
  8
        /* it points now to the next element of the collection */
  9
      }
  10
      if (it.current == 5) {
  11
        it.remove_current();
  12
      }
  13
      if (it.current == 7) {
  14
        it.remove_current();
  15
      }
  16
      IO.println("size of the collection: %u", my_data.count());
  17
    }
  18
  }
  19
  ​
  

  init(){ var queue<uint8>: my_data[4] = {1, 5, 7, 9 }; loop over my_data with it { IO.println("%u", it.current); if (it.current == 1) { it.remove_current(); /* it points now to the next element of the collection */ } if (it.current == 5) { it.remove_current(); } if (it.current == 7) { it.remove_current(); } IO.println("size of the collection: %u", my_data.count()); } } Run
• CHANGED: { } required after if statement (#352).
• FIXED: correct parser issues with sub-processes (#358,#359,#360).

Test coverage metrics (figures for embedded Linux platform)

• Test code coverage for the execution engine: 85.9% (lines of code), 82.2% (functions) and 72.8% (branches)
• Tests: parser=3963, interpreter=857, cpal2x=3342