khanat-opennel-code/code/ryzom/tools/pd_parser/templatizer.h

// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef NL_TEMPLATIZER_H
#define NL_TEMPLATIZER_H

#include <nel/misc/types_nl.h>
#include <nel/misc/common.h>
#include <nel/misc/debug.h>
#include <nel/misc/eval_num_expr.h>

#include <vector>
#include <string>
#include <map>

class ITemplatizerBloc;

const char	EnvSeparator = '/';








/**
 * A Templatizer Env
 */
class CTemplatizerEnv : public NLMISC::CEvalNumExpr
{
public:

	/// Constructor
	CTemplatizerEnv(CTemplatizerEnv* parent) : Parent(parent), CurrentArrayNode(0)	{ }

	/// Destructor
	virtual ~CTemplatizerEnv();

	/// Clear Env
	virtual void		clear();

	/// Get value
	virtual std::string	get(const std::string& name);

	/// Set value
	template<typename T>
	void		set(const std::string& name, const T& value)
	{
		std::string::size_type dotpos = name.find(EnvSeparator);
		std::string		child = name.substr(0, dotpos);

		if (dotpos == std::string::npos)
		{
			setAsRawText(name, NLMISC::toString(value));
		}
		else
		{
			getEnv(child)->set(name.substr(dotpos+1), value);
		}
	}

	/// Set a Define
	void				define(const std::string& name)
	{
		set(name, 1);
	}

	/// Set a Conditional Define
	void				define(bool isdef, const std::string& name)
	{
		if (isdef)
			set(name, 1);
	}

	/// Does Variable exist?
	virtual bool		exists(const std::string& name) const
	{
		TValueMap::const_iterator	it = Values.find(name);
		if (it == Values.end())
			return (Parent == NULL ? false : Parent->exists(name));
		return true;
	}

	/// Does Sub Environment exist?
	virtual bool		envExists(const std::string& name) const
	{
		std::string::size_type dotpos = name.find(EnvSeparator);
		std::string		child = name.substr(0, dotpos);

		if (child.empty())
			return true;

		TEnvMap::const_iterator	it = Envs.find(child);
		if (it == Envs.end())
			return false;

		return (dotpos == std::string::npos) ? true : (*it).second->envExists(name.substr(dotpos+1));
	}

	/// Enter Sub Env, like getEnv() but it doesn't look in parent, and always goes in current env
	virtual CTemplatizerEnv*	getSubEnv(const std::string& name)
	{
		std::string::size_type dotpos = name.find(EnvSeparator);
		std::string		child = name.substr(0, dotpos);

		if (child.empty())
			return this;

		CTemplatizerEnv*	env = NULL;

		if (child == ".")
		{
			env = this;
		}
		else if (child == "..")
		{
			env = (Parent != NULL ? Parent : this);
		}
		else if (child == "...")
		{
			env = getRootEnv();
		}
		else
		{
			TEnvMap::iterator	it = Envs.find(child);
			if (it != Envs.end())
			{
				env = (*it).second;
			}
			else
			{
				env = new CTemplatizerEnv(this);
				Envs[child] = env;
			}

		}

		return (dotpos == std::string::npos) ? env : env->getSubEnv(name.substr(dotpos+1));
	}

	/// Get Sub Env
	virtual CTemplatizerEnv*	getEnv(const std::string& name)
	{
		std::string::size_type dotpos = name.find(EnvSeparator);
		std::string		child = name.substr(0, dotpos);

		if (child.empty())
			return this;

		if (child == ".")
		{
			return (dotpos == std::string::npos) ? this : this->getSubEnv(name.substr(dotpos+1));
		}
		else if (child == "..")
		{
			CTemplatizerEnv*	env = (Parent != NULL ? Parent : this);
			return (dotpos == std::string::npos) ? env : env->getSubEnv(name.substr(dotpos+1));
		}
		else if (child == "...")
		{
			CTemplatizerEnv*	env = getRootEnv();
			return (dotpos == std::string::npos) ? env : env->getSubEnv(name.substr(dotpos+1));
		}
		else
		{
			TEnvMap::iterator	it = Envs.find(child);
			if (it != Envs.end())
			{
				return (dotpos == std::string::npos) ? (*it).second : (*it).second->getSubEnv(name.substr(dotpos+1));
			}
			else
			{
				return Parent != NULL ? Parent->getEnv(name) : getSubEnv(name);
			}
		}
	}

