#ifndef     __TLIB__
#define     __TLIB__

/************************************************************************
 ************************************************************************
    FAUST compiler
	Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
    ---------------------------------------------------------------------
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 ************************************************************************
 ************************************************************************/
 
 
 
/*****************************************************************************
******************************************************************************
							TLIB : tree library 
						Y. Orlarey, (c) Grame 2002
------------------------------------------------------------------------------
Tlib is a simple tree library inspired by the ATerm library. It is made of
five elements : symbols, nodes, smartpointers, trees and lists :

     +------------------------+
     |  	  shlysis 		  |
     +------------------------+
     |  		rec	  	   	  |
     |------------------------|
     |  	    list       	  |
     |------------------------|
     |  	    tree 		  |
     |------------------------|
     | nodes   |			  | 
     |---------| smartpointer |
     | symbol  |			  |
     +---------+--------------+

 API:
 ---- 
 	1) Symbols :
	------------
 	Sym q = symbol("abcd"); 	: returns a symbol q of name "abcd"
	const char* s = name(q); 	: returns the name of symbol q

	2) Nodes :
	----------
	Node(symbol("abcd")); 	: node with symbol content
	Node(10);				: node with int content
	Node(3.14159);			: node with float content
	
	n->type();				: kIntNode or kFloatNode or kSymNode 
	
	n->getInt();			: int content of n 
	n->getFloat();			: float content of n 
	n->getSym();			: symbol content of n 

	- Pattern matching :
	
	if (isInt(n, &i))	... : int i = int content of n
	if (isFloat(n, &f))	... : float f = float content of n
	if (isSym(n, &s))	... : Sym s = Sym content of n

 	3) Trees :
	----------
 	tree (n)			   : tree of node n with no branch  		   
	tree (n, t1)		   : tree of node n with a branch t
	tree (n, t1,...,tm)    : tree of node n with m branches t1,...,tm
	
	- Pattern matching :
	
	if (isTree (t, n))  	   ... : t has node n and no branches; 
	if (isTree (t, n, &t1)     ... : t has node n and 1 branch, t1 is set accordingly; 
	if (isTree (t, n, &t1...&tm)...: t has node n and m branches, ti's are set accordingly; 
	
	- Accessors :
	    	
	t->node()		   : the node of t     
	t->arity()  	   : the number of branches of t
	t->branch(i)	   : the ith branch of t

	4) List :
	---------
	
	nil					= predefined empty list
	cons (x,l)			= create a new list of head x and tail l
	list(a,b,..)		= cons(a, list(b,...))
			
	hd(cons(x,l)) 		= x, 
	tl (cons(x,l)) 		= l
	nth(l,i)			= ith element of l (or nil)
	len(l)				= number of elements of l
	
	isNil(nil) 			= true 		(false otherwise)
	isList(cons(x,l)) 	= true 		(false otherwise)
	
	lmap(f, cons(x,l))	= cons(f(x), lmap(f,l))
	reverse([a,b,..,z])	= [z,..,b,a]
	reverseall([a,b,..,z])	= [ra(z),..,ra(b),ra(a)] where ra is reverseall
	
	- Set :
	(Sets are implemented as ordered lists of elements without duplication)
	
	isElement(e,s)			= true if e is an element of set s, false otherwise
	addElement(e,s)			= s U {e}
	singleton(e)			= {e}
	list2set(l)				= convert a list into a set 
	setUnion(s1,s2)			= s1 U s2
	setIntersection(s1,s2)	= s1 intersection s2
	setIntersection(s1,s2)	= s1 - s2
	
	- Environment : 
	
	pushEnv (key, val, env) -> env' create a new environment
	searchEnv (key,&v,env) -> bool  search for key in env and set v accordingly

	- Property list :
	
	setProperty (t, key, val) -> t		add the association (key x val) to the pl of t
	getProperty (t, key, &val) -> bool	search the pp of t for the value associated to key
	remProperty (t, key) -> t			remove any association (key x ?) from the pl of t

	5) Recursive trees
	------------------
		
	rid()				= a unique ID (a tree) used to identify recursive trees
	rec(id, t)			= a tree containing recursive references 'ref(id)'
	ref(id)				= a reference to a surrounding 'rec(id,t)'
	isRec(t, id, t')	= true if t = rec(id,t')
	isRef(t, id)		= true if t = ref(id)
	
	areEquiv(t,t')		= alpha equivalence of trees
	shmax(t)			= maximize the sharing of recursive subtrees


	6) Sharing Analysis :
	---------------------
	
	shprkey(t) -> k		= unique sharing property key of t
	shcount(k,t') -> n	= returns the number of occurences of t' in t (where k = shprkey(t))
	shlysis(t)	-> k	= annotated the subtrees of t with prop (key sharing-count)
						  (0 if t' is not a subtree of t)
	
	
 History :
 ---------
 	2002-02-08 : First version
 	2002-02-20 : New description of the API
 	2002-04-07 : Added Sharing Analysis 'shlysis.h'
	
******************************************************************************
*****************************************************************************/

#include "symbol.hh"
#include "node.hh"
#include "tree.hh"
#include "num.hh"
#include "list.hh"
#include "shlysis.hh"
#include "recness.hh"

#endif
