khanat-opennel-code/code/ryzom/tools/pd_parser/templatizer.h
acemtp@users.sourceforge.net d5c601ffa5 initial version
2010-05-06 02:08:41 +02:00

1355 lines
26 KiB
C++

// 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)
{
uint 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
{
uint 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)
{
uint 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)
{
uint 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)
{
uint 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) : Reference(ref), CTemplatizerEnv(NULL) { }
/// 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;
uint 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 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 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 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 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))
{
CTemplatizerEnv* subenv = (atoi(evalinsub.c_str()) ? env->getEnv(subname) : env);
return ITemplatizerBloc::eval(subenv);
}
return "";
}
/// Get Param list
virtual const char** getDefParamList()
{
static 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 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 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 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 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 = fopen(filename.c_str(), (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 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 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 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 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 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 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 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 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 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 char* args[] = { "name" };
return (const char**)args;
}
};
#endif // NL_TEMPLATIZER_H
/* End of templatizer.h */