Also fix a bug in Lic2soc.make_e2a_elt where some deps and some
actions were lost. Actually, this bug ought to be triggered only with
nested calls. So this affects only programs executed via the
-knc/-keep-nested-calls option. and -2c is not supposed to work in
conjunction with -knc ! Hence this fix does not fix anything. But
still it fixes potentially future code if I (or someone else) decide
to handle nested calls in the lic one day.

Basically, I've missed some substitutions in Merge and in clocks.

This one was spotted by willie.

More precisely, it was introduced here ea40dfa0
when addind the -enc option.

Indeed, in -ec, since them I've decided to only output the main
node. Hence when no main is specified, one was taken at random. But
it the chosen nide is a predef one, no code is generated !

To fix this, I now chose a user def node.

More precisely, it was introduced here 6c7bc562

bug1: Soc2cGenAssign.f was calling Soc2cIdent.type_to_short_string,
which was generating bad idents (ie, containing "::").

bug2 : some _assign_array_types macro def were missing.

to be continued...

For the time being, we simple try to factorise out the test of
consecutive gao that holds on the same clock.

ps : also fix a pb (infinite loop in SortActions.topo_sort)
introduced in the previous change that, for a strange reason
(Makefile issue), was not catched by the test (almost all test were
failing !!).

pps : it actually seems to break quite a lot of test, but its my test
script that wrong ! since version 527 (we are 534), the compiler used
to perform the test in the tmp dirs is not upadated ! (well it is,
but on the wrong machine...).

I commit this change still as it introduces no more test failures.

Indeed, computing the dependencies and choosing an order for actions
(that may optimize test openning in the near futurea) are 2 different
things.

i.e., by providing a default macro definition that uses memcpy()
(versus generating a nop function).

As suggested by Willie, it allows it to be specialized when it is
called more than once.

The rationale is to prepare the work for a future --2s-stack option.

Also provide a default version of those macros using memcpy.

that expands the call of the specified node (can be used for several nodes).
Remove the previous --do_not-expand-nodes <string>

Also, the L2lExpandNodes pass now deletes the expanded nodes from the
current LicPrg.t.

Add an option --to-c-dont-inline-predef to get the previous behavior.

I've just switched to ocaml 4.02, and it works only on carlit because
of GLIC 2.14 is not installed on other machine.

also, add some missing files.

Indeed, the shift from pave to bauges changes its behavior.

I know they fail, but I'll fix that latter.

Also disable tests that involves ecxexe with files that contain 'merge'.
indeed the -ec backend is not the priority.

nb: bad timings is due to NFS and pavé that is dying.

to behave as scanf("%d")

(the function that perform this job is actually in rdbg-plugin so that it is shared
with lutin and rdbg)

The translation was faithfull to the comment, but the comment was wrong :
in order to translate a condact, we need clocks (when) !

node condact_toto(i0:bool; i1:int; i2:int) returns (o0:int) = Lustre::condact<<toto, 0>>;

is now translated into:

condact_toto(i0:bool; i1:int; i2:int) returns (o0:int)
let
  o0 = if i0 then current(toto(i1 when i0, i2 when i0) ) else (0 fby o0);
tel

is the clock of the quicker clock among its inputs, not among its output !

To acheive that, I gave a diffretent name to each created executable
(vs a.out) to avoids races.

generation has been stopped in the middle of the process because of
an error in order to avoid to run test that will fail for sure.

soc2c: fix the code generated for array concatenation (which was raising a warning and a Seg fault).

Also remove the port number from the sum files

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).