#ifndef __AST_HPP__
#define __AST_HPP__ 1

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

#include "llvm/IR/Module.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/IRBuilder.h"
#include "llvm/IR/Verifier.h"
using namespace llvm;

class ExprAST {
public:
  virtual Value* codegen() const = 0;
  virtual ~ExprAST();
};

class VariableExprAST : public ExprAST {
public:
  VariableExprAST(string v)
    :_v(v)
  {}
  Value* codegen() const;
private:
  string _v;
};

class NumberExprAST : public ExprAST {
public:
  NumberExprAST(double d)
    :_d(d)
  {}
  Value* codegen() const;
private:
  double _d;
};

class InnerExprAST : public ExprAST {
public:
  InnerExprAST(ExprAST *e1);
  InnerExprAST(ExprAST *e1, ExprAST *e2);
  InnerExprAST(ExprAST *e1, ExprAST *e2, ExprAST *e3);
  InnerExprAST(vector<ExprAST *> v):
    _v(v)
  {}
  ~InnerExprAST();
private:
  InnerExprAST(const InnerExprAST&);
  InnerExprAST& operator=(const InnerExprAST&);
protected:
  vector<ExprAST*> _v;
};

class AddExprAST : public InnerExprAST {
public:
  AddExprAST(ExprAST* e1, ExprAST *e2)
    :InnerExprAST(e1, e2)
  {}
  Value* codegen() const;
};

class SubExprAST : public InnerExprAST {
public:
  SubExprAST(ExprAST* e1, ExprAST *e2)
    :InnerExprAST(e1, e2)
  {}
  Value* codegen() const;
};

class MulExprAST : public InnerExprAST {
public:
  MulExprAST(ExprAST* e1, ExprAST *e2)
    :InnerExprAST(e1, e2)
  {}
  Value* codegen() const;
};

class DivExprAST : public InnerExprAST {
public:
  DivExprAST(ExprAST* e1, ExprAST *e2)
    :InnerExprAST(e1, e2)
  {}
  Value* codegen() const;
};

class CallExprAST : public InnerExprAST {
public:
  CallExprAST(string f, vector<ExprAST*> v)
    :InnerExprAST(v), _f(f)
  {}
  Value* codegen() const;
private:
  string _f;
};

class PrototypeAST {
public:
  PrototypeAST(string f, vector<string> args)
    :_f(f), _args(args)
  {}
  Function* codegen() const;
  string getName() const {
    return _f;
  }
private:
  string _f;
  vector<string> _args;
};

class FunctionAST {
public:
  FunctionAST(PrototypeAST p, ExprAST *e)
    :_p(p), _e(e)
  {}
  Function* codegen() const;
  ~FunctionAST();
private:
  FunctionAST(const FunctionAST&);
  FunctionAST& operator=(const FunctionAST&);
  PrototypeAST _p;
  ExprAST *_e;
};

#endif