parser.cpp

#include "parser.h"

int VariableNode::jump_counter = 1;
map<string,int> VariableNode::ast_value;
int VariableNode::counter = 1;

NumberNode::NumberNode(int val):val(val){};

void NumberNode::generateCode(ostream& output){
    output<<"\tldi A "<<val<<endl;
}


void NumberNode::generateL(ostream& output){
    output<<"\tldi A "<<val<<endl;
}

void NumberNode::generateR(ostream& output){
    output<<"\tldi B "<<val<<endl;
}

VariableNode::VariableNode(string name):name(name){
    if(ast_value.find(name)== ast_value.end()) ast_value[name]=counter++;
    id = ast_value[name];
}

void VariableNode::generateCode(ostream& output){
    output<<"\tmov M A "<<ast_value[name]<<endl;
}

void VariableNode::generateL(ostream& output){
    output<<"\tmov A M "<<ast_value[name]<<endl;
}

void VariableNode::generateR(ostream& output){
    output<<"\tmov B M "<< ast_value[name]<<endl;
}

BinaryOpNode::BinaryOpNode(shared_ptr<ASTNode> l, char op , shared_ptr<ASTNode> r)
:l(l),op(op),r(r){}

void BinaryOpNode::generateCode(ostream& output){
    l->generateL(output);
    r->generateR(output);
    switch(op){
        case '+' : output<<"\tadd"<<endl;break;
        case '-' : output<<"\tsub"<<endl;break;
        case '#' : output<<"\tcmp"<<endl;break;
        default:throw runtime_error("unsupported binary operation");
    }
}


VariableDec::VariableDec(string varN ,shared_ptr<ASTNode> val):varN(varN),val(val){
    if(ast_value.find(varN)==ast_value.end())
        VariableNode::ast_value[varN]=VariableNode::counter++;  
}

void VariableDec::generateCode(ostream& output){
    if(ast_value.find(varN)==ast_value.end()){
        ast_value[varN]=counter++;
    }
    val->generateCode(output);
    output<<"\tmov M A "<<ast_value[varN]<<endl;
}

ConditionalNode::ConditionalNode(shared_ptr<ASTNode> cond , shared_ptr<ASTNode>then_br)
: cond(cond), then_br(then_br) {}

void ConditionalNode::generateCode(ostream& output){
    cond->generateCode(output);
    output<<"\tjnz %then_";
    output<<VariableNode::jump_counter<<endl;

    then_br->generateCode(output);

    output<<endl;
    output<<"then_";
    output<<VariableNode::jump_counter;
    output<<":"<<endl;
    VariableNode::jump_counter++;
}

void BlockNode::addStat(shared_ptr<ASTNode> statement){
    statements.push_back(statement);
}

void BlockNode::generateCode(ostream& output){
    
    for(auto each : statements){
        each->generateCode(output);
    }
}

Parser::Parser(vector<Token>& tokens):tokens(tokens),pos(0){}

shared_ptr<ASTNode> Parser::parse(){
    shared_ptr<BlockNode> bNode = make_shared<BlockNode>();
    while(!isAtEnd()){
        bNode->addStat(parseStat());
    }
    return bNode;
}

shared_ptr<ASTNode> Parser::parseStat(){
    if(match({Tokentype::INT})){
        return parseVarDec();
    }else if(match({Tokentype::IF})){
        return parseCond();
    }else if(match({Tokentype::IDENTIFIER})){
        return parseVarAssign();
    }else{
        return parseExpStat();
    }
}

shared_ptr<ASTNode> Parser::parseVarAssign(){
    string varN = previous().value;

    // Semantic Check
    if (VariableNode::ast_value.find(varN) == VariableNode::ast_value.end()) {
        throw runtime_error(" semeantic error :- variable " + varN + " not declared.");
    }

    consume({Tokentype::ASSIGN},"expect = ");
    shared_ptr<ASTNode> val = parseExp();
    consume({Tokentype::SEMICOLON},"expect ; ");
    return make_shared<VariableDec>(varN,val);
}

shared_ptr<ASTNode> Parser::parseVarDec(){
    consume(Tokentype::IDENTIFIER,"expect Variable");

    if (VariableNode::ast_value.find(previous().value) != VariableNode::ast_value.end()) {
        throw runtime_error("sementic error :- variable " + previous().value + " already declared.");
    }

    string varN = previous().value;

    shared_ptr<ASTNode> val = nullptr;

    if(match({Tokentype::ASSIGN})){
        val=parseExp();
    }else{
        consume(Tokentype::SEMICOLON,"expect ;");
        return make_shared<VariableNode>(varN);
    }

    consume(Tokentype::SEMICOLON,"expect ;");
    return make_shared<VariableDec>(varN,val);
}

shared_ptr<ASTNode> Parser::parseCond()
{
    consume({Tokentype::LPAREN},"expect (");
    shared_ptr<ASTNode> cond1 = parseExp();
    consume({Tokentype::RPAREN},"expect )");
    shared_ptr<ASTNode> then_br1 = parseBlock();
    shared_ptr<ASTNode> else_br1 = nullptr;

    return make_shared<ConditionalNode>(cond1,then_br1);
}

shared_ptr<ASTNode> Parser::parseBlock(){
    if(match({Tokentype::LBRACE})){
        shared_ptr<BlockNode> b = make_shared<BlockNode>();
        
        while(!check(Tokentype::RBRACE) && !isAtEnd()){
            b->addStat(parseStat());
        }   
        consume(Tokentype::RBRACE,"expect }");
        return b;
    }else{
        return parseStat();
    }
}

shared_ptr<ASTNode> Parser::parseExpStat(){
    shared_ptr<ASTNode> exp = parseExp();
    consume(Tokentype::SEMICOLON,"expect ;");
    return exp;
}

shared_ptr<ASTNode> Parser::parseExp(){
    shared_ptr<ASTNode> l = parsePrim();

    while(match({Tokentype::PLUS, Tokentype::MINUS ,Tokentype::EQ})){
        char op = previous().value[0];
        shared_ptr<ASTNode> r = parsePrim();
        l = make_shared<BinaryOpNode>(l,op,r);
    }

    return l ;
}

shared_ptr<ASTNode> Parser::parsePrim(){
    if(match({Tokentype::NUMBER})){
        return make_shared<NumberNode>(stoi(previous().value));
    }else if(match({Tokentype::IDENTIFIER})){
        return make_shared<VariableNode>(previous().value);
    }else if(match({Tokentype::LPAREN})){
        shared_ptr<ASTNode> exp = parseExp();
        consume({Tokentype::RPAREN},"expect )");
        return exp;
    }
    throw runtime_error("unexpected token ");
}

bool Parser::match(vector<Tokentype> types){
    auto it = find_if(types.begin(),types.end(),[&](Tokentype type){ 
        return type == tokens[pos].type;
        });
    if(it!=types.end())
    {
        pos++; 
        return true ;
    }
    return false;
}

bool Parser::isAtEnd()
{
    return pos>= tokens.size() || tokens[pos].type == Tokentype::END;
}

bool Parser::check(Tokentype type)
{
    if(isAtEnd())return false;
    return tokens[pos].type == type ;
}

Token Parser::previous()
{
    return tokens[pos-1];
}

void Parser::advance()
{
    if(!isAtEnd())
    {
    pos++;
    return ;
    }
    cout<<"ran output of tokens"<<pos<<endl;
}
void Parser::consume(Tokentype type , string errorMessage)
{
    if(check(type))
        advance();
    else{
        cout<< errorMessage << '\n' << "found - " <<tokens[pos].value<<endl;
        throw runtime_error("wrong token present");
    }
}