// TnzCore includes

#include "trandom.h"

#include "tutil.h"

#include "tconvert.h"

// TnzBase includes

#include "ttokenizer.h"

#include "tunit.h"

#include "tparser.h"

#include "tdoubleparam.h"

#include "tdoublekeyframe.h"

// STD includes

#include <map></map>

#include <math.h></math.h>

#include <functional></functional>

// Qt includes

#include <qstring></qstring>

#include "tgrammar.h"

const double PI = 4 * atan(1.0);

const double toDeg(double rad) { return rad * 180.0 / PI; }

const double toRad(double deg) { return deg / 180.0 * PI; }

namespace TSyntax

{

//===================================================================

//

// RandomManager

//

//   es. x = RandomManager::instance()->getValue(seed, frame);

//

//-------------------------------------------------------------------

class RandomSequence

{

	TRandom m_rnd;

	std::vector<double> m_values;</double>

public:

	RandomSequence(UINT seed) : m_rnd(seed) {}

	double getValue(int i)

	{

		assert(i >= 0);

		if (i >= (int)m_values.size()) {

			m_values.reserve(i + 1);

			while (i >= (int)m_values.size())

				m_values.push_back(m_rnd.getDouble());

		}

		return m_values[i];

	}

};

//-------------------------------------------------------------------

class RandomManager

{ // singleton

	typedef std::map<uint, *="" randomsequence=""> Table;</uint,>

	Table m_table;

	RandomManager() {}

public:

	~RandomManager()

	{

		for (Table::iterator i = m_table.begin(); i != m_table.end(); ++i)

			delete i->second;

	}

	static RandomManager *instance()

	{

		static RandomManager _instance;

		return &_instance;

	}

	RandomSequence *getSequence(UINT seed)

	{

		Table::iterator i = m_table.find(seed);

		if (i == m_table.end()) {

			RandomSequence *seq = new RandomSequence(seed);

			m_table[seed] = seq;

			return seq;

		} else

			return i->second;

	}

	double getValue(UINT seed, double t)

	{

		RandomSequence *seq = getSequence(seed);

		return seq->getValue(t > 0 ? tfloor(t) : 0);

	}

};

//===================================================================

// Calculator

//-------------------------------------------------------------------

Calculator::Calculator()

	: m_rootNode(0), m_param(0), m_unit(0)

{

}

//-------------------------------------------------------------------

Calculator::~Calculator()

{

	delete m_rootNode;

}

//-------------------------------------------------------------------

void Calculator::setRootNode(CalculatorNode *node)

{

	if (node != m_rootNode) {

		delete m_rootNode;

		m_rootNode = node;

	}

}

//===================================================================

// Nodes

//-------------------------------------------------------------------

template <class op=""></class>

class Op0Node : public CalculatorNode

{

public:

	Op0Node(Calculator *calc)

		: CalculatorNode(calc) {}

	double compute(double vars[3]) const

	{

		Op op;

		return op();

	}

};

//-------------------------------------------------------------------

template <class op=""></class>

class Op1Node : public CalculatorNode

{

protected:

	std::auto_ptr<calculatornode> m_a;</calculatornode>

public:

	Op1Node(Calculator *calc, CalculatorNode *a)

		: CalculatorNode(calc), m_a(a) {}

	double compute(double vars[3]) const

	{

		Op op;

		return op(m_a->compute(vars));

	}

	void accept(CalculatorNodeVisitor &visitor) { m_a->accept(visitor); }

};

//-------------------------------------------------------------------

template <class op=""></class>

class Op2Node : public CalculatorNode

{

protected:

	std::auto_ptr<calculatornode> m_a, m_b;</calculatornode>

public:

	Op2Node(Calculator *calc, CalculatorNode *a, CalculatorNode *b)

		: CalculatorNode(calc), m_a(a), m_b(b) {}

	double compute(double vars[3]) const

	{

		Op op;

		return op(m_a->compute(vars), m_b->compute(vars));

	}

	void accept(CalculatorNodeVisitor &visitor)

	{

		m_a->accept(visitor), m_b->accept(visitor);

	}

};

//-------------------------------------------------------------------

template <class op=""></class>

class Op3Node : public CalculatorNode

{

protected:

