#ifndef __SYN_TREE_HPP__
#define __SYN_TREE_HPP__ 1
#include <iostream>
#include <string>
#include <vector>
#include <map>
using namespace std;

class SynTree {
public:
  virtual int interpret(map<string, int> &p) const = 0;
  virtual ~SynTree();
};

class Constant : public SynTree {
public:
  Constant(int v)
    :_v(v)
  {}
  int interpret(map<string, int> &p) const;
private:
  int _v;
};

class Variable : public SynTree {
public:
  Variable(string s)
    :_s(s)
  {}
  int interpret(map<string, int> &p) const;
  string getName() const;
private:
  string _s;
};

class InnerTree : public SynTree {
public:
  InnerTree(SynTree* a);
  InnerTree(SynTree* a, SynTree* b);
  InnerTree(SynTree* a, SynTree* b, SynTree* c);
  InnerTree(vector<SynTree*> a);
  ~InnerTree();
protected:
  vector<SynTree*> _nodes;
private:
  InnerTree(const InnerTree& i);
  InnerTree& operator=(const InnerTree& i);
};

class Add : public InnerTree {
public:
  Add(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Sub : public InnerTree {
public:
  Sub(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Mul : public InnerTree {
public:
  Mul(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Div : public InnerTree {
public:
  Div(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Greater : public InnerTree {
public:
  Greater(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Less : public InnerTree {
public:
  Less(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Eq : public InnerTree {
public:
  Eq(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};


class Assign : public InnerTree {
public:
  Assign(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  int interpret(map<string, int> &p) const;
};

class Print : public InnerTree {
public:
  Print(SynTree* a)
    :InnerTree(a)
  {}
  int interpret(map<string, int> &p) const;
};

class Seq : public InnerTree {
public:
  Seq(vector<SynTree*> v)
    :InnerTree(v)
  {}
  int interpret(map<string, int> &p) const;
};

class PozivFje : public InnerTree {
public:
  PozivFje(string name, vector<SynTree*> s)
    :InnerTree(s), _name(name)
  {}
  int interpret(map<string, int> &p) const;
private:
  string _name;
};

class Upitnik : public InnerTree {
public:
  Upitnik(SynTree *a, SynTree *b, SynTree *c)
    :InnerTree(a, b, c)
  {}
  int interpret(map<string, int> &p) const;
};

class Fja {
public:
  Fja(string res, vector<string> args, SynTree *code)
    :_res(res), _args(args), _code(code)
  {}
  int pozovi(vector<int> a);
  ~Fja();
private:
  string _res;
  vector<string> _args;
  SynTree *_code;
};

#endif