"one_op_per_equation" mode.

(--inline-iterators) to activate it.

nb : do not inline completely nested iterator calls (yet, cf TODO).

(Hat) were handled incorrectly.

change the parser and accept only clock expressions after a when.

A clock is now made of 2 idents: one for the clock constructor, and
one for the clock variable.

internal errors.

Note that by polymorphic here I mean *really* polymorphic, since they
can handle tuples, which is no the case of, let's say, "<".

splitting expressions.

The  idea  is  the  following:  each  time  a  nested  iterator  call
(map<<map<<n,3>>,4>>) is  encountered, we  create a fresh  alias name
(create_alias_name) ad we  add it in the node_alias_tbl.   At the end
of the  compilation, LicDump.dump_node_alias is  called, which prints
the definition of those node aliases.

For example, the expression  "map<<map<<n,3>>,4>>" is printed like this:

    map<<_node_alias1, 4>>

and later, the node alias is defined:

    node _node_alias1(x:int) returns(y:int); let y = map<<n,3>>(x); tel;

prefixed by "_".

definitions in their order of creation. The rationale is purely aesthetic...

as many  new local  variables as necessary  so that an  expression is
made at most of one operator.

The rational  for that  is to obtain  a lic  code that is  trivial to
clock check (nested node calls, for example, make it less simple).

The old behavior can still be obtained using --keep-nested-calls.

During  that  change,   I  realised  that  I  did   not  clock  check
asserts. Hence, I have also added this check.