TODO,v 1.3 2003/03/03 19:43:41 wasowski Exp

* implement double-buffering for internal variables. Also elaborate
  possibilities for external variables. Ackad (Software Synthesis from 
  Statechart Models for Real Time Systems) describes an optimization
  which reorders the transitions so the number of double-buffering needed is
  decreased (minimized?). He claims it makes the things faster by order of
  20%, but this should not apply here.

* draw "calculator" model from Miro Samek's book

* implement conflict resolution (aka virtual transitions or transition
  overloading). The most easy way in current framework is to use algorithm
  similar to static-scope. Find all (statically)-conflicting transitions and
  refine guards to ensure that they never fire at the same time (i.e.
  strengthen condition of topmost transitions to exclude situations when lower
  transitions can fire). Both Harel's and UML approach can be easily
  implemented this way (simply switch the priority). 

* investigate size-speed trade off

* model minimization

* model specialization

* finish implementation of native mode for C1 (based on activity of all state
  machines - not just leaves)

* finish implementation of C2 (based on acyclic control flow graphs)

* implement an XMI front-end

* implement an XMI back-end

* try to marry SCOPE with some GUI designer (dia? ArgoUML?)

* make release should change revision state to Rel

* I miss a simple test case with signals!

* Miro Samek in his book argues that pointers to functions (for actions,
  transitions, etc) is the best solution for statechart code. Indeed this is
  only compiled to one instruction call (indirect call) on Intel
  architecture. This contradicts clearly with IAR's guideliness how to write
  compiler friendly code (lookup tables of pointers are considered killers
  for most optimizations). Currently SCOPE is following the way of IAR's
  guideliness, but initially was implemented along Miro's lines (I mean I had
  the same idea initially). Indeed the transition brought some efficiency
  (speed/size) decrease (bu honestly - I compare it with VS in the same mode).
  Since various sources disagree on what is the right way to go it should
  probably made into an option (as in VS coder).

* Currently SCOPE does not support initial transitions. One would need to
  implement them to become more UML compliant. Following Miro Samek they can
  be implemented as yet another kind of actions (attributes) assigned to
  states (OR-states precisely). A bit similar like exit/entry actions for
  AND-states. Most of initial transitions are direct (not crossing state
  levels) so they can be translated to initial states in current framework.
  Only occasionally an additional attribute would be needed and only then it
  should take up space.


