was used in  the local variables generated to  split expressions into
atomic expressions.

Indeed,  when  such an  intermediary  expression  is  inferred to  be
variable, it is  ok to consider that  it is on the base  clock. And I
was missing such a case.

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.

lexing nightmares in lic2loc.

to avoid priority errors.

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.

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.

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

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

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

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

(which was not supported anyway).

Fix all  the nonreg  test input  files to conform  to new  the struct
syntax (and  re-indent them sometimes). Since that  fixed some compil
errors, it also revealed quite a lot of other type errors!  Therefore
I have also fixed the nonreg test input files so that they compile.

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

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

when trying to  unify, e.g., "a^3" and "int^3".   Such kind of things
occured when one imbricates iterators.   In fact, it was not possible
to get it rigth with  the data representation used for node profiles,
which was not sufficiently general.

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

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

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

tests.

Also, Add the possibility to have several lustre files in the
command-line arguments.

remove the power operator.

Define a lustre.lus that contains a packaged version of Lustre
predefined operators. It will be in the standard lustre library,
and should be accessible directly (path).

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.