by removing a unit test that does not work on win32 (because of bad path convention).

e.g., for arrays.

No test actually catches this bug.

Now all the tests that were ok in the heap mode are also ok in the
stack mode !

However the code generated for programs that use fillred and co is weird.

For instance, in should_work.pipeline.lus, in
fillred_oneStep_pipe_10_step, accu_in is used both as an input and an
output, which seems wrong in the stack mode as no copy is performed.

Is it working by chance ?

Now all the tests that were ok in the heap mode are also ok in the
stack mode !

However the code generated by fillred and co is weird.

For instance, in should_work.pipeline.lus, in
fillred_oneStep_pipe_10_step, accu_in is used both as an input and an
output, which seems wrong in the stack mode as no copy is performed.

Is it working by chance ?

Indeed, in order to copy an array, I used to generate something like

   memcpy(out, in, sizeof(in));

but if 'out' and 'in' are arrays, and if 'in' is an argument of a function,
sizeof() considers it as a pointer, not an array !!!!

note that if 'in' is a local var, sizeof(in) works fine.

To fix it, I use the type of the dest (instead of the id) as argument of sizeof.

nb : The pb never occured before, as in the heap mode only the ctx is
passed a args of step functions.

There were problems with:
- a clash in the node_loop.c file with the local 's' counter (oups).
- code generated for boolred
- code generated for arrow on arrays

There were problems with arrays

There were problems with:
- arrays in step functions (array were declared with an incorrect syntax)
- the node_loop.c file was wrong in presence of arrays in I/O
- clock that are outputs (a "*" was missing)

when calling soc.

Do not work all the times (eg, with arrays it generates C code that
does not compile). cf next changes.

By chance (or for other reasons), the resulting code was correct.

  More precisely, a node that has memory ougth to be declared using
  "node", and using "function" otherwise.

  Moreover, a node that performs side-effects (i.e., if it calls an
  extern node that performs side effects) ougth to be declared as
  "unsafe".

  Safe/unsafe mismatches raise an error.

  Memory mismatches raise an error in one way (a "function" that uses
  memory), and a warning in the other way (a "node" that uses no
  memory).

Also fix some errors done when transmitting the unsafe flag (well, it's
the first time I use it!).

- predef Lustre op were declared as memoryful.
- expr like "if true then ..." were badly translated
- The clock and types of some expressions created by L2lOptimIte had
  a bad arity (in presence of tuples)
- in order to perform the -oite optim, also check that each branch is safe.

Currently no integrity check is performed (i.e., check that each node
that uses an unsafe node is itself declared as unsafe).

Indeed it is possible when each branch of the ite updates no memory.
This is done in the new L2lOptimIte module.

For the time being, it does detect when the node has no memory. It
only looks at the declaration: nodes have memory, and not functions.

I should infer that information and raise warnings or errors if what
I infer is not compatible with waht is declared (will come later).

Also split ActionsDep into ActionsDep and Action.

Also fix a bug in L2lsplit where deeply nested (>2) merge were not
splitted.

Report by willie (cf mail of 8/10/2014 to get the file)

file:/tmp/modes3x2.lus

lus2lic -esa -en -2c /tmp/modes3x2.lus -n modes3x2

But it gives an error of:
Error. in file "/mnt/A/wsept/modes3x2_pre_orig_lus2lic_en_esa/modes3x2.lus",
line 74, col 8 to 8, token '#': only one operator per equation is allowed
(v04_0, v04_1).

Which is the line:
assert #(on_off, toggle);

-----------------------------------------------------------------

Actually, refuse programs that uses "#" or "nor" run with -esa and
-2c|-exec

That means that willie program is now rejected.

Nevertheless, that change migth fix some other programs (that uses
arrays, and used with -esa and -exec or -2c).

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.

Merge branch 'master' of git+ssh://scm.forge.imag.fr/var/lib/gforge/chroot/scmrepos/git/lustre/lus2lic

# Please enter a commit message to explain why this merge is necessary,
# especially if it merges an updated upstream into a topic branch.
# 
# Lines starting with '#' will be ignored, and an empty message aborts
# the commit.

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.