The  idea  is  the  following:  each  time  a  nested  iterator  call
(map<<map<<n,3>>,4>>) is  encountered, we  create a fresh  alias name
(create_alias_name) ad we  add it in the node_alias_tbl.   At the end
of the  compilation, LicDump.dump_node_alias is  called, which prints
the definition of those node aliases.

For example, the expression  "map<<map<<n,3>>,4>>" is printed like this:

    map<<_node_alias1, 4>>

and later, the node alias is defined:

    node _node_alias1(x:int) returns(y:int); let y = map<<n,3>>(x); tel;

as many  new local  variables as necessary  so that an  expression is
made at most of one operator.

The rational  for that  is to obtain  a lic  code that is  trivial to
clock check (nested node calls, for example, make it less simple).

The old behavior can still be obtained using --keep-nested-calls.

During  that  change,   I  realised  that  I  did   not  clock  check
asserts. Hence, I have also added this check.

to avoid name clashes in the lic.

Add some tests with various kinds of expr that we can have after a when.

clock_info, and  therefore also  remove clock_info. The  rationale of
this  change is  that  it  makes things  slightly  simpler, and  more
homogeneous with what is done in type checking.

Not yet implemented (assert false): iterators, struct

Add a UnifyClock module, and rename Unify into UnifyType.

nb : a lot of test are now broken, because
   - the clock checking is now plugged ;-)
   - iterators, struct are not yet implemented

are defined exactly once.

This  algo is  naive and does not  work with  slices of  slices with
negative steps.  I commit it  before trying a  new one to  get better
non-reg test.

Fix some non-reg test in the should_work dir that this new check revealed.

It  does not  work, I  have changed  my mind  to use  a  more general
clocking algorithm based on  unification. I commit that current state
just in case I change my mind again...

type_eff_ext into type_eff btw). The  rationale is to be able to type
alias           on           polymorphic          nodes           (cf
test/should_fail/semantics/bad_call03.lus,  that now  have  a correct
error msg).  It also makes  to code more compact (no more translation
from one  to the  other), and more  general (type_eff_ext  being more
general than type_eff).  User polymorphic nodes should be easy now.

move all the code in parsey.mly into parserUtil.ml (ease the debug).

variables according to their clock dependencies, which is wrong since
that order is partial. I've implemented a topological sort instead.

equations is not done at all yet). Also, print the clock decorations
(when clk) in the generated file.

and PredefEvalClock.

represented. Indeed, it was represented by "HAT_eff of int *
type_eff" instead of "HAT_eff of int * val_exp_eff"

work yet though (returns the wrong type).

Also add the struct printer, and fix a bug in the static argument printing.

performed. The resulting code is both more compact, and more general.

It is more  general, since that predef operators  are now represented
by  node_exp_eff, exactly as  user nodes.   Hence, all  the functions
that were  operating on  user nodes via  node_exp_eff (such  as, node
aliasing) works for free on predef op!

In order to be able  to perform that generalisation, it was necessary
to  extend sligthly  the data  structure used  to represent  the node
profile in CompiledData.node_exp_eff with information indicating if a
variable is polymorphic or overloaded.

Not that, currently, polymorphic  or overloaded variables can only be
introduced by predef  operators. But I think it would  be easy to add
those notions for normal user nodes after this change.

New non-reg files boolred now compiles. Those involving
- boolred
- alias on predef.op

Also, node aliased to other nodes were handled poorly: I was replacing
in the syntax tree the node by its alias. Now, I really define
the alias node using the aliases one.

For instance,

    node toto(x:t) returns (y:t);
    let
      ...
     tel
     node titi = toto;
     node tutu(...) returns(...);
     let
        ...
	z = titi(a);
     tel

was compiled into

    node toto(x:t) returns (y:t);
    let
      ...
     tel

     node tutu(...) returns(...);
     let
        ...
	z = toto(a);
     tel