	/// Get Sub Env
	CTemplatizerEnv*	getEnv(uint node)
	{
		return getEnv(NLMISC::toString("%08X", node));
	}

	/// Evaluate string (string replacement)
	virtual std::string		eval(const std::string& text);

	/// Get Next Array Node
	CTemplatizerEnv*	nextArrayNode(const std::string& array)
	{
		CTemplatizerEnv*	aenv = getSubEnv(array);
		uint				node = (aenv->CurrentArrayNode)++;
		return aenv->getSubEnv(NLMISC::toString("%08X", node));
	}

	/// Set Sub Env
	virtual void		setSubEnv(const std::string& name, CTemplatizerEnv* subenv)
	{
		Envs[name] = subenv;
	}

	/// Get Parent Env
	virtual CTemplatizerEnv*	getParent()
	{
		return Parent;
	}

public:

	/// Parent Env
	CTemplatizerEnv*	Parent;

	typedef std::map<std::string, ITemplatizerBloc*>	TValueMap;
	typedef std::map<std::string, CTemplatizerEnv*>		TEnvMap;

	/// Contained Values
	TValueMap			Values;

	/// Sub Env
	TEnvMap				Envs;

	/// Get Root Env
	virtual CTemplatizerEnv*	getRootEnv()
	{
		CTemplatizerEnv*	root = this;
		while (root->getParent() != NULL)
			root = root->getParent();

		return root;
	}

	/// Current Array Node
	uint				CurrentArrayNode;

	/// Set As Raw Text
	virtual void		setAsRawText(const std::string& name, const std::string& text);

	/// Set Value Node
	virtual void		setValueNode(const std::string& name, ITemplatizerBloc* bloc)
	{
		Values[name] = bloc;
	}

	/// Get Value Node
	virtual ITemplatizerBloc*	getValueNode(const std::string& name)
	{
		ITemplatizerBloc*	node = NULL;
		CTemplatizerEnv*	env = NULL;
		return getValueNodeAndEnv(name, node, env) ? node : NULL;
	}

	/// Get Value Node
	virtual bool		getValueNodeAndEnv(const std::string& name, ITemplatizerBloc*& node, CTemplatizerEnv*& env)
	{
		std::string::size_type pos = name.find_last_of(EnvSeparator);
		if (pos == std::string::npos)
		{
			node = getNode(name);
			env = this;
			while (node == NULL && env != NULL)
			{
				env = env->getParent();
				if (env != NULL)
					node = env->getNode(name);
			}
		}
		else
		{
			env = getEnv(name.substr(0, pos));
			if (env != NULL)
				node = env->getNode(name.substr(pos+1));
		}

		return node != NULL && env != NULL;
	}

	virtual ITemplatizerBloc*	getNode(const std::string& name)
	{
		TValueMap::iterator	it = Values.find(name);
		return it == Values.end() ? NULL : (*it).second;
	}

	virtual NLMISC::CEvalNumExpr::TReturnState	evalValue (const char *value, double &result, uint32 userData);
};


/**
 * A Templatizer Env
 */
class CTemplatizerRefEnv : public CTemplatizerEnv
{
public:

	/// Constructor
	CTemplatizerRefEnv(CTemplatizerEnv* ref) : CTemplatizerEnv(NULL), Reference(ref)	{ }

	/// Clear Env
	virtual void		clear()
	{
		Reference = NULL;
	}

	/// Get value
	virtual std::string	get(const std::string& name)
	{
		return Reference->get(name);
	}

	/// Does Variable exist?
	virtual bool		exists(const std::string& name) const
	{
		return Reference->exists(name);
	}

	/// Does Sub Environment exist?
	virtual bool		envExists(const std::string& name) const
	{
		return Reference->envExists(name);
	}

	/// Get Sub Env
	virtual CTemplatizerEnv*	getEnv(const std::string& name)
	{
		return Reference->getEnv(name);
	}

	/// Evaluate string (string replacement)
	virtual std::string			eval(const std::string& text)
	{
		return Reference->eval(text);
	}

