#ifndef __AST_HPP__
#define __AST_HPP__ 1

#include <string>
#include <vector>
using namespace std;

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

class Constant : public SynTree {
public:
  Constant(int i)
    :_i(i)
  {}
  void compile() const;
private:
  int _i;
};

class Variable : public SynTree {
public:
  Variable(string s)
    :_s(s)
  {}
  inline const string& getName() const {
    return _s;
  }
  void compile() const;
private:
  string _s;
};

class InnerTree : public SynTree {
public:
  InnerTree(vector<SynTree*> v)
    :_v(v)
  {}
  InnerTree(SynTree* s1) {
    _v.resize(0);
    _v.push_back(s1);
  }
  InnerTree(SynTree* s1, SynTree* s2) {
    _v.resize(0);
    _v.push_back(s1);
    _v.push_back(s2);
  }
  InnerTree(SynTree* s1, SynTree* s2, SynTree* s3) {
    _v.resize(0);
    _v.push_back(s1);
    _v.push_back(s2);
    _v.push_back(s3);
  }
  ~InnerTree();
private:
  InnerTree(const InnerTree& i);
  InnerTree& operator=(const InnerTree &i);
protected:
  vector<SynTree*> _v;
};

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

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

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

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

class Lt : public InnerTree {
public:
  Lt(SynTree *s1, SynTree *s2)
    :InnerTree(s1, s2)
  {}
  void compile() const;
};

class Gt : public InnerTree {
public:
  Gt(SynTree *s1, SynTree *s2)
    :InnerTree(s1, s2)
  {}
  void compile() const;
};


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

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

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

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

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

class IfThenElse : public InnerTree {
public:
  IfThenElse(SynTree *s1, SynTree *s2, SynTree *s3)
    :InnerTree(s1, s2, s3)
  {}
  void compile() const;
};

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

#endif