lus2lic -h shows the basic options
lus2lic -more shows more experimental options
lus2lic -dev shows experimental/internal  options

+ the utils/lustrequiv script that tries to state that 2 nodes a equivalent or not
using lesar and lurette.

Indeed, I've missed that case and have no nonreg test for -2ch

that I should have catched then. Sigh.

only affect array concat

by grouping instances of the same type into arrays.

The rationale is to be able to generate for loops with iterators.

The previous code was working, but probably by chance.

Actually, that was the default behavior. Now the default behavior is
to generate loops for iterators.

nb : with -2ch, loops are still always inlined

Indeed, an iterator is a kind of node.

combined with -cc, actually computes the wcet.

nb : only works if wcet tools are installed (owcet.arm, arm-elf-gcc)

combined with -cc, actually computes the wcet.

nb : only works if wcet tools are installed (owcet.arm, arm-elf-gcc)

That generated dummy main calls one step function and exits.

Imposes -2c.

Indeed, in order to sort Soc.gao, I currently process in 3 stages ;
1. compute a total ordering of Actions.t according to the deps
2. transform Actions.t into Soc.gao (List.map)
3. factorize Soc.gao by looking at consecutive gao that have the same guard

With this change, between steps 1 and 2, I reorder the list of actions
so that group of independent actions are sorted according to their
clock. The idea is of course to provide to step 3 more opportunities
of factorization.

The result is not very convincing yet.

I've also tried to sort the actions wrt their clock before performing
the toposort. Seems not too bad.

I've kept the old behavior by default though.

Indeed, having two different mechanisms is bad.

In the end, I've kept mine (and not the one of Pascal), because the
it was depending on LicPrg.t, which was creating a circular dep
(which could of course be fixed, but I am lazy).

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.