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.

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

Also, in verbose mode, print the full path of the openned files.

that are used to instantiate the model.

Indeed, the current parser forbids  the use of "uses" statements in a
model instanciation. I  could have changed the syntax,  but I was not
able to  find a satisfying  way to do  it. For instance, in  order to
declare that package Toto uses packege Util, should we write

	package Toto uses Util; = M(int, int, Util::foo);
?

The  semicolon is  really ugly.  And it  is so  easy to  realise that
package Util should be used...

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

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

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.

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

Also, node aliased to other nodes were handled poorly: I was replacing
in the syntax tree the node by its alias. Now, I really define
the alias node using the aliases one.

For instance,

    node toto(x:t) returns (y:t);
    let
      ...
     tel
     node titi = toto;
     node tutu(...) returns(...);
     let
        ...
	z = titi(a);
     tel

was compiled into

    node toto(x:t) returns (y:t);
    let
      ...
     tel

     node tutu(...) returns(...);
     let
        ...
	z = toto(a);
     tel

Now, I generate

     node toto(x:t) returns (y:t);
     let
       ...
     tel
     node titi(i1:t) returns (o1:t);
     let
       o1 =toto(i1);
     tel
     node tutu(...) returns(...);
     let
        ...
	z = titi(a);
     tel

which is equivalent, but closer to the original program.

they were not abstract.