cf test/should_work/NONREG/fresh_name.lus

where the local variable _n1e1_1 was defined twice !

The fix contist the following idea : prefix fresh var name by "_",
   except if at least one user ident begins by "_". In that case, we
   try to prefix them by "_1", and then "_2", and so on. We take the
   first possible one.

   nb : this won't work if the user defined idents from "_1" to
   "_1073741823" (on 32-bits machine), but I bet that this compiler
   would die before anyway...

E.g., when creating a fresh var using the name of "L1", I was creating a var names "_L11", and then
"_L12", and so on. But if a var is named "L11", "_L111" is created. If if "L1" is used to generate
11 frash vart names, the name "_L111" clashes !!!

The fix contist in adding an underscore before : "L1" produces "_L1_1", "_L1_2", ..., and "_L1_11".

nb : the naming scheme is still wrong for other reasons... Next fix.

message if the constant is abstract ("an integer is expected whereas an int is
provided" was not a great message...).

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.

info is attached to all  val_exp. Moreover, this allow to perfrom all
the  type checking  in  EvalType.f, instead  of  doin part  of it  in
GetEff.translate_val_exp.

expanser to expand the mentioned node.

maintaining (ugly and error-prone) hash tables.

constants that  are not  on the base  clock, add the  suitable "when"
statement if it was not present  in the source code (the lic (and the
ec/lv4) backend  does not  perform such kind  of clock  inference for
constants.

instead of silently generate  (syntactically) wrong lustre v4 (or ec).

(versus raising an internal error...).

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.

iterated, was still printed using the prefix/long name method (e.g.,
"Lustre__not(a)"  instead   of  "not  a").   Moreover,  equality  was
inconsistently represented as "eq" and "equal". I choose the former.

still   printed   using    the   prefix/long   name   method   (e.g.,
"Lustre__and(a,b)" instead of "a and b".

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

var only! Hence, I tranform "#(a)" into "a" in the lv4 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).

i.e., transform

      x,y = (0,1) -> (a,b);

into

      x = 0 -> a;
      y = 1 -> b;