Now, I generate

     node toto(x:t) returns (y:t);
     let
       ...
     tel
     node titi(i1:t) returns (o1:t);
     let
       o1 =toto(i1);
     tel
     node tutu(...) returns(...);
     let
        ...
	z = titi(a);
     tel

which is equivalent, but closer to the original program.

(support for fill, red, etc. is coming soon).

In order to add support  for iterators, I have extended the by_pos_op
(and the by_pos_op_eff) data type with a list of static arguments. In
other words, iterators are handled as a particular case of predefined
operators.

t, and a node returning such a t, the compiler was actually returning
the type definition of t (instead of the abstract type).

In  order  to fix  that,  it  was necessary  to  add  in argument  of
Lazycompiler.solve_x_idref  a  flag  (named provide_flag)  indicating
whether the  item being  compiled appears in  the provide, or  in the
body part of the package.

This fix  triggered another bug that  we also fix: indeed,  it is not
correct to return  a compile error when the  provided parameters of a
node is not equal to  its implementation. Indeed, such parameters can
be abstract type that are defined in that package.

The test "should_work/packEnvTest/packages.lus" is now ok.

	type 'a hereflagged =
	  Here of 'a
	| NotHere of Ident.long
into
	type 'a elt =
	  Local of 'a
	| Imported of Ident.long * static_arg list

i.e., i am basically doing two things:
 - fix poor naming
 - adding static arg to nodes

indeed, when compiling an equation that involves nodes defined
in another package, I need to check that the static args and the
static params match. Therefore I need to have the static params !
Therefore I add them (I will use them in the next commit).

Moreover, in SyntaxTreeCore.node_info, the static_params list was
an option type, which is a bit weird (empty lists are enough to
represent node with no static params).

not compile them is (well, was) the default...).

also, during pretty-printing, remove the type in the constant definition
(e.g., "const x = 42;" instead of "const x = 42:int;"), except if it is an abstract
constant of course

in the shoud_work directory!).

For non-regression tests, do not use Lazycompiler.test function
anymore and just use  LazyCompiler.node_check instead.

put in the new file compiledDataDump.ml all the stuff
related to string convertions of CompiledData items.

and anonymous structures. I've even found some type errors in the non-reg files!

operators. Predef contains the abstract syntax of those operators (taken
for SyntaxTreeCore.by_pos_op), and PredefSemantics contains:

 - const_eval: that says how to statically evaluate constants
 - type_eval: that provides the type profile of predef operators
 - clock_eval: that provides the clock profile of predef operators

The code in EvalConst that dealt with predef const evaluation is now in
Predef.const_eval

EvalNode.f -> GetEff.node,
EvalType.f -> GetEff.typ,
EvalEq.f -> GetEff.eq

EvalConst.f (val_exp -> const_eff list) should have been put there too,
but in fact EvalConst.f ougth to be splitted in two parts:
  - val_exp -> val_exp_eff (but this function already exist)
  - val_exp_eff -> const_eff list

Therefore, the signature of EvalConst.f will be changed to:
val_exp_eff -> const_eff list (and will use GetEff.val_exp)

Ditto for eval_array_index.

 eval_array_index : CompiledData.id_solver -> SyntaxTreeCore.val_exp -> int -> int

ougth to be splitted into two functions:
   - CompiledData.id_solver -> SyntaxTreeCore.val_exp_eff
   - SyntaxTreeCore.val_exp_eff -> int -> int

Ditto for eval_array_size

 eval_array_size : CompiledData.id_solver -> SyntaxTreeCore.val_exp -> int

ougth to be splitted into two functions:
   - CompiledData.id_solver -> SyntaxTreeCore.val_exp_eff
   - SyntaxTreeCore.val_exp_eff -> int

arg... evalConst.f est utilis par GettEff.typ !!!

This is done via the new module EvalEq.

A lot of new errors appear in the on-reg tests, which is normal as
quite a lot of the code is now used...