	/// Enter Sub Env, like getEnv() but it doesn't look in parent, and always goes in current env
	virtual CTemplatizerEnv*	getSubEnv(const std::string& name)
	{
		return Reference->getSubEnv(name);
	}

	/// Get Parent Env
	virtual CTemplatizerEnv*	getParent()
	{
		return Reference->getParent();
	}
public:

	CTemplatizerEnv*	Reference;

	/// Get Root Env
	virtual CTemplatizerEnv*	getRootEnv()
	{
		return Reference->getRootEnv();
	}

	/// Set As Raw Text
	virtual void		setAsRawText(const std::string& name, const std::string& text)
	{
		Reference->setAsRawText(name, text);
	}

	/// Set Value Node
	virtual void		setValueNode(const std::string& name, ITemplatizerBloc* bloc)
	{
		Reference->setValueNode(name, bloc);
	}

	/// Get Value Node
	virtual ITemplatizerBloc*	getValueNode(const std::string& name)
	{
		return Reference->getValueNode(name);
	}

	/// Get Value Node
	virtual bool	getValueNodeAndEnv(const std::string& name, ITemplatizerBloc*& node, CTemplatizerEnv*& env)
	{
		return Reference->getValueNodeAndEnv(name, node, env);
	}

	virtual ITemplatizerBloc*	getNode(const std::string& name)
	{
		return Reference->getNode(name);
	}
};


/**
 * <Class description>
 * \author Benjamin Legros
 * \author Nevrax France
 * \date 2003
 */
class CTemplatizer
{
public:

	/// Constructor
	CTemplatizer();

	/// Destructor
	~CTemplatizer();



	/**
	 * Build templatizer from text
	 */
	bool		build(const char* text);


	/**
	 * Evaluate template and render to string
	 */
	std::string	eval();


	/**
	 * Set Value in env
	 */
	template<typename T>
	void		set(const std::string& var, const T& value)
	{
		if (RootEnv == NULL)
			return;

		std::string::size_type pos = var.find_last_of(EnvSeparator);

		if (pos == std::string::npos)
		{
			RootEnv->set(var, value);
		}
		else
		{
			RootEnv->getEnv(var.substr(0, pos))->set(var.substr(pos+1), value);
		}
	}

public:

	ITemplatizerBloc*		RootBloc;

	CTemplatizerEnv*		RootEnv;

};



class CTemplatizerParser
{
public:

	CTemplatizerParser() : _Buffer(NULL), _Line(0), _Valid(false)	{ }
	CTemplatizerParser(const CTemplatizerParser& ptr) : _Buffer(ptr._Buffer), _Line(ptr._Line), _Valid(ptr._Valid)	{ }
	CTemplatizerParser(const char*	buffer, uint linestart = 1) : _Buffer(buffer), _Line(linestart), _Valid(_Buffer != NULL)	{ }

	char	operator * () const			{ return *_Buffer; }
	char	operator [] (int i) const	{ return _Buffer[i]; }

	CTemplatizerParser&	operator = (const CTemplatizerParser& ptr)
	{
		_Buffer = ptr._Buffer;
		_Line = ptr._Line;
		_Valid = ptr._Valid;
		return *this;
	}

	CTemplatizerParser&	operator ++ ()
	{
		if (*_Buffer == '\0')
			return *this;

		if (*_Buffer == '\n')
			++_Line;

		++_Buffer;
		return *this;
	}

	CTemplatizerParser	operator ++ (int)
	{
		CTemplatizerParser	ret(*this);
		++(*this);
		return ret;
	}

	void	invalidate()	{ _Valid = false; }
	bool	isValid() const	{ return _Valid; }

	uint	getLine() const	{ return _Line; }

private:

	const char*	_Buffer;

	uint	_Line;

	bool	_Valid;

};




/**
 * A Templatizer node
 */
class ITemplatizerBloc
{
public:

	/// Constructor
	ITemplatizerBloc();

	/// Destructor
	virtual ~ITemplatizerBloc();



	/// Evaluate node
	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	res;
		uint	i;
		for (i=0; i<Blocs.size(); ++i)
			res += Blocs[i]->eval(env);
		return res;
	}

	/// Get Text (assuming this is a raw text bloc)
	virtual std::string	getText(CTemplatizerEnv* env)
	{
		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		return NULL;
	}

	/// Get Actual Bloc (not a reference)
	virtual ITemplatizerBloc*	getActualBloc()
	{
		return this;
	}

