#ifndef __AST_HPP__
#define __AST_HPP__ 1

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

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


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

class NumberExprAST : public ExprAST {
public:
  NumberExprAST(int v)
    :Val(v)
  {}
  Value* codegen() const;
private:
  double Val;
};

class VariableExprAST : public ExprAST {
public:
  VariableExprAST(string s)
    :Name(s)
  {}
  string getName() const;
  Value* codegen() const;
private:
  string Name;
};

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

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

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

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

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

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

class PrototypeAST {
public:
  PrototypeAST(string n, vector<string> a)
    :Name(n), Args(a)
  {}
  Function* codegen() const;
  string getName() const {
    return Name;
  }
private:
  string Name;
  vector<string> Args;
};

class FunctionAST {
public:
  FunctionAST(PrototypeAST p, ExprAST* b)
    :Proto(p), Body(b)
  {}
  ~FunctionAST();
  Function* codegen() const;
private:
  FunctionAST(const FunctionAST& f);
  FunctionAST& operator=(const FunctionAST &f);
  PrototypeAST Proto;
  ExprAST *Body;
};

#endif