	std::auto_ptr<calculatornode> m_a, m_b, m_c;</calculatornode>

public:

	Op3Node(Calculator *calc, CalculatorNode *a, CalculatorNode *b, CalculatorNode *c)

		: CalculatorNode(calc), m_a(a), m_b(b), m_c(c) {}

	double compute(double vars[3]) const

	{

		Op op;

		return op(m_a->compute(vars), m_b->compute(vars), m_c->compute(vars));

	}

	void accept(CalculatorNodeVisitor &visitor)

	{

		m_a->accept(visitor), m_b->accept(visitor), m_c->accept(visitor);

	}

};

//-------------------------------------------------------------------

class ChsNode : public CalculatorNode

{

	std::auto_ptr<calculatornode> m_a;</calculatornode>

public:

	ChsNode(Calculator *calc, CalculatorNode *a) : CalculatorNode(calc), m_a(a) {}

	double compute(double vars[3]) const { return -m_a->compute(vars); }

	void accept(CalculatorNodeVisitor &visitor) { m_a->accept(visitor); }

};

//-------------------------------------------------------------------

class QuestionNode : public CalculatorNode

{

	std::auto_ptr<calculatornode> m_a, m_b, m_c;</calculatornode>

public:

	QuestionNode(Calculator *calc, CalculatorNode *a, CalculatorNode *b, CalculatorNode *c)

		: CalculatorNode(calc), m_a(a), m_b(b), m_c(c) {}

	double compute(double vars[3]) const

	{

		return (m_a->compute(vars) != 0) ? m_b->compute(vars) : m_c->compute(vars);

	}

	void accept(CalculatorNodeVisitor &visitor)

	{

		m_a->accept(visitor), m_b->accept(visitor), m_c->accept(visitor);

	}

};

//-------------------------------------------------------------------

class NotNode : public CalculatorNode

{

	std::auto_ptr<calculatornode> m_a;</calculatornode>

public:

	NotNode(Calculator *calc, CalculatorNode *a) : CalculatorNode(calc), m_a(a) {}

	double compute(double vars[3]) const { return m_a->compute(vars) == 0; }

	void accept(CalculatorNodeVisitor &visitor) { m_a->accept(visitor); }

};

//-------------------------------------------------------------------

class CycleNode : public CalculatorNode

{

	std::auto_ptr<calculatornode> m_a;</calculatornode>

public:

	CycleNode(Calculator *calc, CalculatorNode *a) : CalculatorNode(calc), m_a(a) {}

	double compute(double vars[3]) const

	{

		struct locals {

			static inline double compute(const TDoubleParam ¶m, double f)

			{

				if (param.getKeyframeCount() >= 2 && f < param.keyframeIndexToFrame(0)) {

					TDoubleKeyframe kf = param.getKeyframe(0);

					if (kf.m_type == TDoubleKeyframe::Expression || kf.m_type == TDoubleKeyframe::SimilarShape)

						return param.getDefaultValue();

				}

				double value = param.getValue(f);

				return value;

			}

		};

		double delta = tmax(1.0, m_a->compute(vars));

		const TDoubleParam *ownerParam = getCalculator()->getOwnerParameter();

		if (!ownerParam)

			return 0;

		double value = locals::compute(*ownerParam, vars[FRAME] - 1 - delta);

		if (getCalculator()->getUnit())

			value = getCalculator()->getUnit()->convertTo(value);

		return value;

	}

	void accept(CalculatorNodeVisitor &visitor) { m_a->accept(visitor); }

};

//-------------------------------------------------------------------

class RandomNode : public CalculatorNode

{

	std::auto_ptr<calculatornode> m_seed, m_min, m_max, m_arg;</calculatornode>

public:

	RandomNode(Calculator *calc) : CalculatorNode(calc), m_seed(0), m_min(0), m_max(0)

	{

		m_arg.reset(new VariableNode(calc, CalculatorNode::FRAME));

	}

	void setSeed(CalculatorNode *arg)

	{

		assert(m_seed.get() == 0);

		m_seed.reset(arg);

	}

	void setMax(CalculatorNode *arg)

	{

		assert(m_max.get() == 0);

		m_max.reset(arg);

	}

	void setMin(CalculatorNode *arg)