public:

	std::string	evalParam(const std::string& param, CTemplatizerEnv* env)
	{
		TParamMap::iterator	it = Params.find(param);
		if (it == Params.end())
			return "";
		return (*it).second->eval(env);
	}

public:

	/// Bloc types
	enum TType
	{
		Text,
	};

	/// Bloc type
	TType				Type;

	typedef std::vector<ITemplatizerBloc*>				TBlocList;
	typedef std::map<std::string, ITemplatizerBloc*>	TParamMap;

	/// Params
	TParamMap			Params;

	/// Sub blocs
	TBlocList			Blocs;


	/// Parse bloc
	static ITemplatizerBloc*	parseBloc(CTemplatizerParser& ptr);

	/// Parse bloc header
	virtual CTemplatizerParser	parseHeader(CTemplatizerParser ptr);

	/// Parse bloc internal data
	virtual CTemplatizerParser	parseInternal(CTemplatizerParser ptr);

	/// Has A Internal Bloc of data
	virtual bool		hasInternal() const	{ return true; }
};





/// Root Templatizer
class CTemplatizerRootBloc : public ITemplatizerBloc
{
public:

};

/// Reference Node
class CTemplatizerReferenceBloc : public ITemplatizerBloc
{
public:

	ITemplatizerBloc*	Reference;

	/// Constructor
	CTemplatizerReferenceBloc(ITemplatizerBloc* ref = NULL) : Reference(ref)	{}

	/// Destructor
	virtual ~CTemplatizerReferenceBloc()
	{
		Reference = NULL;
	}

	/// Evaluate node
	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			name = evalParam("name", env);
		std::string			ref = evalParam("ref", env);
		ITemplatizerBloc*	refnode = env->getValueNode(ref);
		if (refnode != NULL)
			env->setValueNode(name, new CTemplatizerReferenceBloc(refnode));
		else
			nlwarning("Failed to create reference on '%s', not found", name.c_str());
		return "";
	}

	/// Get Text (assuming this is a raw text bloc)
	virtual std::string	getText(CTemplatizerEnv* env)
	{
		return Reference->getText(env);
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name", "ref" };
		return (const char**)args;
	}

	/// Get Actual Bloc (not a reference)
	virtual ITemplatizerBloc*	getActualBloc()
	{
		return Reference->getActualBloc();
	}

	/// Has A Internal Bloc of data
	virtual bool		hasInternal() const	{ return false; }
};


/// RefEnv Bloc
class CTemplatizerRefEnvBloc : public ITemplatizerBloc
{
public:

	/// Evaluate node
	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			name = evalParam("name", env);
		std::string			ref = evalParam("ref", env);

		CTemplatizerEnv*	refenv = env->getEnv(ref);
		if (refenv != NULL)
			env->setSubEnv(name, new CTemplatizerRefEnv(refenv));
		else
			nlwarning("Failed to create reference on env '%s', not found", name.c_str());
		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name", "ref" };
		return (const char**)args;
	}

	/// Has A Internal Bloc of data
	virtual bool		hasInternal() const	{ return false; }
};





/**
 * Comment Bloc
 */
class CTemplatizerCommentBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		return "";
	}

	/// Parse bloc internal data
	virtual CTemplatizerParser	parseInternal(CTemplatizerParser ptr);

};


/**
 * Raw Text Bloc
 */
class CTemplatizerRawTextBloc : public ITemplatizerBloc
{
public:

	std::string		Text;

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		return Text;
	}

	virtual std::string	getText(CTemplatizerEnv* env)
	{
		return Text;
	}
};

// Set As Raw Text
inline void	CTemplatizerEnv::setAsRawText(const std::string& name, const std::string& text)
{
	CTemplatizerRawTextBloc*	bloc = new CTemplatizerRawTextBloc();
	bloc->Text = text;
	setValueNode(name, bloc);
}

// Get value
inline std::string	CTemplatizerEnv::get(const std::string& name)
{
	ITemplatizerBloc*	bloc = getValueNode(name);

	return (bloc == NULL) ? std::string("") : bloc->getText(this);
}

