simple, and also avoids  3 shift/reduce conflicts. It also make
the pragma stuff more homogeneous  and simple to explain in the
manual.

Moreover, pramgma  are no  more attached to  AST nodes,  but to
lexemes.

Note that by polymorphic here I mean *really* polymorphic, since they
can handle tuples, which is no the case of, let's say, "<".

splitting expressions.

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.

test/should_work/Pascal/t1.lus

+ typos

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

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

the parameters  input types are  compatible with Unify.f.   Apply (if
necessary) the resulting substitution to the output parameters.

Also,  when checking array  concat, try  to unify  the types  of both
arrays instead of just checking their equality.

This of course triggers some errors in the non-reg tests.  One of
this error is due to a bug in the parser, where the list of parameter
was inversed twice. I've also fixed that in this change.

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.

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

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

before '..'.

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

no node is provided at  the command-line.  Instead, compile all items
even if the --compile-all-items option is not provided.

package.

Better  error msg  when instanciating  a  model by  provided a  wrong
number of arguments.

in  the nonreg  tests.  They are  currently  ignored. Moreover,  they
should be added at other places (or maybe handled differently).

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

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

work yet though (returns the wrong type).

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

overloaded operator.

Moreover, do not try to check that int or real constant are ok. It is
the role of the host language.