	{

		assert(m_min.get() == 0);

		m_min.reset(arg);

	}

	double compute(double vars[3]) const

	{

		double s = (m_seed.get() != 0) ? m_seed->compute(vars) : 0;

		double r = RandomManager::instance()->getValue(s, fabs(m_arg->compute(vars)));

		if (m_min.get() == 0)

			if (m_max.get() == 0)

				return r;

			else

				return m_max->compute(vars) * r;

		else

			return (1 - r) * m_min->compute(vars) + r * m_max->compute(vars);

	}

	void accept(CalculatorNodeVisitor &visitor)

	{

		m_arg->accept(visitor);

		if (m_seed.get())

			m_seed->accept(visitor);

		if (m_min.get())

			m_min->accept(visitor);

		if (m_max.get())

			m_max->accept(visitor);

	}

};

//===================================================================

// Patterns

//-------------------------------------------------------------------

CalculatorNode *Pattern::popNode(std::vector<calculatornode *=""> &stack) const</calculatornode>

{

	CalculatorNode *node = stack.back();

	stack.pop_back();

	return node;

}

//===================================================================

class NumberPattern : public Pattern

{

public:

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.empty() && token.getType() == Token::Number;

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 1;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return Number;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 1);

		assert(tokens[0].getType() == Token::Number);

		stack.push_back(new NumberNode(calc, tokens[0].getDoubleValue()));

	}

};

//-------------------------------------------------------------------

class ConstantPattern : public Pattern

{

	string m_constantName;

	double m_value;

public:

	ConstantPattern(string constantName, double value, string description = "")

		: m_constantName(constantName), m_value(value)

	{

		setDescription(description);

	}

	string getFirstKeyword() const { return m_constantName; }

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.empty() && token.getText() == m_constantName;

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 1;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return Constant;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 1);

		stack.push_back(new NumberNode(calc, m_value));

	}

};

//-------------------------------------------------------------------

class VariablePattern : public Pattern

{

	string m_variableName;

	int m_varIdx;

public:

	VariablePattern(string variableName, int varIdx, string description = "")

		: m_variableName(variableName), m_varIdx(varIdx)

	{

		setDescription(description);

	}

	string getFirstKeyword() const { return m_variableName; }

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.empty() && token.getText() == m_variableName;

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 1;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return Variable;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 1);

		assert(tokens[0].getText() == m_variableName);

		stack.push_back(new VariableNode(calc, m_varIdx));

	}

};

//-------------------------------------------------------------------

template <class op=""></class>

class Op2Pattern : public Pattern

{

	string m_opName;

	int m_priority;

public:

	Op2Pattern(string opName, int priority)

		: m_opName(opName), m_priority(priority) {}

	int getPriority() const { return m_priority; }

	string getFirstKeyword() const { return m_opName; }

	bool expressionExpected(const std::vector<token> &previousTokens) const</token>

	{

		return previousTokens.empty() || previousTokens.size() == 2;

	}

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 1 && token.getText() == m_opName;

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 3;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 1 ? Operator : InternalError;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 3);

		assert(tokens[1].getText() == m_opName);

		CalculatorNode *b = popNode(stack);

		CalculatorNode *a = popNode(stack);

		stack.push_back(new Op2Node<op>(calc, a, b));</op>

	}

};

//-------------------------------------------------------------------

class UnaryMinusPattern : public Pattern

{

public:

	UnaryMinusPattern() {}

	int getPriority() const { return 50; }

	string getFirstKeyword() const { return "-"; }

	bool expressionExpected(const std::vector<token> &previousTokens) const</token>

	{

		return previousTokens.size() == 1;

	}

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.empty() && token.getText() == "-";

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 2;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return Operator;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 2);

		assert(tokens[0].getText() == "-");

		stack.push_back(new ChsNode(calc, popNode(stack)));

	}

};

//-------------------------------------------------------------------

class NotPattern : public Pattern

{

	string m_prefix;

public:

	NotPattern(string prefix, string description) : m_prefix(prefix)

	{

		setDescription(description);

	}

	int getPriority() const { return 5; }

	string getFirstKeyword() const { return m_prefix; }

	bool expressionExpected(const std::vector<token> &previousTokens) const</token>

