%{
#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>
#include "ast.hpp"
#define YYDEBUG 1
using namespace std;

 int yylex();

 void yyerror(string s) {
   cerr << s << endl;
   exit(EXIT_FAILURE);
 }

 int counter = 0;
  
%}

%nonassoc else_token in_token
%left ':'
%right '='
%left '<' '>'
%left '+' '-'
%left '*' '/'

%union {
  double d;
  string *s;
  ExprAST *e;
  vector<ExprAST*> *v;
  vector<string> *v1;
  PrototypeAST *p;
  vector< pair<string, ExprAST*> > *v2;
  pair<string, ExprAST*> *p1;
}

%token <d> num_token
%token <s> id_token 
%token def_token extern_token if_token else_token then_token for_token in_token var_token

%type <e> E Inkrement
%type <v> NizE
%type <v1> Argumenti
%type <p> Potpis
%type <v2> NizInic
%type <p1> Inic

%%
Program : Program Naredba ';'
| Naredba ';'
;
Naredba : def_token Potpis E {
  FunctionAST f(*$2, $3);
  delete $2;
  f.codegen();
 }
| extern_token Potpis {
  $2->codegen();
  delete $2;
 }
| E {
  PrototypeAST p("neimenovana_fja_" + to_string(counter++), vector<string>());
  FunctionAST f(p, $1);
  f.codegen();
 }
;
Potpis: id_token '(' Argumenti ')' {
  $$ = new PrototypeAST(*$1, *$3);
  delete $1;
  delete $3;
 }
Argumenti : Argumenti id_token {
  $$ = $1;
  $$->push_back(*$2);
  delete $2;
 }
|  {
  $$ = new vector<string>();
 }
;
E : E '+' E {
  $$ = new AddExprAST($1, $3);
 }
| E '-' E {
  $$ = new SubExprAST($1, $3);
 }
| E '*' E {
  $$ = new MulExprAST($1, $3);
 }
| E '/' E {
  $$ = new DivExprAST($1, $3);
 }
| E '<' E {
  $$ = new LessThenExprAST($1, $3);
  }
| E '>' E {
  $$ = new GreaterThenExprAST($1, $3);
  }
| E ':' E {
  $$ = new SeqExprAST($1, $3);
  }
| id_token '=' E {
  $$ = new AssignExprAST(*$1, $3);
  delete $1;
  }
| '(' E ')' {
  $$ = $2;
 }
| num_token {
  $$ = new NumberExprAST($1);
 }
| id_token {
  $$ = new VariableExprAST(*$1);
  delete $1;
  }
| id_token '(' NizE ')' {
  $$ = new CallExprAST(*$1, *$3);
  delete $1;
  delete $3;
  }
| id_token '(' ')' {
  $$ = new CallExprAST(*$1, vector<ExprAST*>());
  delete $1;
  }
| if_token E then_token E else_token E {
  $$ = new IfThenElse($2, $4, $6);
 }
| for_token id_token '=' E ',' E Inkrement in_token E {
  $$ = new ForIn(*$2, $4, $6, $7, $9);
  delete $2;
 }
| var_token NizInic in_token E {
  $$ = new VarExprAST(*$2, $4);
  delete $2;
 }
;
NizInic: NizInic ',' Inic {
  $$ = $1;
  $$->push_back(*$3);
  delete $3;
 }
| Inic {
  $$ = new vector<pair<string, ExprAST*> >();
  $$->push_back(*$1);
  delete $1;
 }
;
Inic: id_token '=' E {
  $$ = new pair<string, ExprAST*>(*$1, $3);
  delete $1;
 }
| id_token {
  $$ = new pair<string, ExprAST*>(*$1, new NumberExprAST(0));
  delete $1;
  }
;
Inkrement: ',' E {
  $$ = $2;
 }
| {
  $$ = new NumberExprAST(1.0);
 }
;
NizE: NizE ',' E {
  $$ = $1;
  $$->push_back($3);
 }
| E {
  $$ = new vector<ExprAST*>();
  $$->push_back($1);
 }
;
%%

extern llvm::Module* TheModule;
extern llvm::LLVMContext TheContext;

int main() {
  //yydebug = 1;

  InitializeModuleAndPassManager();
  
  yyparse();

  //TheModule->dump();

  auto TargetTriple = sys::getDefaultTargetTriple();

  InitializeAllTargetInfos();
  InitializeAllTargets();
  InitializeAllTargetMCs();
  InitializeAllAsmParsers();
  InitializeAllAsmPrinters();

  string Error;
  auto Target = TargetRegistry::lookupTarget(TargetTriple, Error);  
  if (!Target) {
    cerr << Error;
    return 1;
  }

  auto CPU = "generic";
  auto Features = "";
  
  TargetOptions opt;
  auto RM = Reloc::Model();
  auto TargetMachine = Target->createTargetMachine(TargetTriple, CPU, Features, opt, RM);

  TheModule->setDataLayout(TargetMachine->createDataLayout());
  TheModule->setTargetTriple(TargetTriple);

  string Filename = "output.o";
  error_code EC;
  raw_fd_ostream dest(Filename, EC, sys::fs::F_None);
  
  if (EC) {
    cerr << "Could not open file: " << EC.message();
    return 1;
  }

  legacy::PassManager pass;
  auto FileType = TargetMachine::CGFT_ObjectFile;
  
  if (TargetMachine->addPassesToEmitFile(pass, dest, FileType)) {
    cerr << "TargetMachine can't emit a file of this type";
    return 1;
  }
  
  pass.run(*TheModule);
  dest.close();

  delete TheModule;
  
  return 0;
}