#ifndef __SYNTREE_H__
#define __SYNTREE_H__ 1

#include <string>
#include <vector>

using namespace std;

class Syntree {
public:
  virtual void compile() const = 0;
  virtual ~Syntree() { }
  virtual Syntree* clone() const = 0;
};

class Variable : public Syntree {
public:
  Variable(string name)
    :_name(name)
  {}
  string getName() const {
    return _name;
  }
  void compile() const;  
  Syntree* clone() const;
private:
  string _name;
};

class Constant : public Syntree {
public:
  Constant(int value)
    :_value(value)
  {}
  void compile() const;  
  Syntree* clone() const;
private:
  int _value;
};

class InnerNode : public Syntree {
public:
  InnerNode(vector<Syntree *> nodes)
    :_nodes(nodes)
  {} 
  InnerNode(Syntree *i1, Syntree *i2, Syntree *i3);
  InnerNode(Syntree *i1, Syntree *i2);
  InnerNode(Syntree *i1);
  ~InnerNode();
  InnerNode(const InnerNode& i);
  InnerNode& operator=(const InnerNode& i);
private:
  void init(const InnerNode& i);
  void deinit();
protected:
  vector<Syntree *> _nodes;
};

class Add : public InnerNode {
public:
  Add(Syntree* i1, Syntree *i2)
    : InnerNode(i1, i2)
  {}
  void compile() const;  
  Syntree* clone() const;  
};

class Mul : public InnerNode {
public:
  Mul(Syntree* i1, Syntree *i2)
    : InnerNode(i1, i2)
  {}
  void compile() const;  
  Syntree* clone() const;  
};

class Lt : public InnerNode {
public:
  Lt(Syntree* i1, Syntree *i2)
    : InnerNode(i1, i2)
  {}
  void compile() const;  
  Syntree* clone() const;  
};

class Assign : public InnerNode {
public:
  Assign(Syntree* i1, Syntree *i2)
    :InnerNode(i1, i2)
  {}
  void compile() const;  
  Syntree* clone() const;  
}; 

class Print : public InnerNode {
public:
  Print(Syntree* i1)
    :InnerNode(i1)
  {}
  void compile() const;  
  Syntree* clone() const;  
}; 

class Seq : public InnerNode {
public:
  Seq(InnerNode* i1, Syntree *i2)
    :InnerNode(i1)
  {
    _nodes.push_back(i2);
  }
  void compile() const;  
  Syntree* clone() const;  
}; 

class While : public InnerNode {
public:
  While(Syntree* cond, Syntree *c)
    :InnerNode(cond, c)
  {}
  void compile() const;  
  Syntree* clone() const;  
};

class Empty : public Syntree {
public:
  void compile() const;  
  Syntree* clone() const;  
};

class IfThenElse : public InnerNode {
public:
  IfThenElse(Syntree* cond, Syntree *c1, Syntree *c2)
    :InnerNode(cond, c1, c2)
  {}
  void compile() const;  
  Syntree* clone() const;  
};

class IfThen : public InnerNode {
public:
  IfThen(Syntree* cond, Syntree *c)
    :InnerNode(cond, c)
  {}
  void compile() const;  
  Syntree* clone() const;  
};

#endif