nodes (e.g., map<<+,2>>). While fixing  that, I put all the functions
that deals with polymorphism into a new (Eponymous) dedicated module.

The idea to be able to expand polymorphic node is basically the same,
as the one for printing polymorphic  nodes: we need to wait until the
type is instanciated (in GetEff).  That delay is implemented by using
a stack of nodes.

an expanser to will expand only struct, and i whant to name it like that).

In  short, the  rationale for  this change,  is that  it is  having a
recursive node_exp is
- useless,
- too complicated,
- wrong w.r.t. nesting iterator calls

In long:

- It is useless because, at the  Eff level, a node cannot call itself
  via one  of its  static arg (which  was where the  recursivity came
  from).

- and indeed, it  is much simpler to consider that  a static arg node
  can only be ident.long that identifies a node alias.

  This  means of  course, that  nested iterators  have  been unnested
  before,   inventing  alias   node  names   along  the   way...  And
  polymorphism makes thing difficult once again.

- But the  *big* problem  with a recursive  node_exp is that  it make
  things very  complicated to (lic)dump nested  iterator call because
  of polymorphism!   Actually, it  even makes thing  complicated when
  the iterators were themselves not nested in the source code !

  Some ugly  things were done in  LicDump to unnest  those calls when
  printing node_exp.   But this uglyness  have a price:  tricky code,
  and bugs! Indeed, nested iterators calls were wong for example when
  using  the --inline-iterator  mode (but  i would  not  be surprised
  that is wrong in other cases...).

Hence,  LicDump  is  simpler,  but  of course  LazyCompiler  is  more
complicated.  But  this  is  reasonable:  a  pretty-printer  is  not
supposed to be complicated.

To  do  that, we  centralized  the ident  name  creation  into a  new
dedicated module Name.

+ fix should_work/NONREG/param_node.lus, we contained a combinational loop.

(--inline-iterators) to activate it.

nb : do not inline completely nested iterator calls (yet, cf TODO).

by position). Rename ExpandPack into InstanciateModel.

dead hits versus all hits).

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.

PredefEvelClock, in a similar manner as for 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

compact, cleaner, and correct wrt negative steps in array slices.

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

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

and PredefEvalClock.

SolveIdent.recognize_predef_op  that  replaces  node call  by  Predef
constructor  when   necessary,  via  a  complete   traversal  of  the
SyntaxTree (instead  of doing it  in the parser). The  rationales for
this change are that:

- it is quite tedious to do it in parser as multiple locations are involved
- I did missed some locations
- It makes the parser more focused on parsing issues
- that traversal  is a first step  do deal with  idref solving (hence
 the name of the new module that contains that function

Note that lsrc/test/should_work/fab_test/lecteur.lus was using
"plus" as a variable ident, which raised an error, which

(well, for the first file, the numbers were ok :-).

Also, begin to sort out a little bit the mess in the Global module.

Moreover, augment the necessary print level of most internal structure
dumping function.

of "red<<if, 3>>".

Put the unification stuff in  a dedicated module, and add some random
unit tests to it.

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.

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

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

used in order to make it homogoneous with what is done in SyntaxTreeCore.ml

This commit is related to the previous one actually.

Also remove all this story of node_half_eff that is not
used (yet), and that may not be useful (we'll see later).

Also continue to fix the representation of SyntaxTrreCore.node_info :
 -> remove the node alias
 -> put the corresponding infomation in node_body field
 -> rename node_body field into node_def
 -> associate to node_def (instead of a body option) a new union
type made of Abstract, Extern, Alias of ..., Body of ...

This allows us to
 - remove an "assert false" to deal with node with body and alias
(this new presentation makes it impossible)
 - Deal with Abstract node properly

currently only evaluates predef nodes.

git commit.