	{

		return previousTokens.size() == 1;

	}

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.empty() && token.getText() == m_prefix;

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 2;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return Operator;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 2);

		assert(tokens[0].getText() == m_prefix);

		stack.push_back(new NotNode(calc, popNode(stack)));

	}

};

//-------------------------------------------------------------------

class QuestionTernaryPattern : public Pattern

{

public:

	QuestionTernaryPattern() {}

	int getPriority() const { return 5; }

	string getFirstKeyword() const { return "?"; }

	bool expressionExpected(const std::vector<token> &previousTokens) const</token>

	{

		int i = (int)previousTokens.size();

		return i == 0 || i == 2 || i == 4;

	}

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		int i = (int)previousTokens.size();

		return i == 1 && token.getText() == "?" || i == 3 && token.getText() == ":";

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 5;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		int i = (int)previousTokens.size();

		return (i == 1 || i == 3) ? Operator : InternalError;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		CalculatorNode *node1 = popNode(stack);

		CalculatorNode *node2 = popNode(stack);

		CalculatorNode *node3 = popNode(stack);

		stack.push_back(new QuestionNode(calc, node3, node2, node1));

	}

};

//-------------------------------------------------------------------

class BraketPattern : public Pattern

{

public:

	BraketPattern() {}

	int getPriority() const { return 5; }

	string getFirstKeyword() const { return "("; }

	bool expressionExpected(const std::vector<token> &previousTokens) const</token>

	{

		return previousTokens.size() == 1;

	}

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.empty() && token.getText() == "(" ||

			   previousTokens.size() == 2 && token.getText() == ")";

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() == 3;

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		return previousTokens.size() != 1 ? Parenthesis : InternalError;

	}

	void createNode(

		Calculator *calc,

		std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		assert(tokens.size() == 3);

		assert(tokens[0].getText() == "(");

		assert(tokens[2].getText() == ")");

	}

};

//-------------------------------------------------------------------

class FunctionPattern : public Pattern

{

protected:

	string m_functionName;

	bool m_implicitArgAllowed;

	// if m_implicitArgAllowed == true then the first argument is the frame number

	// e.g. f(5) means f(frame,5)

	// to use a different first argument (e.g. t*10) you have to write f(t*10;5)

	int m_minArgCount;

	std::vector<double> m_optionalArgDefaults;</double>

public:

	FunctionPattern(string functionName, int minArgCount)

		: m_functionName(functionName), m_implicitArgAllowed(false), m_minArgCount(minArgCount)

	{

	}

	void allowImplicitArg(bool allowed) { m_implicitArgAllowed = allowed; }

	void addOptionalArg(double value) { m_optionalArgDefaults.push_back(value); }

	string getFirstKeyword() const { return m_functionName; }

	bool expressionExpected(const std::vector<token> &previousTokens) const</token>

	{

		int n = (int)previousTokens.size();

		return 2 <= n && (n & 1) == 0;

	}

	bool matchToken(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		int i = (int)previousTokens.size();

		string s = toLower(token.getText());

		if (i == 0)

			return s == toLower(m_functionName);

		else if (i == 1)

			return s == "(";

		else if ((i & 1) == 0)

			return true;

		else if (s == ",")

			return true;

		else if (s == ";")

			return i == 3 && m_implicitArgAllowed;

		else if (s == ")") {

			int n = (i - 1) / 2;

			if (previousTokens.size() > 3 && previousTokens[3].getText() == ";")

				n--;

			if (n < m_minArgCount || n > m_minArgCount + (int)m_optionalArgDefaults.size())

				return false;

			else

				return true;

		} else

			return false;

	}

	bool isFinished(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		if (previousTokens.empty())

			return false;

		return m_minArgCount == 0 && previousTokens.size() == 1 && token.getText() != "(" ||

			   previousTokens.back().getText() == ")";

	}

	TokenType getTokenType(const std::vector<token> &previousTokens, const Token &token) const</token>

	{

		int i = (int)previousTokens.size();

		if (i == 0)

			return Function;

		else if (i == 1 || token.getText() == ")")

			return Function;

		else if (i == 3)

			return token.getText() == ";" ? Comma : Comma;

		else if (i & 1)

			return Comma;

		else

			return InternalError;

	}

