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

To do that, I've used the (un)expand_profile function defined in SocExec
(and put the in a new module with a more neutral name: SocVar).

expected passes		1116 -> 1121
unexpected failures	282 -> 277

- Generate code for most predef operators.
- Generate a loop.c file (in a similar manner as ec2c -loop does)

It generates C code that compile on at least one example.

Work in progress...

cf git sha 55d3d77c470f416befd16a1b7d47f751eb2171fc of rdbg

More specifically, replace @ by rev_append and flatten+map by fold_left.

On a file that has 11000 equations (normal.ec), I win a factor 4: 60s -> 15s

The main difference is that I use a map instead of list to store
visited nodes.  The compilation time of normal.ec is divided by 2!!
(35s->15s)

We do not really see the difference in the time of the non-reg tests
since the execution of normal.ec still exceeds the 10s timeouts.

Also add support to rdbg to perform nonreg test. I do not plug yet it
as it's twice slower. but most of it seems due patch_ecexe. Indeed,
lus2lic -interface compile the whole program just to print the node
interface.

nb: it has detected a couple of existing bugs.

Fix a bug in socExec.ml (strangely untriggered before) along the way.

The test now runs in 150s (versus 417s)

[...] for some reasons, i cannot reproduce the 150s !!!

Indeed, I've intentionally removed the when statements in clocked local var like this :

 var
    v:int;

because the following was producing a syntax error in ecexe:

 var
    v:int when c;

But Actually, the right thing to do was to generate the following:

 var
    (v:int) when c;

...

nb : #FAILS=90->89

I though polymorphism was removed by l2lRmPoly.ml, but well, it was easy.

nb : #FAILS=131->128

where equations such as " ok = (x=x_ref); " are translated into incorrect v' lustre
when x is a structure or an array.

nb : #FAILS=152->135

(to be kind with data plotters).

Actually it does not fix any test, but I feel it is a (slight)
progress, so I commit it... Well, to be fair, one objective progress
is that I can now compile the test suite with the -np option.

(1) equations such as
 (x,y,z)=[0,0,0];
were generated with -en unless -ec was specified.

I've fixed that by always breaking tuples, even when global_opt.ec
is false (this condition was strange anyway).

(2) During node expansion, I create a fresh variable for each local
var in the expanded node, but old var names were still appering in
clock expression

indeed, consider that example :
var
  c:bool;
  x when c :bool;

I was generating something equivalent to

var
  c_fresh:bool;
  x_fresh when c :bool;

bou... Of course, it was working because in -ec mode, I need to
remove clock annotation when declaring local variables, which was
hidding the problem.

nb : because I've change test_lus2lic_no_node to use -lv4 instead of
-ec to generate the lustre oracle, which exposes new pbs (cf above).

(3) When expanding a node on the base clock with arguments on another
clock, I was not propagating that information (let's keep the
finger-crossed and hope the current fix is complete).

nb : the number of failing test cases is the same (5 new pass, but 5
new fail!!), but it actually is a progression. Indeed, the new test
failures ares due to the fact that this current change fixes a
problem that expose yet another one!

Actually, the newly exposed bug is not in the compliler, but in the
oracle I generate via the --auto-test option ; indeed, for testing
nodes which not all interface variables are one the base clock, I
should generate oracle that do take them into account.

112 tests failed, and 127 passed !!

Add --gen-autotest option that generates  a Lutin file and an oracle Lustre file suitable to compare the result of 2 Lustre compilers

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.

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.

BTW, put everything that concerns node environement into the new
IdSolver module (from the Lic module).

Also do not print type and const declarations with -ec.

nb : I've transformed all the regressions I've seen into todo entries
in todo.org.

nb 2 : I did not mv the newly broken tests into the broken dirs. I'll
do that for those I do not want to fix in the short term.

nb: les tests ne passent toujours bien sur.

* Partie lus -> AST

predef.ml -> srcPredef.ml
syntaxTreeCore.ml -> astCore.ml
syntaxTree.ml     -> astV6.ml
syntaxTreeDump.mli-> astV6Dump.mli

* Partie Ast -> Ast

solveIdent.mli -> astRecognizePredef.mli
syntaxTab.mli -> astTab.mli
symbolTab.mli -> astTabSymbol.mli

* Partie  AST -> lic (static evaluation)

eff.ml  -> lic.ml
getEff.mli -> ast2lic.mli
lazyCompiler.mli -> licTab.mli
builtIn.ml -> licMetaOp.ml
predefEval*.ml -> licEval*.ml
name.mli -> licName.mli

* Partie Lic -> Lic

uniqueOutput.mli      -> l2lCheckOutputs.mli
structArrayExpand.mli -> l2lExpandArrays.mli
nodesExpand.mli       -> l2lExpandNodes.mli
doNoPoly.ml           -> l2lRmPoly.ml
doAliasTypes.ml       -> l2lAliasType.ml
doSplit.ml            -> l2lSplit.ml

+ remise en place du souk qu'il a mis dans le repertoire test.

- il a commencé à rajouter le CondAct (tout est parti de la en fait...)
- il a coupé le LazyCompiler en morceaux

Pour cela, il a créé un nouveau module LicPrg qui définit la
structure de données (SDD) en sortie du LazyCompiler. Ensuite, les
diverses tranformations src2src sont faites à partir de cette SDD.

- il a débranché (temporairement) l'expansion de noeud et de array/structure

- il a débranché ma pseudo inférence de type et a mis à la place une
vérification de types.

- Le traitement du polymorphisme est effectué via une transfo src2src
dans DoNoPoly (que je vais renommer en RmPoly)

--------------------------------------------------------------------------
Par ailleurs,

J'ai créé un todo.org et un README.org que je vais essayer de tenir à jour.

nb: les tests ne passent toujours bien sur.

et donc ne marchent plus !