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

#include <memory></memory>

// Qt includes

#include <qstring></qstring>

#include "tgrammar.h"

static const double PI = 4 * atan(1.0);

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

static 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 final : public CalculatorNode {

public:

  Op0Node(Calculator *calc) : CalculatorNode(calc) {}

  double compute(double vars[3]) const override {

    Op op;

    return op();

  }

};

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

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

class Op1Node final : public CalculatorNode {

protected:

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

public:

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

  double compute(double vars[3]) const override {

    Op op;

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

  }

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

};

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

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

class Op2Node final : public CalculatorNode {

protected:

  std::unique_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 override {

    Op op;

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

  }

  void accept(CalculatorNodeVisitor &visitor) override {

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

  }

};

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

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

class Op3Node final : public CalculatorNode {

protected:

  std::unique_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 override {

    Op op;

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

  }

  void accept(CalculatorNodeVisitor &visitor) override {

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

  }

};

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

class ChsNode final : public CalculatorNode {

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

public:

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

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

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

};

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

class QuestionNode final : public CalculatorNode {

  std::unique_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 override {

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

  }

  void accept(CalculatorNodeVisitor &visitor) override {

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

  }

};

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

class NotNode final : public CalculatorNode {

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

public:

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

  double compute(double vars[3]) const override {

    return m_a->compute(vars) == 0;

  }

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

};

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

class CycleNode final : public CalculatorNode {

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

public:

  CycleNode(Calculator *calc, CalculatorNode *a)

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

  double compute(double vars[3]) const override {

    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 = std::max(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) override { m_a->accept(visitor); }

};

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

class RandomNode final : public CalculatorNode {

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

public:

  RandomNode(Calculator *calc)

      : CalculatorNode(calc)

      , m_seed()

      , m_min()

      , m_max()

      , m_arg(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 override {

    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) override {

    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 final : public Pattern {

public:

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

                  const Token &token) const override {

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 1;

  }

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

                         const Token &token) const override {

    return Number;

  }

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

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

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

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

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

  }

};

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

class ConstantPattern final : public Pattern {

  std::string m_constantName;

  double m_value;

public:

  ConstantPattern(std::string constantName, double value,

                  std::string description = "")

      : m_constantName(constantName), m_value(value) {

    setDescription(description);

  }

  std::string getFirstKeyword() const override { return m_constantName; }

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

                  const Token &token) const override {

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 1;

  }

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

                         const Token &token) const override {

    return Constant;

  }

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

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

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

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

  }

};

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

class VariablePattern final : public Pattern {

  std::string m_variableName;

  int m_varIdx;

public:

  VariablePattern(std::string variableName, int varIdx,

                  std::string description = "")

      : m_variableName(variableName), m_varIdx(varIdx) {

    setDescription(description);

  }

  std::string getFirstKeyword() const override { return m_variableName; }

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

                  const Token &token) const override {

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 1;

  }

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

                         const Token &token) const override {

    return Variable;

  }

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

                  const std::vector<token> &tokens) const override {</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 final : public Pattern {

  std::string m_opName;

  int m_priority;

public:

  Op2Pattern(std::string opName, int priority)

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

  int getPriority() const override { return m_priority; }

  std::string getFirstKeyword() const override { return m_opName; }

  bool expressionExpected(

      const std::vector<token> &previousTokens) const override {</token>

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

  }

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

                  const Token &token) const override {

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 3;

  }

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

                         const Token &token) const override {

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

  }

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

                  const std::vector<token> &tokens) const override {</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 final : public Pattern {

public:

  UnaryMinusPattern() {}

  int getPriority() const override { return 50; }

  std::string getFirstKeyword() const override { return "-"; }

  bool expressionExpected(

      const std::vector<token> &previousTokens) const override {</token>

    return previousTokens.size() == 1;

  }

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

                  const Token &token) const override {

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 2;

  }

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

                         const Token &token) const override {

    return Operator;

  }

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

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

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

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

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

  }

};

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

class NotPattern final : public Pattern {

  std::string m_prefix;

public:

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

    setDescription(description);

  }

  int getPriority() const override { return 5; }

  std::string getFirstKeyword() const override { return m_prefix; }

  bool expressionExpected(

      const std::vector<token> &previousTokens) const override {</token>

    return previousTokens.size() == 1;

  }

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

                  const Token &token) const override {

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 2;

  }

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

                         const Token &token) const override {

    return Operator;

  }

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

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

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

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

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

  }

};

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

class QuestionTernaryPattern final : public Pattern {

public:

  QuestionTernaryPattern() {}

  int getPriority() const override { return 5; }

  std::string getFirstKeyword() const override { return "?"; }

  bool expressionExpected(

      const std::vector<token> &previousTokens) const override {</token>

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

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

  }

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

