by taking advantage of the multi-proc -> x5 speedup with j 4 !

Note that i do not use -j 4 (qtest) for reference (reftest) to lower
timings distorsion due to the machine load.

Indeed, for big integers, looking at |x-x'|<eps leads to false
positive, because of the precision (*); it is better to to look at
|1-x/x'|<eps

(*) the precision (-p 6) influence the comparison, because the SUT
currently sends its result via a socket and truncate the result
(which is probably a bad idea).

nb : the exec time explose (x3), but for an external (unknown) reason
(undoing the change leads to the same exec time ~800s).

nb : the -exec mode was working because I did not use the generated soc,
which was completely wrong.

Note that to do that, I have modified the CURRENT variant of
Lic.val_exp, to attach it the clock the current holds on. Indeed, the
clock is mandatory to generated correct code...

In an ideal world, this clock information may have explicitely been
set by the user ("current(clk_of_X,X)" instead of "current(X)"), but
for historical reason, it is not the case.

Hence, this information is added as soon as it is available, namely,
during clock checking.

Indeed, starting from a clean /tmp dir changed the result of the non reg test...

Indeed, once the activation condition has been true, and when it is
false it wax returning the default value instead of the previous one.

# of expected passes 		1512 -> 1519
# of unexpected failures	84 -> 78

For instance, do not launch tests that perform result comparison (via
lurette) on files that contains extern nodes (as they cannot be
executed) or package.  Package do not work because appending the
tested lustre file with the generated oracle as I do is wrong in
presence of package.

Moreover, my current test process is not able to test programs which
main node IOs are not all on the base clock. I have fixed this by
patching the examples.

# of expected passes 		1508 -> 1512
# of unexpected failures	130 -> 84

30 tests fail, but 169 pass!!!

# of expected passes 		1339 -> 1508
# of unexpected failures	100 -> 130

and -2c).  Indeed, the l2lExpandArrays sometime transforms a
Lic.var_exp ve into TUPLE[ve].

# of unexpected failures	101->109

but actually, some new test passes causes several other failing test
to be tried, so it is not really a regression.

Indeed, ite are polymorphic, and thus inventing names during soc
instanciation is error-prone, ugly, innefficient, and increase the
code size.

Moreover, using C ite to translate them online (ie, without going
trough a soc) is straigforward

# of unexpected failures	104->101.

In other words, consider ">" and co as overloaded operators, not polymorphic ones.

where I've removed the handling of polymorphism.

where I've removed the handling of polymorphism.

e.g., by replacing "plus" by "iplus" or "rplus"

Hence now the following is accepted :
   res = map<<+,  N>>(x, a, b);

but still not

  a_or_b = map<<Lustre::if,  N>>(x, a, b);

For instance,
  node toto = map<<Lustre::if,  N>>(x, a, b);
is rejected.

The problem with this change is that we now also reject equations such as
   res = map<<+,  N>>(x, a, b);

which could be avoided. Probably L2lRmPoly does its job partially.

nb:  unexpected failures  120 -> 118

nb:  unexpected failures  115->120

nb:  unexpected failures 120 -> 115

nb:  unexpected failures 126 -> 120

nb:  unexpected failures 127 -> 125

I've sligthly modified the profile of gen_assign to explicitly ask for the
size of the data structure to be copied.

nb:  unexpected failures 131 -> 127

nb:  unexpected failures 133-> 131

nb:  unexpected failures 143->133

nb:  unexpected failures	144->143

nb:  unexpected failures	149->144

The arrow soc now has a memory used to hold if the first step has be triggered.

The first one in Soc2cIdent.type_to_short_string when enum and int were both
translated by "i" ; as a consequence, some different soc ctx get the same name.

The second one was due to the fact that car ident in gao switches were
printed incorrectly (missing "ctx->" or "node_no_mem_ctx.").

nb:  unexpected failures 162-> 149

nb:  unexpected failures 175-> 162

Also name step function consistent and uniquely

nb:  unexpected failures 187->175

nb:  unexpected failures 195->187

Also start to add support for the other iterators, but it does not work yet.

The idea is that
- when it is not in the memory, it is considered as true
- it is set to false after each step is executed