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

and PredefEvalClock.

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

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

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

EvalNode.f

rename back predef_node into by_pos_op.

currently only evaluates predef nodes.

	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.

	 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.