                  const Token &token) const override {

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

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 5;

  }

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

                         const Token &token) const override {

    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 override {</token>

    CalculatorNode *node1 = popNode(stack);

    CalculatorNode *node2 = popNode(stack);

    CalculatorNode *node3 = popNode(stack);

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

  }

};

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

class BraketPattern final : public Pattern {

public:

  BraketPattern() {}

  int getPriority() const override { return 5; }

  std::string getFirstKeyword() const override { return "("; }

  bool expressionExpected(

      const std::vector<token> &previousTokens) const override {</token>

    return previousTokens.size() == 1;

  }

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

                  const Token &token) const override {

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

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

  }

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

                  const Token &token) const override {

    return previousTokens.size() == 3;

  }

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

                         const Token &token) const override {

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

  }

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

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

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

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

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

  }

};

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

class FunctionPattern : public Pattern {

protected:

  std::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(std::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); }

  std::string getFirstKeyword() const override { return m_functionName; }

  bool expressionExpected(

      const std::vector<token> &previousTokens) const override {</token>

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

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

  }

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

                  const Token &token) const override {

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

    std::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,</token>

                  const Token &token) const override {

    if (previousTokens.empty()) return false;

    return m_minArgCount == 0 && previousTokens.size() == 1 &&

               token.getText() != "(" ||

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

  }

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

                         const Token &token) const override {

    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, Calculator *calc,</calculatornode>

               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 final : public FunctionPattern {

public:

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

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

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

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

  }

};

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

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

class F1Pattern final : public FunctionPattern {

public:

  F1Pattern(std::string functionName, std::string descr = "")

      : FunctionPattern(functionName, 1) {

    setDescription(descr);

  }

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

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

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

  }

};

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

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

class F2Pattern final : public FunctionPattern {

public:

  F2Pattern(std::string functionName, std::string descr = "")

      : FunctionPattern(functionName, 2) {

    setDescription(descr);

  }

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

                  const std::vector<token> &tokens) const override {</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 final : public FunctionPattern {

public:

  F3Pattern(std::string functionName, std::string descr = "")

      : FunctionPattern(functionName, 3) {

    setDescription(descr);

  }

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

                  const std::vector<token> &tokens) const override {</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 final : public FunctionPattern {

public:

  Fs2Pattern(std::string functionName, std::string description)

      : FunctionPattern(functionName, 1) {

    allowImplicitArg(true);

    setDescription(description);

  }

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

                  const std::vector<token> &tokens) const override {</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 final : public FunctionPattern {

public:

  Fs3Pattern(std::string functionName, double defVal, std::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 override {</token>

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

    getArgs(nodes, calc, stack, tokens);

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

  }

};

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

class CyclePattern final : public FunctionPattern {

public:

  CyclePattern(std::string functionName) : FunctionPattern(functionName, 1) {

    setDescription(

        "cycle(period)\nCycles the transitions of the period previous frames "

        "to the selected range");

  }

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

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

    CalculatorNode *a = popNode(stack);

    stack.push_back(new CycleNode(calc, a));

  }

};

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

class RandomPattern final : public FunctionPattern {

  bool m_seed;

public:

  RandomPattern(std::string functionName, bool seed, std::string description)

      : FunctionPattern(functionName, seed ? 1 : 0), m_seed(seed) {

    allowImplicitArg(true);

    addOptionalArg(0);

    addOptionalArg(0);

    setDescription(description);

  }

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

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

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

    if (m_seed) n--;

    RandomNode *randomNode = new RandomNode(calc);

    if (n > 0) {

      randomNode->setMax(popNode(stack));

      if (n > 1) randomNode->setMin(popNode(stack));

    }

    if (m_seed) randomNode->setSeed(popNode(stack));

    stack.push_back(randomNode);

  }

};

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

class PatternTable {

  std::map<std::string, *="" pattern=""> m_kTable;</std::string,>

  std::vector<pattern *=""> m_uTable;</pattern>

  Grammar::Position m_position;

public:

  PatternTable(Grammar::Position position) : m_position(position) {}

  ~PatternTable() {

    for (std::map<std::string, *="" pattern="">::iterator it = m_kTable.begin();</std::string,>

         it != m_kTable.end(); ++it)

      delete it->second;

    for (std::vector<pattern *="">::iterator it = m_uTable.begin();</pattern>

         it != m_uTable.end(); ++it)

      delete *it;

  }

  void addPattern(Pattern *pattern) {

    std::string keyword = pattern->getFirstKeyword();

    if (keyword != "") {

      // first keyword should be unique

      assert(m_kTable.count(keyword) == 0);

      m_kTable[keyword] = pattern;

    } else

      m_uTable.push_back(pattern);

  }

  const Pattern *getPattern(const Token &token) const {

    std::vector<token> tokens;</token>

    if (m_position == Grammar::ExpressionEnd) tokens.push_back(Token());

    if (token.getType() == Token::Punct || token.getType() == Token::Ident) {