parser.cpp

#include "parser.h"

using namespace std;

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

Node* Parser::parse() {
    Node* left = new Node(tokens[pos++].value);
    pos++; // skip '='
    Node* right = expression();

    Node* root = new Node("=");
    root->left = left;
    root->right = right;

    return root;
}

// 🔥 Constant Folding Helper
Node* fold(Node* node) {
    if (!node) return node;

    if (node->left && node->right) {
        node->left = fold(node->left);
        node->right = fold(node->right);

        // if both are numbers → compute
        if (isdigit(node->left->value[0]) && isdigit(node->right->value[0])) {
            int l = stoi(node->left->value);
            int r = stoi(node->right->value);
            int result;

            if (node->value == "+") result = l + r;
            else if (node->value == "-") result = l - r;
            else if (node->value == "*") result = l * r;
            else if (node->value == "/") result = l / r;

            return new Node(to_string(result));
        }
    }
    return node;
}

Node* Parser::expression() {
    Node* node = term();

    while (tokens[pos].type == PLUS || tokens[pos].type == MINUS) {
        string op = tokens[pos++].value;
        Node* newNode = new Node(op);
        newNode->left = node;
        newNode->right = term();
        node = newNode;
    }

    return fold(node); // 🔥 apply optimization
}

Node* Parser::term() {
    Node* node = factor();

    while (tokens[pos].type == MUL || tokens[pos].type == DIV) {
        string op = tokens[pos++].value;
        Node* newNode = new Node(op);
        newNode->left = node;
        newNode->right = factor();
        node = newNode;
    }

    return node;
}

Node* Parser::factor() {
    return new Node(tokens[pos++].value);
}