// SysYIRGenerator.cpp
// TODO：类型转换及其检查
// TODO：sysy库函数处理
// TODO：数组处理
// TODO：对while、continue、break的测试
#include "IR.h"
#include <any>
#include <memory>
using namespace std;
#include "SysYIRGenerator.h"

namespace sysy {

/*
 * @brief: visit compUnit
 * @details:
 *      compUnit: (decl | funcDef)+;
 */
std::any SysYIRGenerator::visitCompUnit(SysYParser::CompUnitContext *ctx) {
  // create the IR module
  auto pModule = new Module();
  assert(pModule);
  module.reset(pModule);

  SymbolTable::ModuleScope scope(symbols_table);

  // 待添加运行时库函数getint等
  // generates globals and functions
  auto type_i32 = Type::getIntType();
  auto type_f32 = Type::getFloatType();
  auto type_void = Type::getVoidType();
  auto type_i32p = Type::getPointerType(type_i32);
  auto type_f32p = Type::getPointerType(type_f32);
  
  //runtime library
  module->createFunction("getint", Type::getFunctionType(type_i32, {}));
  module->createFunction("getch", Type::getFunctionType(type_i32, {}));
  module->createFunction("getfloat", Type::getFunctionType(type_f32, {}));
  symbols_table.insert("getint", module->getFunction("getint"));
  symbols_table.insert("getch", module->getFunction("getch"));
  symbols_table.insert("getfloat", module->getFunction("getfloat"));
  
  module->createFunction("getarray", Type::getFunctionType(type_i32, {type_i32p}));
  module->createFunction("getfarray", Type::getFunctionType(type_i32, {type_f32p}));
  symbols_table.insert("getarray", module->getFunction("getarray"));
  symbols_table.insert("getfarray", module->getFunction("getfarray"));

  module->createFunction("putint", Type::getFunctionType(type_void, {type_i32}));
  module->createFunction("putch", Type::getFunctionType(type_void, {type_i32}));
  module->createFunction("putfloat", Type::getFunctionType(type_void, {type_f32}));
  symbols_table.insert("putint", module->getFunction("putint"));
  symbols_table.insert("putch", module->getFunction("putch"));
  symbols_table.insert("putfloat", module->getFunction("putfloat"));

  module->createFunction("putarray", Type::getFunctionType(type_void, {type_i32, type_i32p}));
  module->createFunction("putfarray", Type::getFunctionType(type_void, {type_i32, type_f32p}));
  symbols_table.insert("putarray", module->getFunction("putarray"));
  symbols_table.insert("putfarray", module->getFunction("putfarray"));

  module->createFunction("putf", Type::getFunctionType(type_void, {}));
  symbols_table.insert("putf", module->getFunction("putf"));

  module->createFunction("starttime", Type::getFunctionType(type_void, {type_i32}));
  module->createFunction("stoptime", Type::getFunctionType(type_void, {type_i32}));
  symbols_table.insert("starttime", module->getFunction("starttime"));
  symbols_table.insert("stoptime", module->getFunction("stoptime"));

  // visit all decls and funcDefs
  for(auto decl:ctx->decl()){
    decl->accept(this);
  }
  for(auto funcDef:ctx->funcDef()){
    builder = IRBuilder();
    printf("entry funcDef\n");
    funcDef->accept(this);
  }
  // return the IR module ?
  return pModule;
}

/*
 * @brief: visit decl
 * @details:
 *      decl: constDecl | varDecl;
 *      constDecl: CONST bType constDef (COMMA constDef)* SEMI;
 *      varDecl: bType varDef (COMMA varDef)* SEMI;
 * constDecl and varDecl shares similar syntax structure
 * we consider them together? not sure
 */
std::any SysYIRGenerator::visitDecl(SysYParser::DeclContext *ctx) {
  if(ctx->constDecl())
    return visitConstDecl(ctx->constDecl());
  else if(ctx->varDecl())
    return visitVarDecl(ctx->varDecl());
  std::cerr << "error unkown decl" << ctx->getText() << std::endl;
  return std::any();
}

/*
 * @brief: visit constdecl
 * @details:
 *      constDecl: CONST bType constDef (COMMA constDef)* SEMI;
 *      constDef: Ident (LBRACK constExp RBRACK)* (ASSIGN constInitVal)?;
 */
std::any SysYIRGenerator::visitConstDecl(SysYParser::ConstDeclContext *ctx) {
  cout << "visitconstDecl" << endl;
  current_type = any_cast<Type*>(ctx->bType()->accept(this));
  for(auto constDef:ctx->constDef()){
    constDef->accept(this);
  }
  return std::any();
}
/*
 * @brief: visit btype
 * @details:
 *      bType: INT | FLOAT;
 */
std::any SysYIRGenerator::visitBType(SysYParser::BTypeContext *ctx) {
  if(ctx->INT())
    return Type::getPointerType(Type::getIntType());
  else if(ctx->FLOAT())  
    return Type::getPointerType(Type::getFloatType());
  std::cerr << "error: unknown type" << ctx->getText() << std::endl;
  return std::any();
}

/*
 * @brief: visit constDef
 * @details:
 *     constDef: Ident (LBRACK constExp RBRACK)* (ASSIGN constInitVal)?;
 *     constInitVal: constExp | LBRACE (constInitVal (COMMA constInitVal)*)? RBRACE;
 */
std::any SysYIRGenerator::visitConstDef(SysYParser::ConstDefContext *ctx){
  auto name = ctx->Ident()->getText();
  Type* type = current_type;
  Value* init = ctx->constInitVal() ? any_cast<Value*>(ctx->constInitVal()->accept(this)) : (Value *)nullptr;

  if (ctx->constExp().empty()){
    //scalar
    if(init){
      if(symbols_table.isModuleScope()){
        assert(init->isConstant() && "global must be initialized by constant");
        Value* global = module->createGlobalValue(name, type, {}, init);
        symbols_table.insert(name, global);
        cout << "add module const " << name ;
        if(init){
          cout << " inited by " ;
          init->print(cout);
        }
        cout << '\n';
      }
      else{
        Value* alloca = builder.createAllocaInst(type, {}, name);
        Value* store = builder.createStoreInst(init, alloca);
        symbols_table.insert(name, alloca);
        cout << "add local const " << name ;
        if(init){
          cout << " inited by " ;
          init->print(cout);
        }
        cout << '\n';
      }
    }
    else{
      assert(false && "const without initialization");
    }
  }
  else{
    //array
    std::cerr << "array constDef not implemented yet" << std::endl;
  }
  printf("visitConstDef %s\n",name.c_str());
  return std::any();
}


/*
 * @brief: visit constInitVal
 * @details:
 *      constInitVal: constExp
 *		              | LBRACE (constInitVal (COMMA constInitVal)*)? RBRACE;
 */
std::any SysYIRGenerator::visitConstInitVal(SysYParser::ConstInitValContext *ctx){
  Value* initvalue;
  if(ctx->constExp())
    initvalue = any_cast<Value*>(ctx->constExp()->accept(this));
  else{
    //还未实现数组初始化等功能待验证
    std::cerr << "array initvalue not implemented yet" << std::endl;
    // auto numConstInitVals = ctx->constInitVal().size();
    // vector<Value*> initvalues;
    // for(int i = 0; i < numConstInitVals; i++)
    //   initvalues.push_back(any_cast<Value*>(ctx->constInitVal(i)->accept(this)));
    // initvalue = ConstantValue::getArray(initvalues);
  }
  return initvalue;  
}

/*
 * @brief: visit function type
 * @details:
 *      funcType: VOID | INT | FLOAT;
 */
std::any SysYIRGenerator::visitFuncType(SysYParser::FuncTypeContext* ctx){
  if(ctx->INT())
    return Type::getIntType();
  else if(ctx->FLOAT())
    return Type::getFloatType();
  else if(ctx->VOID())
    return Type::getVoidType();
  std::cerr << "invalid function type: " << ctx->getText() << std::endl;
  return std::any();
}

/*
 * @brief: visit function define
 * @details:
 *      funcDef: funcType Ident LPAREN funcFParams? RPAREN blockStmt;
 *      funcFParams: funcFParam (COMMA funcFParam)*;
 *      funcFParam: bType Ident (LBRACK RBRACK (LBRACK exp RBRACK)*)?;
 * entry -> next -> others -> exit
 * entry: allocas, br
 * next: retval, params, br
 * other: blockStmt init block
 * exit: load retval, ret
 */
std::any SysYIRGenerator::visitFuncDef(SysYParser::FuncDefContext* ctx){

  auto funcName = ctx->Ident()->getText();
  auto returnType = any_cast<Type*>(ctx->funcType()->accept(this));
  auto func = module->getFunction(funcName);
  
  cout << "func: ";
  returnType->print(cout);
  cout << ' '<< funcName.c_str() << endl;

  vector<Type*> paramTypes;
  vector<string> paramNames;

  if(ctx->funcFParams()){
    for(auto funcParam:ctx->funcFParams()->funcFParam()){
      Type* paramType = any_cast<Type*>(funcParam->bType()->accept(this));
      paramTypes.push_back(paramType);
      paramNames.push_back(funcParam->Ident()->getText());
    }
  }
  
  
  auto funcType = FunctionType::get(returnType, paramTypes);
  auto function = module->createFunction(funcName, funcType);

  SymbolTable::FunctionScope scope(symbols_table);
  BasicBlock* entryblock = function->getEntryBlock();
  for(size_t i = 0; i < paramTypes.size(); i++)
    entryblock->createArgument(paramTypes[i], paramNames[i]);

  for(auto& arg: entryblock->getArguments())
    symbols_table.insert(arg->getName(), (Value *)arg.get());

  cout << "setposition entryblock" << endl;
  builder.setPosition(entryblock, entryblock->end());

  ctx->blockStmt()->accept(this);

  return std::any();
}

/*
 * @brief: visit varDecl
 * @details:
 *     varDecl: bType varDef (COMMA varDef)* SEMI;
 */
std::any SysYIRGenerator::visitVarDecl(SysYParser::VarDeclContext *ctx){
  cout << "visitVarDecl" << endl;
  current_type = any_cast<Type *>(ctx->bType()->accept(this));
  for(auto varDef:ctx->varDef()){
    varDef->accept(this);
  }
  return std::any();
}

/*
 * @brief: visit varDef
 * @details:
 *     varDef: Ident (LBRACK constExp RBRACK)* (ASSIGN initVal)?;
 */
std::any SysYIRGenerator::visitVarDef(SysYParser::VarDefContext *ctx){
  const std::string name = ctx->Ident()->getText();
  Type* type = current_type;
  Value* init = ctx->initVal() ? any_cast<Value*>(ctx->initVal()->accept(this)) : nullptr;
  // const std::vector<Value *> dims = {};

  cout << "vardef: ";
  current_type->print(cout);
  cout << ' ' << name << endl;

  if(ctx->constExp().empty()){
    //scalar
    if(symbols_table.isModuleScope()){

      if(init)
        assert(init->isConstant() && "global must be initialized by constant");
      Value* global = module->createGlobalValue(name, type, {}, init);
      symbols_table.insert(name, global);
      cout << "add module var " << name ;
      // if(init){
      //   cout << " inited by " ;
      //   init->print(cout);
      // }
      cout << '\n';
    }
    else{
      
      Value* alloca = builder.createAllocaInst(type, {}, name);
      cout << "creatalloca" << endl;
      alloca->print(cout);
      Value* store = (StoreInst *)nullptr;
      if(init != nullptr)
        store = builder.createStoreInst(alloca, init, {}, name);
      symbols_table.insert(name, alloca);
      // alloca->setName(name);
      cout << "add local var " ;
      alloca->print(cout);
      // if(init){
      //   cout << " inited by " ;
      //   init->print(cout);
      // }
      cout << '\n';        
    }
  }
  else{
    //array
    std::cerr << "array varDef not implemented yet" << std::endl;
  }
  return std::any();
}

/*
 * @brief: visit initVal
 * @details:
 *      initVal: exp | LBRACE (initVal (COMMA initVal)*)? RBRACE;
 */
std::any SysYIRGenerator::visitInitVal(SysYParser::InitValContext *ctx) {
  Value* initvalue = nullptr;
  if(ctx->exp())
    initvalue = any_cast<Value*>(ctx->exp()->accept(this));
  else{
    //还未实现数组初始化等功能待验证
    std::cerr << "array initvalue not implemented yet" << std::endl;
    // auto numConstInitVals = ctx->constInitVal().size();
    // vector<Value*> initvalues;
    // for(int i = 0; i < numConstInitVals; i++)
    //   initvalues.push_back(any_cast<Value*>(ctx->constInitVal(i)->accept(this)));
    // initvalue = ConstantValue::getArray(initvalues);
  }
  return initvalue;  
}

// std::any SysYIRGenerator::visitFuncFParams(SysYParser::FuncFParamsContext* ctx){
//   return visitChildren(ctx);
// }
// std::any SysYIRGenerator::visitFuncFParam(SysYParser::FuncFParamContext *ctx) {
//   return visitChildren(ctx);
// }

/*
 * @brief: visit blockStmt
 * @details:
 *      blockStmt: LBRACE blockItem* RBRACE;
 *      blockItem: decl | stmt;
 */
std::any SysYIRGenerator::visitBlockStmt(SysYParser::BlockStmtContext* ctx){
  SymbolTable::BlockScope scope(symbols_table);
  for (auto item : ctx->blockItem()){
    item->accept(this);
    // if(builder.getBasicBlock()->isTerminal()){
    //   break;
    // }
  }
  return std::any();
}

/*
 * @brief: visit ifstmt
 * @details:
 *      ifStmt: IF LPAREN cond RPAREN stmt (ELSE stmt)?;
 */
std::any SysYIRGenerator::visitIfStmt(SysYParser::IfStmtContext *ctx) {
  auto condition = any_cast<Value *>(ctx->cond()->accept(this));

  auto thenBlock = builder.getBasicBlock()->getParent()->addBasicBlock("then");
  auto elseBlock = builder.getBasicBlock()->getParent()->addBasicBlock("else");

  auto condbr = builder.createCondBrInst(condition,thenBlock,elseBlock,{},{});

  builder.setPosition(thenBlock, thenBlock->end());
  ctx->stmt(0)->accept(this);

  if(ctx->ELSE()){
    builder.setPosition(elseBlock, elseBlock->end());
    ctx->stmt(1)->accept(this);
  }
  //无条件跳转到下一个基本块
  // builder.createUncondBrInst(builder.getBasicBlock()->getParent()->addBasicBlock("next"),{});
  return std::any();
}

/*
 * @brief: visit whilestmt
 * @details: 
 *      whileStmt: WHILE LPAREN cond RPAREN stmt;
 */

