Remove a lot of warnings (considered as errors by dune).

By not catching errors, rdbg and (thus) lurette were silently do nothing
in presence of errors in Lustre files.

And it is now done only by Lic2soc (L2lCheckLoops is not used anymore)

Also, during this change, I was bitten again by the « "__" versus "::" in ident
names » problem again.

The core of this problem is due to the fact that I use LicDump both for
(1) dealing with internal ident names
(2) generating lustre files

Because of (2), ident names may depend on the ec or the v4 option. hence, internal
names were sometimes translated with "__" instead of "::".

To (try to) fix that, I've added a boolean flag to all "to_string" functions that
states whether the function is used for internal purposes, or for generating lustre
files.

It was quite a boring change, that triggered other problems, that I've fixed
in this (too long) commit :
 - -esa should force -en, otherwise bad things happen (-esa is used for -ec anyway)
 - in -esa mode, #/nor inputs tuples of bool, not arrays
 - fix the list of predi op that returns a type different that its arg (SocPredef)

It was generetaing wrong code in conjunction with -ec.

In particular, it was generating n-any "and" instead of binary "and".

Also, I needed (in L2LExpandEnum) to generated a Lic.ARRAY of const
instead of a Lic.Array_const_eff so that LicDump properly generated
ec code.

To do that, I have created a new dedicated module L2lExpandEnum, that
actually also deals with -eei (which was probably wrong, even if I
have not counter-exemple).

Use 1-hot encoding instead of log-encoding

I've fixed a bug in L2lExpandArrays that occurs on equation such as
  some_bool = (some_array1 = some_array2);

Also, I've rewritten Lv6Compile for more readability

Remove duplicated code when using SocMap.find and co

which was not even compiling...

nb : i have changed the var name in the generated nodes, which was a bad idea
(=painful to get it rigth again).

so that w7/lesar can help otawa/ilp to prune path in the binary.

nb : not working on the convertible example:
 - sometimes the module name still appear in the ident (enums)
 - clocks are not well supported by Lesar actually. More thinking is necessary.

Because otherwise, V4 ec tools behaves strangely.

The bug was appearing a node was called on a non base clock that was
existing in the called nodes (name clash). Typically, it occurs on
recursive node called on some non-trivial clocks.

Also, use maps instead of list to hold the substitution between
params and args.

and replace enumerated clock in the var_info even if it does not
appear in a val_exp.

nb : luciole-rif is now  in the rdbg repo.

More precisely, transforms equations of the form

   y = x when Toto(c);

into

   x when Toto_c ;
   Toto_c=Toto(c);

('::' vs '__')

soc2c -2cw7: use mkff+fixffx+arm.looploc to fix extern lib calls.

Ditto for Misc and Compile

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

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.

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.

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

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.

More precisely, it was always returning the default value when the
activation condition was false instead of returning "dft_val fby out".

 nb : #FAILS=84->81

(to be kind with data plotters).

As far as ldbg is concerned, it only traces the toplevel node, at
call event.

Note that I needed to rename quite a lot of modules to avoid name clashes
between lus2lic.a and ltop.

I've also merged the Verbose module with the one of Lutin so that
they can be shared (there were sharing 95% already).

Also Merge the Global and the MainArg module as they were
(bizzarely) both handling command args options.

In order to do that, I've generalised the type of merge : now the clock
argument can be any expression. Some assert false still prevent its use,
but it should be easy to get rid of them (I'll do that latter).

nb : programs do run, but I did not check that they run correctly...

Also fix a regression introduced in the previous change where
incorrect ec code was generated for diese.

1) At the Lic level, there's no reason to distinguish betwenn node
calls, and predef node calls. Indeed it makes things simpler and more
homogeneous afterwards.

2) int strings are only converted when necessary (constant evaluation).

3) const are handled directly under Lic.by_pos_op instead of being under
   PREDEF_CALL, which make things easier and more logical.

Can be tried unsing the -exec option.

currently only working with trivial programs manipulating equalities
(wires) and predef operators (no pre, ->, arrays, and node calls).

Indeed, the data structure in output of the lis2loc parser was very
similar to Lic.t/LicPrg.t. Hence, this shunt.

At this stage it compiles, but it's untested and does not work.