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

command-line) to compile a node in a package that does not exist.

functions.    But   Those   functions    are   also   used   by   the
Lazycompiler.x_check_interface_do,  so  that  items declared  in  the
provide part were printed twice the generated code.

This change  removes the  item printing for  items compiled  from the
provide part.

Also, make  sure that "make  test" returns a  non empty exit  code so
that "make cia" does not perform the commit when the test fails...

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.

	type 'a hereflagged =
	  Here of 'a
	| NotHere of Ident.long
into
	type 'a elt =
	  Local of 'a
	| Imported of Ident.long * static_arg list

i.e., i am basically doing two things:
 - fix poor naming
 - adding static arg to nodes

indeed, when compiling an equation that involves nodes defined
in another package, I need to check that the static args and the
static params match. Therefore I need to have the static params !
Therefore I add them (I will use them in the next commit).

Moreover, in SyntaxTreeCore.node_info, the static_params list was
an option type, which is a bit weird (empty lists are enough to
represent node with no static params).

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

in the shoud_work directory!).

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.

and anonymous structures. I've even found some type errors in the non-reg files!

operators. Predef contains the abstract syntax of those operators (taken
for SyntaxTreeCore.by_pos_op), and PredefSemantics contains:

 - const_eval: that says how to statically evaluate constants
 - type_eval: that provides the type profile of predef operators
 - clock_eval: that provides the clock profile of predef operators

The code in EvalConst that dealt with predef const evaluation is now in
Predef.const_eval

EvalNode.f -> GetEff.node,
EvalType.f -> GetEff.typ,
EvalEq.f -> GetEff.eq

EvalConst.f (val_exp -> const_eff list) should have been put there too,
but in fact EvalConst.f ougth to be splitted in two parts:
  - val_exp -> val_exp_eff (but this function already exist)
  - val_exp_eff -> const_eff list

Therefore, the signature of EvalConst.f will be changed to:
val_exp_eff -> const_eff list (and will use GetEff.val_exp)

Ditto for eval_array_index.

 eval_array_index : CompiledData.id_solver -> SyntaxTreeCore.val_exp -> int -> int

ougth to be splitted into two functions:
   - CompiledData.id_solver -> SyntaxTreeCore.val_exp_eff
   - SyntaxTreeCore.val_exp_eff -> int -> int

Ditto for eval_array_size

 eval_array_size : CompiledData.id_solver -> SyntaxTreeCore.val_exp -> int

ougth to be splitted into two functions:
   - CompiledData.id_solver -> SyntaxTreeCore.val_exp_eff
   - SyntaxTreeCore.val_exp_eff -> int

arg... evalConst.f est utilis par GettEff.typ !!!

values could not be exported, while expandPack.ml was exporting it.

by piping the output od find by sort in the test/Makefile.

This is done via the new module EvalEq.

A lot of new errors appear in the on-reg tests, which is normal as
quite a lot of the code is now used...

predefined nodes. The idea is that the Predef module will contain
all the necessary information to build a node_info_eff for each
of the predefined operator.

It migth makes thing more difficult to deal with overling, but we'll
see later how to fix that. Anyway, not all the predefinef operator
are overloaded, so...

used in order to make it homogoneous with what is done in SyntaxTreeCore.ml

This commit is related to the previous one actually.

Also remove all this story of node_half_eff that is not
used (yet), and that may not be useful (we'll see later).

Also continue to fix the representation of SyntaxTrreCore.node_info :
 -> remove the node alias
 -> put the corresponding infomation in node_body field
 -> rename node_body field into node_def
 -> associate to node_def (instead of a body option) a new union
type made of Abstract, Extern, Alias of ..., Body of ...

This allows us to
 - remove an "assert false" to deal with node with body and alias
(this new presentation makes it impossible)
 - Deal with Abstract node properly

change is
	- make the parser simpler
	- make the compilation simpler
	- make everything simpler actually...
	- accepts more correct programs.
	- etc.

Indeed, before, we had specific syntax nodes for
	- extern nodes
	- aliased nodes
	- abstract nodes
	- normal nodes
which leads to duplicate code everywhere. Now, we have a more generic
representation.

The nice thing is that the parser is much simpler, and a lot of
duplicated code is avoided (for example, extern and abstract nodes do
now share the same code).

The bad thing is that we have more "assert false" lying everywere due
to this «too rich» representation, in order to deal with cases
that can never happen. For exemple, we have to do something with
nodes that have  both an alias and a body. This cannot happen of
course, so we issue an "assert false", which is a little bit painful,
as it have been rejected by the parser anyway.

Moreover, for some reason, external node params could not be clocked,
and cannot have static params. Maybe it is not possible to compile
such nodes (I don't know yet), but we should not raise a syntax error IMHO.

Somehow, what was done was very similar to ask the parser to perform type
checking.

EvalNode.f

rename back predef_node into by_pos_op.

i.e.,
	a = operator +(1,3);
or
	a = map<<operator +>>(l);

This is to simplify the syntax tree. We migth undo this change in the
future, or perform the same thing differently.

sensible to flushing, which is painful.

around a lexing bug that I don't know how to fix yet.

Add Some lustre files that are automatically tested thanks to the
generic Makefile (from the Youssef compiler).

Test files are organized as follows :

 - files in directories that are under the "should_fail" directory
  do triggers errors, but it is intented

	should_fail/syntax
	should_fail/type
	should_fail/semantics

 - and files that should not trigger any error:

	should_work/

currently only evaluates predef nodes.

To do that, we :

(1) totally remove  (in the  ocaml code) the  use of "oper",  and use
"node" instead.  Indeed, a node  is a memoryfull operator, as opposed
to function that are memoryless operators.  However, lus2lic does not
really care about memoryless  and memoryfull information. Therefore I
prefer  to use  node everywhere,  and to  flag node_info  to indicate
whether it has memories or not.

(2) change the syntaxTreeCore type to make it more general. Indeed,
    the distinction between functions and nodes was

    - redundant:  extern nodes  and (extern)  functions  were handled
    differently (NodeExtern versus ExtNode (was named FUNC before)).

    - and  incomplete:   it  was  not  possible   to  provide  static
      parameters to function, nor to define functions with body, etc.

Now a  function is  just a memoryless  node. The check  that function
indeed use no memory will be done later.

(3) also,  change  the  parser   so  that  functions  with  body  are
    accepted.

(4) in order  to do it step by  step, I add the  "extern" keyword" so
    that extern nodes and functions are more easy to parse. I will
    remove it later.

git commit.

	Do not test nodes with static params as it is too difficult
  	to do from the top-level automatically. Indeed, it would
	require to build effective static arg before, which would
	require to make node_check mutually recursive with type_check
	and co. Its not worth the trouble, as such node can be tested
	anyway if used.

LazyCompiler.solve_node_idref:
	compile (with the new function check_static_arg) static
	params instead of ignoring them.

EvalConst.eval_const -> EvalConst.f
	for simplicity and homogeneity with the naming scheme used in EvalType.

Better error msgs.

Renaming idents.

	add a debug rule that hides the mli files and make debugging
	easier w.r.t. var printing.