 std::any SysYIRGenerator::visitWhileStmt(SysYParser::WhileStmtContext* ctx) {
  //需要解决一个函数多个循环的命名问题
  auto header = builder.getBasicBlock()->getParent()->addBasicBlock("header");
  auto body = builder.getBasicBlock()->getParent()->addBasicBlock("body");
  auto exit = builder.getBasicBlock()->getParent()->addBasicBlock("exit");

  SymbolTable::BlockScope scope(symbols_table);

  {  // visit header block
    builder.setPosition(header, header->end());
    auto cond = any_cast<Value*>(ctx->cond()->accept(this));
    auto condbr = builder.createCondBrInst(cond, body, exit, {}, {});
  }

  {  // visit body block
    builder.setPosition(body, body->end());
    ctx->stmt()->accept(this);
    auto uncondbr = builder.createUncondBrInst(header, {});
  }

  // visit exit block
  builder.setPosition(exit, exit->end());
  //无条件跳转到下一个基本块以及一些参数传递

  return std::any();
}

/*
 * @brief: visit breakstmt
 * @details:
 *      breakStmt: BREAK SEMICOLON;
 */
std::any SysYIRGenerator::visitBreakStmt(SysYParser::BreakStmtContext* ctx) {
  //如何获取break所在body对应的header块
  return std::any();
}
/*
 * @brief Visit ReturnStmt
 *      returnStmt: RETURN exp? SEMICOLON;
 */
std::any SysYIRGenerator::visitReturnStmt(SysYParser::ReturnStmtContext* ctx) {
  cout << "visitReturnStmt" << endl;
  // auto value = ctx->exp() ? any_cast_Value(visit(ctx->exp())) : nullptr;
  Value* value = ctx->exp() ? any_cast<Value*>(ctx->exp()->accept(this)) : nullptr;

  const auto func = builder.getBasicBlock()->getParent();

  assert(func && "ret stmt block parent err!");

  // 匹配 返回值类型 与 函数定义类型
  if (func->getReturnType()->isVoid()) {
    if (ctx->exp())
      assert(false && "the returned value is not matching the function");

    auto ret = builder.createReturnInst();
    return std::any();
  }

  assert(ctx->exp() && "the returned value is not matching the function");

  auto ret = builder.createReturnInst(value);

  //需要增加无条件跳转吗
  return std::any();
}

/*
 * @brief: visit continuestmt
 * @details:
 *     continueStmt: CONTINUE SEMICOLON;
 */
std::any SysYIRGenerator::visitContinueStmt(SysYParser::ContinueStmtContext* ctx) {
  //如何获取continue所在body对应的header块
  return std::any();
}


/*
 * @brief visit assign stmt
 * @details:
 *      assignStmt: lValue ASSIGN exp SEMICOLON
 */
std::any SysYIRGenerator::visitAssignStmt(SysYParser::AssignStmtContext* ctx) {
  cout << "visitassignstme :\n";
  auto lvalue = any_cast<Value *>(ctx->lValue()->accept(this));
  cout << "getlval" << endl;//lvalue->print(cout);cout << ')';
  auto rvalue = any_cast<Value *>(ctx->exp()->accept(this));
  //可能要考虑类型转换例如int a = 1.0
  cout << "getrval" << endl;//rvalue->print(cout);cout << ")\n";
  builder.createStoreInst(rvalue, lvalue, {}, {});
  return std::any();
}

/*
 * @brief: visit lValue
 * @details:
 *      lValue: Ident (LBRACK exp RBRACK)*;
 */
std::any SysYIRGenerator::visitLValue(SysYParser::LValueContext* ctx) {
  cout << "visitLValue" << endl;
  auto name = ctx->Ident()->getText();
  Value* value = symbols_table.lookup(name);

  assert(value && "lvalue not found");

  if(ctx->exp().size() == 0){
    //scalar
    cout << "lvalue: " << name << endl;
    return value;
  }
  else{
    //array
    std::cerr << "array lvalue not implemented yet" << std::endl;    
  }
  std::cerr << "error lvalue" << ctx->getText() << std::endl;
  return std::any();
}

std::any SysYIRGenerator::visitPrimExp(SysYParser::PrimExpContext *ctx){
  cout << "visitPrimExp" << endl;
  return visitChildren(ctx);
}
// std::any SysYIRGenerator::visitExp(SysYParser::ExpContext* ctx) {
//   cout << "visitExp" << endl;
//   return ctx->addExp()->accept(this);
// }

std::any SysYIRGenerator::visitNumber(SysYParser::NumberContext *ctx) {
  cout << "visitNumber" << endl;
  Value* res = nullptr;
  if (auto iLiteral = ctx->ILITERAL()) {
    /* 基数 (8, 10, 16) */
    const auto text = iLiteral->getText();
    int base = 10;
    if (text.find("0x") == 0 || text.find("0X") == 0) {
      base = 16;
    } else if (text.find("0b") == 0 || text.find("0B") == 0) {
      base = 2;
    } else if (text.find("0") == 0) {
      base = 8;
    }
    res = ConstantValue::get((int)std::stol(text, 0, base));
  } else if (auto fLiteral = ctx->FLITERAL()) {
    const auto text = fLiteral->getText();
    res = ConstantValue::get((float)std::stof(text));
  }
  cout << "number: ";
  res->print(cout);
  cout << endl;

  return res;
}

/*
 * @brief: visit call
 * @details:
 *      call: Ident LPAREN funcRParams? RPAREN;
 */
std::any SysYIRGenerator::visitCall(SysYParser::CallContext* ctx) {
  cout << "visitCall" << endl;
  auto funcName = ctx->Ident()->getText();
  auto func = module->getFunction(funcName);
  assert(func && "function not found");

  //需要做类型检查和转换
  std::vector<Value*> args;
  if(ctx->funcRParams()){
    for(auto exp:ctx->funcRParams()->exp()){
      args.push_back(any_cast<Value*>(exp->accept(this)));
    }
  }
  Value* call = builder.createCallInst(func, args);
  return call;
}

/*
 * @brief: visit unexp
 * @details:
 *    unExp: unaryOp unaryExp
 */
std::any SysYIRGenerator::visitUnExp(SysYParser::UnExpContext *ctx) {
  cout << "visitUnExp" << endl;
  Value* res = nullptr;
  auto op = ctx->unaryOp()->getText();
  auto exp = any_cast<Value*>(ctx->unaryExp()->accept(this));
  if(ctx->unaryOp()->ADD()){
    res = exp;
  }
  else if(ctx->unaryOp()->SUB()){
    res = builder.createNegInst(exp, exp->getName());
  }
  else if(ctx->unaryOp()->NOT()){
    //not将非零值转换为0，零值转换为1
    res = builder.createNotInst(exp, exp->getName());
  }
  return res;
}

/*
 * @brief: visit mulexp
 * @details:
 *    mulExp: unaryExp ((MUL | DIV | MOD) unaryExp)*
 */
std::any SysYIRGenerator::visitMulExp(SysYParser::MulExpContext *ctx) {
  cout << "visitMulExp" << endl;
  Value* res = nullptr;
  cout << "mulExplhsin\n";
  Value* lhs = any_cast<Value *>(ctx->unaryExp(0)->accept(this));
  cout << "mulExplhsout\n";
  if(ctx->unaryExp().size() == 1){
    cout << "unaryExp().size() = 1\n";
    res = lhs;
  }
  else{
    cout << "unaryExp().size() > 1\n";
    for(size_t i = 1; i < ctx->unaryExp().size(); i++){
      Value* rhs = any_cast<Value *>(ctx->unaryExp(i)->accept(this));
      auto opNode = dynamic_cast<antlr4::tree::TerminalNode *>(ctx->children[2 * i - 1]);
      
      if(opNode->getText() == "*"){
        res = builder.createMulInst(lhs, rhs, lhs->getName() + "*" + rhs->getName());
      }
      else if(opNode->getText() == "/"){
        res = builder.createDivInst(lhs, rhs, lhs->getName() + "/" + rhs->getName());
      }
      else if(opNode->getText() == "%"){
        std::cerr << "mod not implemented yet" << std::endl;
        // res = builder.createModInst(lhs, rhs, lhs->getName() + "%" + rhs->getName());
      }  
    }
  }
  return res;  
}

/*
 * @brief: visit addexp
 * @details:
 *    addExp: mulExp ((ADD | SUB) mulExp)*
 */
std::any SysYIRGenerator::visitAddExp(SysYParser::AddExpContext *ctx) {
  cout << "visitAddExp" << endl;
  Value* res = nullptr;
  Value* lhs = any_cast<Value*>(ctx->mulExp(0)->accept(this));
  if(ctx->mulExp().size() == 1){
    cout << "ctx->mulExp().size() = 1\n";
    res = lhs;
  }
  else{
    for(size_t i = 1; i < ctx->mulExp().size(); i++){
      cout << "i = " << i << "\n";
      Value* rhs = any_cast<Value*>(ctx->mulExp(i)->accept(this));
      auto opNode = dynamic_cast<antlr4::tree::TerminalNode *>(ctx->children[2 * i - 1]);
      
      if(opNode->getText() == "+"){
        res = builder.createAddInst(lhs, rhs, lhs->getName() + "+" + rhs->getName());
      }
      else if(opNode->getText() == "-"){
        res = builder.createSubInst(lhs, rhs, lhs->getName() + "-" + rhs->getName());
      }
    }
    lhs = res;
  }

  return res;  
}

/*
 * @brief: visit relexp
 * @details:
 *    relExp: addExp ((LT | GT | LE | GE) addExp)*
 */
std::any SysYIRGenerator::visitRelExp(SysYParser::RelExpContext *ctx) {
  cout << "visitRelExp" << endl;
  Value* res = nullptr;
  Value* lhs = any_cast<Value*>(ctx->addExp(0)->accept(this));
  if(ctx->addExp().size() == 1){
    res = lhs;
  }
  else{
    for(size_t i = 1; i < ctx->addExp().size(); i++){
      Value* rhs = any_cast<Value*>(ctx->addExp(i)->accept(this));
      auto opNode = dynamic_cast<antlr4::tree::TerminalNode *>(ctx->children[2 * i - 1]);
      if(lhs->getType() != rhs->getType()){
        std::cerr << "type mismatch:type check not implemented" << std::endl;
      }
      Type* type = lhs->getType();
      if(opNode->getText() == "<"){
        if(type->isInt())
          res = builder.createICmpLTInst(lhs, rhs, lhs->getName() + "<" + rhs->getName());
        else if(type->isFloat())
          res = builder.createFCmpLTInst(lhs, rhs, lhs->getName() + "<" + rhs->getName());
      }
      else if(opNode->getText() == ">"){
        if(type->isInt())
          res = builder.createICmpGTInst(lhs, rhs, lhs->getName() + ">" + rhs->getName());
        else if(type->isFloat())
          res = builder.createFCmpGTInst(lhs, rhs, lhs->getName() + ">" + rhs->getName());
      }
      else if(opNode->getText() == "<="){
        if(type->isInt())
          res = builder.createICmpLEInst(lhs, rhs, lhs->getName() + "<=" + rhs->getName());
        else if(type->isFloat())
          res = builder.createFCmpLEInst(lhs, rhs, lhs->getName() + "<=" + rhs->getName());
      }
      else if(opNode->getText() == ">="){
        if(type->isInt())
          res = builder.createICmpGEInst(lhs, rhs, lhs->getName() + ">=" + rhs->getName());
        else if(type->isFloat())
          res = builder.createFCmpGEInst(lhs, rhs, lhs->getName() + ">=" + rhs->getName());
      }
    }
  }
  return res;
}

/*
 * @brief: visit eqexp
 * @details:
 *    eqExp: relExp ((EQ | NEQ) relExp)*
 */
std::any SysYIRGenerator::visitEqExp(SysYParser::EqExpContext* ctx) {
  cout << "visitEqExp" << endl;
  Value* res = nullptr;
  Value* lhs = any_cast<Value*>(ctx->relExp(0)->accept(this));
  if(ctx->relExp().size() == 1){
    res = lhs;
  }
  else{
    for(size_t i = 1; i < ctx->relExp().size(); i++){
      Value* rhs = any_cast<Value*>(ctx->relExp(i)->accept(this));
      auto opNode = dynamic_cast<antlr4::tree::TerminalNode *>(ctx->children[2 * i - 1]);
      if(lhs->getType() != rhs->getType()){
        std::cerr << "type mismatch:type check not implemented" << std::endl;
      }
      Type* type = lhs->getType();
      if(opNode->getText() == "=="){
        if(type->isInt())
          res = builder.createICmpEQInst(lhs, rhs, lhs->getName() + "==" + rhs->getName());
        else if(type->isFloat())
          res = builder.createFCmpEQInst(lhs, rhs, lhs->getName() + "==" + rhs->getName());
      }
      else if(opNode->getText() == "!="){
        if(type->isInt())
          res = builder.createICmpNEInst(lhs, rhs, lhs->getName() + "!=" + rhs->getName());
        else if(type->isFloat())
          res = builder.createFCmpNEInst(lhs, rhs, lhs->getName() + "!=" + rhs->getName());
      }
    }
  }
  return res;
}

/*
 * @brief: visit lAndexp
 * @details:
 *    lAndExp: eqExp (AND eqExp)*
 */
std::any SysYIRGenerator::visitLAndExp(SysYParser::LAndExpContext* ctx) {
  cout << "visitLAndExp" << endl;
  auto currentBlock = builder.getBasicBlock();
  // auto trueBlock = currentBlock->getParent()->addBasicBlock("trueland" + std::to_string(++trueBlockNum));
  auto falseBlock = currentBlock->getParent()->addBasicBlock("falseland" + std::to_string(++falseBlockNum));
  Value* value = any_cast<Value*>(ctx->eqExp(0)->accept(this));
  auto trueBlock = currentBlock;
  for(size_t i = 1; i < ctx->eqExp().size(); i++){
    trueBlock = trueBlock->getParent()->addBasicBlock("trueland" + std::to_string(++trueBlockNum));
    builder.createCondBrInst(value, currentBlock, falseBlock, {}, {});
    builder.setPosition(trueBlock, trueBlock->end());
    value = any_cast<Value*>(ctx->eqExp(i)->accept(this));
  }
  //结构trueblk条件跳转到falseblk
  //       - trueBlock1->trueBlock2->trueBlock3->...->trueBlockn->nextblk
  //entry-|
  //       -falseBlock->nextblk
  //需要在最后一个trueblock的末尾加上无条件跳转到下一个基本块的指令
  // builder.createCondBrInst(value, trueBlock, falseBlock, {}, {});
  return std::any();
}

/*
 * @brief: visit lOrexp
 * @details:
 *    lOrExp: lAndExp (OR lAndExp)*
 */
std::any SysYIRGenerator::visitLOrExp(SysYParser::LOrExpContext* ctx) {
  cout << "visitLOrExp" << endl;
  auto currentBlock = builder.getBasicBlock();
  auto trueBlock = currentBlock->getParent()->addBasicBlock("trueland" + std::to_string(++trueBlockNum));
  Value* value = any_cast<Value*>(ctx->lAndExp(0)->accept(this));
  auto falseBlock = currentBlock;
  for(size_t i = 1; i < ctx->lAndExp().size(); i++){
    falseBlock = currentBlock->getParent()->addBasicBlock("falseland" + std::to_string(++falseBlockNum));
    builder.createCondBrInst(value, trueBlock, falseBlock, {}, {});
    builder.setPosition(falseBlock, falseBlock->end());
    value = any_cast<Value*>(ctx->lAndExp(i)->accept(this));
  }
  //结构trueblk条件跳转到falseblk
  //       - falseBlock1->falseBlock2->falseBlock3->...->falseBlockn->nextblk
  //entry-|
  //       -trueBlock->nextblk
  //需要在最后一个falseblock的末尾加上无条件跳转到下一个基本块的指令
  // builder.createCondBrInst(value, trueBlock, falseBlock, {}, {});
  return std::any();
}

/*
 * @brief: visit constexp
 * @details:
 *    constExp: addExp;
 */
std::any SysYIRGenerator::visitConstExp(SysYParser::ConstExpContext* ctx) {
  cout << "visitConstExp" << endl;
  ConstantValue* res = nullptr;
  Value* value = any_cast<Value*>(ctx->addExp()->accept(this));
  if(isa<ConstantValue>(value)){
    res = dyncast<ConstantValue>(value);
  }
  else{
    std::cerr << "error constexp" << ctx->getText() << std::endl;
  }
  return res;
}

/* begin
std::any SysYIRGenerator::visitConstGlobalDecl(SysYParser::ConstDeclContext *ctx, Type* type) {
  std::vector<Value *> values;
  for (auto constDef : ctx->constDef()) {

    auto name = constDef->Ident()->getText();
    // get its dimensions
    vector<Value *> dims;
    for (auto dim : constDef->constExp())
      dims.push_back(any_cast<Value *>(dim->accept(this)));
    
    if (dims.size() == 0) {
      auto init = constDef->ASSIGN() ? any_cast<Value *>((constDef->constInitVal()->constExp()->accept(this)))
                                     : nullptr;
      if (init && isa<ConstantValue>(init)){
        Type *btype = type->as<PointerType>()->getBaseType();
        if (btype->isInt() && init->getType()->isFloat())
          init = ConstantValue::get((int)dynamic_cast<ConstantValue *>(init)->getFloat());
        else if (btype->isFloat() && init->getType()->isInt())
          init = ConstantValue::get((float)dynamic_cast<ConstantValue *>(init)->getInt());
      }

      auto global_value = module->createGlobalValue(name, type, dims, init);
      
      symbols_table.insert(name, global_value);
      values.push_back(global_value);
    }
    else{
      auto init = constDef->ASSIGN() ? any_cast<Value *>(dims[0])
                                     : nullptr;
      auto global_value = module->createGlobalValue(name, type, dims, init);
      if (constDef->ASSIGN()) {
        d = 0;
        n = 0;
        path.clear();
        path = vector<int>(dims.size(), 0);
        isalloca = false;
        current_type = global_value->getType()->as<PointerType>()->getBaseType();
        current_global = global_value;
        numdims = global_value->getNumDims();
        for (auto init : constDef->constInitVal()->constInitVal())
          init->accept(this);  
        // visitConstInitValue(init);
      }
      symbols_table.insert(name, global_value);
      values.push_back(global_value);
    }
  }
  return values;
}

std::any SysYIRGenerator::visitVarGlobalDecl(SysYParser::VarDeclContext *ctx, Type* type){
  std::vector<Value *> values;
  for (auto varDef : ctx->varDef()) {

    auto name = varDef->Ident()->getText();
    // get its dimensions
    vector<Value *> dims;
    for (auto dim : varDef->constExp())
      dims.push_back(any_cast<Value *>(dim->accept(this)));
    
    if (dims.size() == 0) {
      auto init = varDef->ASSIGN() ? any_cast<Value *>((varDef->initVal()->exp()->accept(this)))
                                     : nullptr;
      if (init && isa<ConstantValue>(init)){
        Type *btype = type->as<PointerType>()->getBaseType();
        if (btype->isInt() && init->getType()->isFloat())
          init = ConstantValue::get((int)dynamic_cast<ConstantValue *>(init)->getFloat());
        else if (btype->isFloat() && init->getType()->isInt())
          init = ConstantValue::get((float)dynamic_cast<ConstantValue *>(init)->getInt());
      }

      auto global_value = module->createGlobalValue(name, type, dims, init);
      
      symbols_table.insert(name, global_value);
      values.push_back(global_value);
    }
    else{
      auto init = varDef->ASSIGN() ? any_cast<Value *>(dims[0])
                                     : nullptr;
      auto global_value = module->createGlobalValue(name, type, dims, init);
      if (varDef->ASSIGN()) {
        d = 0;
        n = 0;
        path.clear();
        path = vector<int>(dims.size(), 0);
        isalloca = false;
        current_type = global_value->getType()->as<PointerType>()->getBaseType();
        current_global = global_value;
        numdims = global_value->getNumDims();
        for (auto init : varDef->initVal()->initVal())
          init->accept(this);  
        // visitInitValue(init);
      }
      symbols_table.insert(name, global_value);
      values.push_back(global_value);
    }
  }
  return values;
}

std::any SysYIRGenerator::visitConstLocalDecl(SysYParser::ConstDeclContext *ctx, Type* type){
  std::vector<Value *> values;
    // handle variables
  for (auto constDef : ctx->constDef()) {
    
    auto name = constDef->Ident()->getText();
    vector<Value *> dims;
    for (auto dim : constDef->constExp())
      dims.push_back(any_cast<Value *>(dim->accept(this)));
    auto alloca = builder.createAllocaInst(type, dims, name);
    symbols_table.insert(name, alloca);

    if (constDef->ASSIGN()) {
      if (alloca->getNumDims() == 0) {

        auto value = any_cast<Value *>(constDef->constInitVal()->constExp()->accept(this));
        
        if (isa<ConstantValue>(value)) {
          if (ctx->bType()->INT() && dynamic_cast<ConstantValue *>(value)->isFloat())
            value = ConstantValue::get((int)dynamic_cast<ConstantValue *>(value)->getFloat());
          else if (ctx->bType()->FLOAT() && dynamic_cast<ConstantValue *>(value)->isInt())
            value = ConstantValue::get((float)dynamic_cast<ConstantValue *>(value)->getInt());
        }
        else if (alloca->getType()->as<PointerType>()->getBaseType()->isInt() && value->getType()->isFloat())
          value = builder.createFtoIInst(value);
        else if (alloca->getType()->as<PointerType>()->getBaseType()->isFloat() && value->getType()->isInt())
          value = builder.createIToFInst(value);
        
        auto store = builder.createStoreInst(value, alloca);
      }
      else{
        d = 0;
        n = 0;
        path.clear();
        path = vector<int>(alloca->getNumDims(), 0);
        isalloca = true;
        current_alloca = alloca;
        current_type = alloca->getType()->as<PointerType>()->getBaseType();
        numdims = alloca->getNumDims();
        for (auto init : constDef->constInitVal()->constInitVal())
          init->accept(this);
      }
    }

    values.push_back(alloca);
  }
  return values;
}

std::any SysYIRGenerator::visitVarLocalDecl(SysYParser::VarDeclContext *ctx, Type* type){
  std::vector<Value *> values;
  for (auto varDef : ctx->varDef()) {
    
    auto name = varDef->Ident()->getText();
    vector<Value *> dims;
    for (auto dim : varDef->constExp())
      dims.push_back(any_cast<Value *>(dim->accept(this)));
    auto alloca = builder.createAllocaInst(type, dims, name);
    symbols_table.insert(name, alloca);

    if (varDef->ASSIGN()) {
      if (alloca->getNumDims() == 0) {

        auto value = any_cast<Value *>(varDef->initVal()->exp()->accept(this));
        
        if (isa<ConstantValue>(value)) {
          if (ctx->bType()->INT() && dynamic_cast<ConstantValue *>(value)->isFloat())
            value = ConstantValue::get((int)dynamic_cast<ConstantValue *>(value)->getFloat());
          else if (ctx->bType()->FLOAT() && dynamic_cast<ConstantValue *>(value)->isInt())
            value = ConstantValue::get((float)dynamic_cast<ConstantValue *>(value)->getInt());
        }
        else if (alloca->getType()->as<PointerType>()->getBaseType()->isInt() && value->getType()->isFloat())
          value = builder.createFtoIInst(value);
        else if (alloca->getType()->as<PointerType>()->getBaseType()->isFloat() && value->getType()->isInt())
          value = builder.createIToFInst(value);
        
        auto store = builder.createStoreInst(value, alloca);
      }
      else{
        d = 0;
        n = 0;
        path.clear();
        path = vector<int>(alloca->getNumDims(), 0);
        isalloca = true;
        current_alloca = alloca;
        current_type = alloca->getType()->as<PointerType>()->getBaseType();
        numdims = alloca->getNumDims();
        for (auto init : varDef->initVal()->initVal())
          init->accept(this);
      }
    }
    
    values.push_back(alloca);
  }
  return values;
}
   end
*/

} // namespace sysy