	void getArgs(

		std::vector<calculatornode *=""> &nodes,</calculatornode>

		Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

		const std::vector<token> &tokens) const</token>

	{

		bool implicitArgUsed = m_implicitArgAllowed && tokens.size() > 3 && tokens[3].getText() == ";";

		// n = number of arguments to provide (mandatory + optional + implicit)

		int n = m_minArgCount + (int)m_optionalArgDefaults.size() + (m_implicitArgAllowed ? 1 : 0);

		// m = number of default arguments to assign (with their default value)

		int m = n - (tokens.size() - 2) / 2;

		if (m_implicitArgAllowed && !implicitArgUsed)

			m--;

		assert(m <= (int)m_optionalArgDefaults.size());

		if (m > (int)m_optionalArgDefaults.size())

			m = (int)m_optionalArgDefaults.size();

		nodes.resize(n);

		// fetch arguments from the stack

		int k = n - m;

		if (implicitArgUsed) {

			while (k > 0)

				nodes[--k] = popNode(stack);

		} else {

			while (k > 1)

				nodes[--k] = popNode(stack);

			nodes[0] = new VariableNode(calc, CalculatorNode::FRAME);

		}

		// add default values

		for (int i = 0; i < m; i++)

			nodes[n - m + i] = new NumberNode(calc, m_optionalArgDefaults[i]);

	}

};

//-------------------------------------------------------------------

template <class function=""></class>

class F0Pattern : public FunctionPattern

{

public:

	F0Pattern(string functionName) : FunctionPattern(functionName, 0) {}

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

					const std::vector<token> &tokens) const</token>

	{

		stack.push_back(new Op0Node<function>(calc, m_functionName));</function>

	}

};

//-------------------------------------------------------------------

template <class function=""></class>

class F1Pattern : public FunctionPattern

{

public:

	F1Pattern(string functionName, string descr = "") : FunctionPattern(functionName, 1) { setDescription(descr); }

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

					const std::vector<token> &tokens) const</token>

	{

		stack.push_back(new Op1Node<function>(calc, popNode(stack)));</function>

	}

};

//-------------------------------------------------------------------

template <class function=""></class>

class F2Pattern : public FunctionPattern

{

public:

	F2Pattern(string functionName, string descr = "") : FunctionPattern(functionName, 2) { setDescription(descr); }

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

					const std::vector<token> &tokens) const</token>

	{

		CalculatorNode *b = popNode(stack);

		CalculatorNode *a = popNode(stack);

		stack.push_back(new Op2Node<function>(calc, a, b));</function>

	}

};

//-------------------------------------------------------------------

template <class function=""></class>

class F3Pattern : public FunctionPattern

{

public:

	F3Pattern(string functionName, string descr = "") : FunctionPattern(functionName, 3) { setDescription(descr); }

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

					const std::vector<token> &tokens) const</token>

	{

		CalculatorNode *c = popNode(stack);

		CalculatorNode *b = popNode(stack);

		CalculatorNode *a = popNode(stack);

		stack.push_back(new Op3Node<function>(calc, a, b, c));</function>

	}

};

//-------------------------------------------------------------------

template <class function=""></class>

class Fs2Pattern : public FunctionPattern

{

public:

	Fs2Pattern(string functionName, string description)

		: FunctionPattern(functionName, 1)

	{

		allowImplicitArg(true);

		setDescription(description);

	}

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

					const std::vector<token> &tokens) const</token>

	{

		std::vector<calculatornode *=""> nodes;</calculatornode>

		getArgs(nodes, calc, stack, tokens);

		stack.push_back(new Op2Node<function>(calc, nodes[0], nodes[1]));</function>

	}

};

//-------------------------------------------------------------------

template <class function=""></class>

class Fs3Pattern : public FunctionPattern

{

public:

	Fs3Pattern(string functionName, double defVal, string descr)

		: FunctionPattern(functionName, 1)

	{

		allowImplicitArg(true);

		addOptionalArg(defVal);

		setDescription(descr);

	}

	void createNode(Calculator *calc, std::vector<calculatornode *=""> &stack,</calculatornode>

					const std::vector<token> &tokens) const</token>

	{

		std::vector<calculatornode *=""> nodes;</calculatornode>

		getArgs(nodes, calc, stack, tokens);