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

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.

work yet though (returns the wrong type).

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

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.

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

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

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.

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.

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.

Better error msgs.

Renaming idents.

	 oper -> node
	 func -> extern node
	 node -> (user) node

	 CALL_BY_NAME -> STRUCT_n
	 STRUCT_EXP_n -> STRUCT_anonymous_n
	 flaged -> flagged

src/syntaxTreeCore.ml (new file)
	Split      syntaxTree.ml      into     syntaxTree.ml      and
	syntaxTreeCore.ml. The idea is that lic2loc should be able to
	use syntaxTreeCore.ml verbatim.

src/lxm.ml
src/lxm.mli
	remove pack_name from  this module, so that it  can be shared
	with  lic2loc too  (this is  mandatory  since it  is used  by
	SyntaxTreeCore)

src/compile.ml
src/compiledData.ml
src/evalConst.ml
src/evalConst.mli
src/evalType.ml
src/evalType.mli
src/expandPack.ml
src/lazyCompiler.ml
src/main.ml
src/parser.mly
src/symbolTab.ml
src/symbolTab.mli
src/syntaxTab.ml
src/syntaxTreeDump.ml
src/syntaxTreeDump.mli
src/test/Makefile
src/test/packs.lus
src/test/test.res.exp
	opening SyntaxTreeCore  module, and inline  the definition of
	Lxm.pack_name.

	Also,  begin  to  replace  oper  by node  or  predef_node  in
	identifiers, in order to get a more consistant naming scheme.

Ident.t is now an abstract data type (instead of a string).
fullid is turned into an Ident.long, and is also made abstract.

Add basic regression tests.

Add "assert false" statements everywhere it was necessary.

Add the fby operator in the syntax.