Add a -tlex option to debug the lexer.

Also, rename the rules in parser.mly now that their appear in the manual.
This renaming work is in progress though.

maintaining (ugly and error-prone) hash tables.

That change revealed an untriggered bug in EvalClock.check_args: it was wrong
to add in subst the substitutions made of the parameters and the arguments (it
is enough to unify the clocks of the pars and of the args). For instance, consider
the node (in should_work/clock/clock.lus)

   node clock5(x :  bool; y:  bool when x; z: bool when y)

and the call

  z2 = clock5(a, b when a, c when e);

I was adding y/b in the subst, which was wrong.

Other minor changes:
 - move const_to_val_eff from Eff to UnifyClock.
 - GetEff.translate_val_exp now returns a substitution, in order to be able
   to unify clock vars and propagate the resulting substitution.

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.