#ifndef __SYN_TREE_HPP__
#define __SYN_TREE_HPP__ 1
#include <vector>
#include <string>

using namespace std;

class SynTree {
public:
  virtual void compile() const = 0;
  virtual ~SynTree();
};

class Constant : public SynTree {
public:
  Constant(int v)
    :_v(v)
  {}
  void compile() const;
private:
  int _v;
};

class Variable : public SynTree {
public:
  Variable(string s)
    :_s(s)
  {}
  void compile() 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*> v);
  ~InnerTree();
private:
  InnerTree(const InnerTree& i);
  InnerTree& operator=(const InnerTree& i);
protected:
  vector <SynTree*> _nodes;
};

class Add : public InnerTree {
public:
  Add(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Sub : public InnerTree {
public:
  Sub(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Mul : public InnerTree {
public:
  Mul(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Div : public InnerTree {
public:
  Div(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Less : public InnerTree {
public:
  Less(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Greater : public InnerTree {
public:
  Greater(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};


class Print : public InnerTree {
public:
  Print(SynTree* a)
    :InnerTree(a)
  {}
  void compile() const;
};

class Assign : public InnerTree {
public:
  Assign(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Seq : public InnerTree {
public:
  Seq(vector<SynTree*> v)
    :InnerTree(v)
  {}
  void compile() const;
};

class While : public InnerTree {
public:
  While(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};

class Eps : public SynTree {
  void compile() const;
};

class IfThenElse : public InnerTree {
public:
  IfThenElse(SynTree* a, SynTree* b, SynTree* c)
    :InnerTree(a, b, c)
  {}
  void compile() const;
};

class IfThen : public InnerTree {
public:
  IfThen(SynTree* a, SynTree* b)
    :InnerTree(a, b)
  {}
  void compile() const;
};


#endif