22/01/2004
--------------------------------------------------------------------------------
SugarCubes v3.1.0

- correction of a bug in the SugarCubes v3.0 optimizer.
- correction of a bug in the addProgram implementation.
- correction of a bug in the localVariable method of the class SC, which produce
  a StackOverflow by recursively calling itself.
- correction of a bug of the implementation of the LocalVariable in the
  declareLocalVariable method, which was misleading to a ClassCastException if
  the initial value was null.

- added a Kill instruction in addition to the Until instruction.
- added emptyMachine constructors to the SC class in order to replace in future
  versions of the SugarCubes the badly named voidMachine constructors.
- added a Junior interface to the SugarCubes which almost comply to the Junior
  Semantics. It allows one to write SugarCubes programs using the Junior API.
  One must notes that due to some differences in the semantics between
  SugarCubes and Junior some program Junior program may behave slightly
  differently.
- added an EventFreezable instruction in addition to the Freezable instruction
  of Sugarcubes to comply to the Junior freezing mechanism.
- added methods to the ReactiveEngine interface in order to deal with values of
  events at the previous instant.
- added a couple of variables to identify the SugarCubes version :
    * SC.version
    * SC.generation_date
  don't forget to put these informations if you submit a bug report.
- added an instruction to execute an atomic action at the end of the instant.
  This is similar to a Task executed at the end of an instant. But it is
  defined into a program and so it can be controlled, preempted, etc ...
  This will be an efficient replacement to the Callback instruction, as at the
  end of the instant one can ask for all the occurrences of the event and treat
  all of them in one efficient loop. It can also discard values or implement
  whatever policy in the treatment of the valued occurrences of one or more
  events.
- Modification of the mechanism of minimal time of a reaction : added a method
  reactNotBlocking() which returns immediately after reaction but returns
  and doesn't execute a new reaction until the minimal duration last.
  The method returns the time remaining to wait until the next reaction can take
  place. if the value is negative the machine has terminated its program. If the
  standard react method is called, the react block for the remaining time if
  needed until processing the next reaction.

Have fun!

Jean-Ferdy