18/10/2005
----------

  class FindLeaves extends strategy.term.termVisitableFwd {
    Collection bag;
    public FindLeaves(Collection bag) {
      super(`Identity());
      this.bag = bag;
    }
    public Term visit_Term(Term arg) throws VisitFailure {
      if (arg.getArity() == 0) {
        bag.add(MuTraveler.getPosition(this));
      }
      return arg;
    }
  }


  %strat FindLeaves(bag:Collection) extends `Identity() {
    visit Term {
      F(_) -> { ... }
      x    -> { if(x.getArity()) ... this ... }
    }

    visit S2 {
      G(_) -> { ... }
      _   -> { ... }
    }
  }

- extends est suivi d'une expression back-quote dont on peut connaitre le codomaine
- cela permet de generer le bon %op Codomaine FindLeave(bag:Collection) { ... }
- chaque sorte doit definir son visitorForward
- il est utilise pour generer le Java


autres idees:

  %strat FindLeaves(Collection bag) {
    | Term(F())  -> { ... }
    | Term(_)    -> { ... }
    | S2(G())    -> { ... }
    | S2(_)      -> { ... }
    | x          -> { x }
    | Identity
  }


  %strat FindLeaves(Collection bag) {
    _    -> { Identity }
  }

  %strat Term FindLeaves(Collection bag) {
    F()  -> { ... }
    _    -> { ... }
  }

  %strat S2 FindLeaves(Collection bag) {
    G()  -> { ... }
    _    -> { ... }
  }

17/03/2004
----------
 premieres idees sur le meta-preprocesseur

  %newcommand %vas[1] %special_text(vas-to-tom, #1)
  %newcommand %java[1] ...
  %newcommand %rule[1] %special_text(jtom, #1)

  %special_text(vas-to-tom, "--javagen -n peano" ) {
   ...
  }

  %special_text(jtom, "" ) {
    %rule {
       ...
    }
  }

  %special_text(coq, "" ) {
    proof
  }


15/03/2004
----------

- XML
  possibilite de faire des traversal et de filtrer le // de XQuery


- String
  filtrage trop lent
	idee1: donner la longueur d'un X* (X*3 capture une sous-liste de longueur 3)
				 cela permet d'abstraire une sequence de constantes
	idee2: utiliser des fonctions d'index (aide externe) pour reperer plus rapidement les parties constantes
				 reperer les 'c' dans X1*,c,X2*,c,X3*
	idee3: abstraire les memes constantes par des variables identiques et
				 tester la non-linearite au moment de l'instanciation
  idee4: instancier les X* au moment du backquote
  idee5: introduire des variable avec garde et les traiter au moment de la compilation
  idee6: de-looper le filtrage de X* vers des listes constantes (connues a compile-time)


12/12/2003
----------

Previsions pour la v2.0

- Doc
  separer le reference manual du user manual
  creer un vrai tutorial
  couper la pages web en plusieurs sous-pages

- Plugin-in
  possibilite de passer les tests et de bootstrapper
  voir comment integrer javacc
  optimiser la lecture des fichiers en lisant le buffer
  revoir le Tom editor et utiliser une compilation "incrementale" pour decouvrir la definition des operateurs...
  ameliorer la fenetre de selection des properties (Tom et ADT)
  warning ADT file not found
  completion Tom
  recuperer un peu du mode java

- Debugger
  integrer le debugger sous eclipse

- XML
  ameliorer les XMLTools

- Runtime
  distribuer le runtime separement

- Moteur
  AC matching
  revoir l'api
  rendre l'integration de theories plus modulaire
  voir la compilation des records et la disjunction de symboles
  ameliorer le list-matching
  filtrer sur les attributs (AC/HashSet)
  ameliorer le Checker
  analyse des patterns XML
  passer de TomParser.jj a TomParser.t

- ajouter un get_head, get_tail, is_empty dans les %oplist

- new API for %op L f(E*)
  get_it   : L      -> it
  has_elt  : it -> Bool
  get_elt  : it -> E
  get_mult : it -> int
  go_next  : it -> it
  get_all  : it -> L

- exemples

%type Term {
  implement { ATerm }
  equals(t1,t2)    { t1.isEqual(t2) }
}

%op E f(s1:E, s2:E) {
  is_fsym(t) { t.fun='f' }
  get_slot(s1,t) { t.s1 }
  get_slot(s2,t) { t.s2 }
  make(s1,s2) { ... }
}

% ATermList
%op L f(E*) {
  get_it(l)      { l }
  has_elt(it,l)  { it.isEmpty() }
  get_elt(it,l)  { it.getHead() }
  get_mult(it,l) { 1 }
  go_next(it,l)  { it.getTail() }
  get_all(it,l)  { it }

  make_empty()     { ... }
  make_insert(e,l) { ... }
}

% ArrayList
%op L f(E*) {
  get_it(l)      { l.listIterator() }
  has_elt(it,l)  { it.hasNext() }
  get_elt(it,l)  { l.get(it.nextIndex()) }
  get_mult(it,l) { 1 }
  go_next(it,l)  { it.next() }
  get_all(it,l)  { it.clone, while() { res.add(it.next) } }

* make_empty(n)    { ... }
* make_append(e,l) { ... }
}

% Array
%op L f(E*) {
  get_it(l)      { 1 }
  has_elt(it,l)  { it < l.size() }
  get_elt(it,l)  { l.get(it) }
  get_mult(it,l) { 1 }
  go_next(it,l)  { it+1 }
  get_all(it,l)  { while() { res[i](l[it]) } }

* make_empty(n)    { ... }
* make_append(e,l) { ... }
}

% ArrayList
%op L f(E*) {
  get_it(l)      { l.iterator() }
  has_elt(it,l)  { it.hasNext() }
  get_elt(it,l)  { it.clone.next }
  get_mult(it,l) { ... }
  go_next(it,l)  { it.next() }
  get_all(it,l)  { it.clone, while() { res.add(it.next) } }

  make_empty()     { ... }
  make_insert(e,l) { ... }
}


------------------------------------------------------------
PHASE 1
-------
  /*
   * On defini l'API d'un type avec une notation coherente
   */

%typeterm Term {
  implement { ATerm }
  get_fun_sym(t)   { ((t instanceof ATermAppl)?((ATermAppl)t).getAFun():null) }
  get_subterm(t,n) { (((ATermAppl)t).getArgument(n)) }
  equals(t1,t2)    { t1.isEqual(t2) }
}

%op Term plus(Term t1, Term t2) {
  fsym { "plus" }
  make { makeAppl("plus",t1,t2) }
}

%op Term state(Term context, Term value) {
  fsym { "state" }
  make { makeAppl("state",context,value) }
}

  /*
   * Les patterns peuvent utiliser des champs nommes pour permettre
   * une extension plus facile des constructeurs
   */

%match(term t) {
  state(value=a,...)   -> { ... }
  t:state(value=a) -> { return t.setSubterm(1,b) }
}

%rule state(value=a) -> state(value=b)


List matching:
--------------

  /*
   * Java et LinkedList
   */

%typelist L {
  implement { LinkedList }
  get_fun_sym(t) { ((t instanceof LinkedList)?"cons":null) }
  equals(l1,l2)  { l1.equals(l2) }
  get_head(l)    { l.getFirst() }
  get_tail(l)    { subList(1,l.size()) }
  is_empty(l)    { l.isEmpty() }
}

%oplist L cons( E* ) {
  fsym { "cons" }
  make_empty()  { new LinkedList() }
  make_add(l,e) { l.addFirst(e) }
}

------------------------------------------------------------

  /*
   * Java et ArrayList
   */

%typelist L {
  implement { ArrayList }
  get_fun_sym(t) { ((t instanceof ArrayList)?"cons":null) }
  equals(l1,l2)    { l1.equals(l2) }
  get_element(l,n) { l.get(n) }
  get_size(l)      { l.size() }
}

%oplist L cons( E* ) {
  fsym { "cons" }
  make_empty(n)    { new ArrayList(n) }
  make_add(l,e,n)  { l.set(n,e) }
}

------------------------------------------------------------

  /*
   * Java et tableau
   */

%type L {
  implement { Element[] }
  equals(l1,l2)    { l1.equals(l2) }
  get_element(l,n) { l[n] }
  get_size(l)      { l.size() }
}

%oplist L cons( E* ) {
  fsym { "cons" }
  make_empty(n)    { new Element[n] }
  make_add(l,e,n)  { l[n]=e }
}

------------------------------------------------------------

  /*
   * C et tableau/malloc
   */

typedef struct e {
  int size;
  int *array;
}

struct e* create_e(n) {
  struct e *res = malloc(sizeof(struct e));
  res->size=n;
  res->array=malloc(n*sizeof(int));
  return res;
}

%type L {
  implement { struct e* }
  equals(l1,l2)    { memcmp(l1,l2, MIN(l1->size,l2->size)) }
}

%oplist L cons( E* ) {
  get_element(l,n) { l->array[n] }
  get_size(l)      { l->size }

  make_empty(n)    { create_e(n) }
  make_add(l,e,n)  { l->array[n]=e }
}

------------------------------------------------------------

  /*
   * C et GNU tableau
   */

%type L {
  implement { e[] }
  equals(l1,l2)    { ??? }
}

%oplist L cons( E* ) {
  get_element(l,n) { l[n] }
  get_size(l)      { ??? }

  make_empty(n)    { ??? }
  make_add(l,e,n)  { l[n]=e }
}



------------------------------------------------------------
Associative matching:
---------------------

%type L {
  implement { List }
  get_fun_sym(l)   { ((((List)l).isEmpty())?
                      aterm().makeAFun("nil", 0,false):
                      aterm().makeAFun("cons", 2, false)) }
  get_subterm(l,n) { (((List) l).get(n)) }
  equals(l1,l2)    { l1.equals(l2) }
}

%op L nil {
  fsym { makeAFun("nil", 0, false) }
  make { new List() }
}

%op L cons(Term t, L l) {
  fsym { makeAFun("cons", 2, false) }
  make { l.add(t) }
}

%theory A1(cons,nil)

%match(L l) {
  cons(E1*, x, E2*, y, E3*) -> { ... }
}



PHASE 2
-------
  /*
   * On peut creer des synonymes d'un type
   * ou l'etendre en redefinissant certaines fonctions
   */

%type TermBis extends Term {
}

%type List extends Term {
  abstract { ATermList }

  get_fun_sym(l) {
    ((((ATermList)l).isEmpty())?
     aterm().makeAFun("empty", 0, false):
     aterm().makeAFun("cons", 2, false))
      }

  get_subterm(l,n) {
    ((n==0)?
     ((ATermList)l).getFirst():
     (ATerm)(((ATermList)l).getNext()))
      }
}

%sym List empty {
  code { makeAFun("empty", 0, false) }
  make { makeAppl("empty") }
}

%sym List cons(Term t, List l) {
  code { makeAFun("cons", 2, false) }
  make { makeAppl("cons",t,l) }
}

PHASE 3
-------
  /*
   * On introduit une notion de type parametre permettant
   * de factoriser la representation ou la creation
   * des termes de ce type
   */

%type Constant(Symbol) extends Term {
  code { makeAFun(Symbol, 0, false) }
  make { makeAppl(Symbol) }
}

%sym Constant zero {
}

%theory AC(plus)





NOTE
----

Codage systematique des operateurs de la forme

       Op(Option(<List>),...)

exemple :
	Appl(Option([]), Symbol(...), [...])

	Appl(Option([Annoted(...)]), Symbol(...), [...])

Par list-matching on exprime les regles generale de la facon suivante :

	Appl(option(_),
             Symbol(...), [...]) -> {...}

Ces regles s'appliquent pour toutes les specialisation de Appl

Pour definir un regle particuliere a une specialisation on utilise le list-matching

	Appl(option(E1*, Annoted(...), E2*),
	     Symbol(...), [...]) -> {...}
