Fix a performance bug that was occuring with programs having a lot of variables and that were using constant.

maintaining (ugly and error-prone) hash tables.

That change revealed an untriggered bug in EvalClock.check_args: it was wrong
to add in subst the substitutions made of the parameters and the arguments (it
is enough to unify the clocks of the pars and of the args). For instance, consider
the node (in should_work/clock/clock.lus)

   node clock5(x :  bool; y:  bool when x; z: bool when y)

and the call

  z2 = clock5(a, b when a, c when e);

I was adding y/b in the subst, which was wrong.

Other minor changes:
 - move const_to_val_eff from Eff to UnifyClock.
 - GetEff.translate_val_exp now returns a substitution, in order to be able
   to unify clock vars and propagate the resulting substitution.

not expanded.

expanser to expand the mentioned node.

maintaining (ugly and error-prone) hash tables.

aliasing polymorphic operators afterwards,  use the rigth type in the
first     place    when     building    the     alias     node    (in
Lazycompiler.make_alias_node).

instanciated by a polymorphic operator.

expansed) type  definitions that were containing struct  or arrays in
the expand_structs mode.

extern constants.

as extern constants.

Also  fix  a  bug   in  the  struct/array  expanser:  when  expanding
structured constants  into val_exp,  I need to  add a entry  into the
type and clock val_exp tables.

 - expr such as "current x,y" should be written "current (x,y)"
 - abstract   struct  or   array   types  were   handled  as   extern
   types, which  prevent the struct  and array expanser to  work them
   out. In order to fix that, I have added an Abstract_type_eff variant
   to Eff.type_ which contains the concerte type.

2 source transformations), we add an entry in the EvalType and the EvalClock
tables. Otherwise, when we use EvalType.lookup or EvalClock.lookup, an error
migth be raised.

the moment, I just don't generate such operator anymore (i generate the
polymorphic version Lustre::lt instead). I don't really know what is the
better.

fixing the v4 backend : print "+" instead of "Lustre::plus" (and ditto for the others).

where generated in the --expand-nodes mode..

with a non-empty body (instead of just the first node).

When a node P::n1 wants to access to a node P::n2, it is ok to
search for it in the boby of P.

node, as UniqueOutput.check take as argument the source info with the
original arity...

conjunction of some program transformation (-ei or -esa).

In Lazycompiler.node_check_do, I've forgotten  to put the node i/o in
the local_env table in the case of node alias.

nodes (e.g., map<<+,2>>). While fixing  that, I put all the functions
that deals with polymorphism into a new (Eponymous) dedicated module.

The idea to be able to expand polymorphic node is basically the same,
as the one for printing polymorphic  nodes: we need to wait until the
type is instanciated (in GetEff).  That delay is implemented by using
a stack of nodes.

an expanser to will expand only struct, and i whant to name it like that).

In  short, the  rationale for  this change,  is that  it is  having a
recursive node_exp is
- useless,
- too complicated,
- wrong w.r.t. nesting iterator calls

In long:

- It is useless because, at the  Eff level, a node cannot call itself
  via one  of its  static arg (which  was where the  recursivity came
  from).

- and indeed, it  is much simpler to consider that  a static arg node
  can only be ident.long that identifies a node alias.

  This  means of  course, that  nested iterators  have  been unnested
  before,   inventing  alias   node  names   along  the   way...  And
  polymorphism makes thing difficult once again.

- But the  *big* problem  with a recursive  node_exp is that  it make
  things very  complicated to (lic)dump nested  iterator call because
  of polymorphism!   Actually, it  even makes thing  complicated when
  the iterators were themselves not nested in the source code !

  Some ugly  things were done in  LicDump to unnest  those calls when
  printing node_exp.   But this uglyness  have a price:  tricky code,
  and bugs! Indeed, nested iterators calls were wong for example when
  using  the --inline-iterator  mode (but  i would  not  be surprised
  that is wrong in other cases...).

Hence,  LicDump  is  simpler,  but  of course  LazyCompiler  is  more
complicated.  But  this  is  reasonable:  a  pretty-printer  is  not
supposed to be complicated.

To  do  that, we  centralized  the ident  name  creation  into a  new
dedicated module Name.

+ fix should_work/NONREG/param_node.lus, we contained a combinational loop.

is  part  of  the  Eff.node_ney  via  static  node  parameters.   The
consequence  was  that some  nodes  (the  ones  with node  as  static
parameters) were and printer several times (if used several times in
the user program)!

(--inline-iterators) to activate it.

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

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.

polymorphic operators.

For instance, when LicDumping expression such as

    map<<map<<+,4>>,5>>

an  alias  node was  created  for  "map<<+,4>>"  (to unnest  iterator
calls). Fut this node is intrically overloaded (polymorphic). In this
change, we  look at  the type this  innr call  is used to  generate a
specialised (mono-morphic) version of the node alias.

Note that we currently still generate type variable when users write

     node mymap = map<<+,4>>;

+ enhance  error msg  (which helped finding  the bug, but  that migth
also be useful for ed-users...).