// eval num expr override
inline NLMISC::CEvalNumExpr::TReturnState	CTemplatizerEnv::evalValue (const char *value, double &result, uint32 userData)
{
	if (*value != '$')
	{
		return NLMISC::CEvalNumExpr::ValueError;
	}

	std::string	strvalue = get(value+1);

	if (sscanf(strvalue.c_str(), "%lf", &result) != 1)
	{
		result = (strvalue.empty() ? 0.0 : 1.0);
	}

	return NLMISC::CEvalNumExpr::NoError;
}



/**
 * Text Bloc
 */
class CTemplatizerTextBloc : public ITemplatizerBloc
{
public:

	std::string		Text;

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		return env->eval(Text);
	}

	virtual std::string	getText(CTemplatizerEnv* env)
	{
		return env->eval(Text);
	}

	/// Parse bloc internal data
	virtual CTemplatizerParser	parseInternal(CTemplatizerParser ptr);
};




/**
 * Sub bloc
 */
class CTemplatizerSubBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			subname = evalParam("name", env);
		CTemplatizerEnv*	subenv = env->getSubEnv(subname);

		return ITemplatizerBloc::eval(subenv);
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};


/**
 * Loop bloc
 */
class CTemplatizerLoopBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			subname = evalParam("name", env);
		CTemplatizerEnv*	subenv = env->getSubEnv(subname);

		std::string			res;

		CTemplatizerEnv::TEnvMap::iterator	it;
		for (it=subenv->Envs.begin(); it!=subenv->Envs.end(); ++it)
			res += ITemplatizerBloc::eval((*it).second);

		return res;
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};


/**
 * IfDefEnv bloc
 */
class CTemplatizerIfDefEnvBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			subname = evalParam("name", env);
		std::string			evalinsub = evalParam("evalinsub", env);

		if (env->envExists(subname))
		{
			sint eval;
			NLMISC::fromString(evalinsub, eval);
			CTemplatizerEnv*	subenv = (eval ? env->getEnv(subname) : env);
			return ITemplatizerBloc::eval(subenv);
		}

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name", "evalinsub" };
		return (const char**)args;
	}
};


/**
 * IfDef bloc
 */
class CTemplatizerIfDefBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			varname = evalParam("name", env);

		if (env->exists(varname))
		{
			return ITemplatizerBloc::eval(env);
		}

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};


/**
 * IfDefEnv bloc
 */
class CTemplatizerIfNotDefEnvBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			subname = evalParam("name", env);

		if (!env->envExists(subname))
		{
			return ITemplatizerBloc::eval(env);
		}

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};


/**
 * IfDef bloc
 */
class CTemplatizerIfNotDefBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			varname = evalParam("name", env);

		if (!env->exists(varname))
		{
			return ITemplatizerBloc::eval(env);
		}

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};


/**
 * Switch bloc
 */
class CTemplatizerSwitchBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string			switchvalue = evalParam("value", env);

		uint	i;
		for (i=0; i<Blocs.size(); ++i)
			if (Blocs[i]->evalParam("case", env) == switchvalue)
				return Blocs[i]->eval(env);

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "value" };
		return (const char**)args;
	}
};

/**
 * File bloc
 */
class CTemplatizerFileBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	clearfile = evalParam("clear", env);
		std::string	filename = evalParam("name", env);

		std::string	result = ITemplatizerBloc::eval(env);

		FILE*	f;
		f = NLMISC::nlfopen(filename, (clearfile == "true" ? "w" : "a"));
		if (f != NULL)
		{
			fwrite(result.c_str(), 1, result.size(), f);
			fclose(f);
		}

		return result;
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};

/**
 * Set bloc
 */
class CTemplatizerSetBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	var = evalParam("name", env);
		std::string	result = ITemplatizerBloc::eval(env);

		env->set(var, result);

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};

/**
 * Append bloc
 */
class CTemplatizerAppendBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	var = evalParam("name", env);
		std::string	result = ITemplatizerBloc::eval(env);

		ITemplatizerBloc*	bloc = env->getValueNode(var);
		if (bloc == NULL)
			return "";

		CTemplatizerRawTextBloc*	text = dynamic_cast<CTemplatizerRawTextBloc*>(bloc->getActualBloc());
		if (text == NULL)
			return "";

		text->Text += result;

		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};

/**
 * Define Bloc
 */
class CTemplatizerDefineBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	name = evalParam("name", env);
		env->setValueNode(name, new CTemplatizerReferenceBloc(this));
		return "";
	}

	virtual std::string	getText(CTemplatizerEnv* env)
	{
		return ITemplatizerBloc::eval(env);
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};

/**
 * If Bloc
 */
class CTemplatizerIfBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	value = evalParam("cond", env);
		double		result;
		NLMISC::CEvalNumExpr::TReturnState	res = env->evalExpression(value.c_str(), result, NULL);

		if (res == NLMISC::CEvalNumExpr::NoError && result != 0.0)
		{
			return ITemplatizerBloc::eval(env);
		}
		else
		{
			return "";
		}
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "cond" };
		return (const char**)args;
	}
};

/**
 * If Not Bloc
 */
class CTemplatizerIfNotBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	value = evalParam("cond", env);

		if (value.empty())
		{
			return ITemplatizerBloc::eval(env);
		}
		else
		{
			return "";
		}
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "cond" };
		return (const char**)args;
	}
};

/**
 * Join bloc
 */
class CTemplatizerJoinBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	sep = evalParam("separator", env);

		std::string	res;
		uint	i;
		for (i=0; i<Blocs.size(); ++i)
		{
			std::string	token = Blocs[i]->eval(env);

			if (token.empty())
				continue;

			if (!res.empty())
				res += sep;

			res += token;
		}
		return res;
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "separator" };
		return (const char**)args;
	}
};

/**
 * User Defined function call
 */
class CTemplatizerUserFunctionBloc : public ITemplatizerBloc
{
public:

	CTemplatizerUserFunctionBloc(const std::string& name) : Name(name)	{}

	std::string		Name;

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		ITemplatizerBloc*	func = NULL;
		CTemplatizerEnv*	fenv = NULL;
		if (!env->getValueNodeAndEnv(Name, func, fenv))
		{
			nlwarning("Unknown user function '%s'", Name.c_str());
			return "";
		}

		// subenv is child of object env, not of current env
		CTemplatizerEnv*	subenv = new CTemplatizerEnv(fenv);

		// deport params in subenv
		// \todo : eval param in current env
		TParamMap::iterator	it;
		for (it=Params.begin(); it!=Params.end(); ++it)
			subenv->setAsRawText((*it).first, (*it).second->getText(env));
			//subenv->setValueNode((*it).first, new CTemplatizerReferenceBloc((*it).second));

		std::string	res = func->getText(subenv);

		delete subenv;

		return res;
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		return NULL;
	}

	/// Has A Internal Bloc of data
	virtual bool		hasInternal() const
	{
		return false;
	}
};

/**
 * Class
 */
class CTemplatizerClassBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	name = evalParam("name", env);
		env->setValueNode(name, new CTemplatizerReferenceBloc(this));
		return "";
	}

	virtual std::string	instantiate(CTemplatizerEnv* env)
	{
		return ITemplatizerBloc::eval(env);
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};

/**
 * Class
 */
class CTemplatizerObjectBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	classname = evalParam("class", env);
		std::string	name = evalParam("name", env);

		ITemplatizerBloc*	bloc = env->getValueNode(classname);
		if (bloc == NULL)
		{
			nlwarning("Unknown class '%s'", classname.c_str());
			return "";
		}

		CTemplatizerClassBloc*	classbloc = dynamic_cast<CTemplatizerClassBloc*>(bloc->getActualBloc());
		if (classbloc == NULL)
		{
			nlwarning("object '%s' is not a class", classname.c_str());
			return "";
		}

		CTemplatizerEnv* objectenv = env->getSubEnv(name);
		objectenv->clear();

		return classbloc->instantiate(objectenv);
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "class", "name" };
		return (const char**)args;
	}

	/// Has A Internal Bloc of data
	virtual bool		hasInternal() const	{ return false;	}
};


/**
 * Breakpoint
 */
class CTemplatizerBreakpointBloc : public ITemplatizerBloc
{
public:

	virtual std::string	eval(CTemplatizerEnv* env)
	{
		std::string	value = evalParam("name", env);
		return "";
	}

	/// Get Param list
	virtual const char**	getDefParamList()
	{
		static const char*	args[] = { "name" };
		return (const char**)args;
	}
};


#endif // NL_TEMPLATIZER_H

/* End of templatizer.h */