to avoid priority errors.

iterators (e.g.,  "Lustre::plus" instead of "Lustre::+")  in order to
make the life of lic3loc easier.

to avoid priority errors.

to avoid priority errors.

to avoid priority errors.

parenthesis, but after an equal sign, as in lv6.

profiles constain only named types.

Typically, instead of printing:

           node toto(x: int ^ 4) ...

print something like :

           type int4 = int ^ 4
           node toto(x: int4) ...

Moreover, in  order to  avoid name clashes,  we prefix all  user name
type by "_".

e.g., instead of

        type toto = toto { ... };

we now print

        type toto = struct { ... };

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

PredefEvelClock, in a similar manner as for type checking.

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

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.

when printing (left part) field acces.

definition instead of the type name in node profiles.

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.

ordering in order to handle  clocks properly, but I forget to reorder
them back for the interface variables!

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.