calculator.cpp

#include "calculator.h"
using namespace std;

/*********************************
    HELPERS
*********************************/

double evaluate(string a, string op, string b) {
    double da = stod(a);
    double db = stod(b);

    // cout << qlog("EVALUATE", "Operation: " + a + " " + op + " " + b + '\n');
    // cout << qlog("EVALUATE", "Result: ");

    if (op == "+") return da + db;
    if (op == "-") return da - db;
    if (op == "*") return da * db;
    if (op == "/") return da / db;

    return 1;
}

/*********************************
    LEXER
*********************************/
vector<string> lex(string input) {
    vector<string> tokens;
    string current = "";

    for (char c : input) {
        // digit checking
        if (isdigit(c) || c == '.') current.push_back(c);
        else if (c == ' ') {
            if (current != "") { tokens.push_back(current); current = ""; }
        }
        // operator checking
        else if (c == '+' || c == '-' || c == '*' || c == '/') {
            if (current != "") { tokens.push_back(current); current = ""; }

            current.push_back(c);
            tokens.push_back(current);
            current = "";
        }
        else if (c == '(' || c == ')'){
            if (current != "") { tokens.push_back(current); current = ""; }

            current.push_back(c);
            tokens.push_back(current);
            current = "";
        }
    }

    if (current != "") tokens.push_back(current);

    return tokens;
}

/*********************************
    PARSER
*********************************/
vector<string> parse(vector<string> tokens) {
    vector<string> parsedTokens;

    int i = 0;
    while (i < tokens.size()) {
        if (tokens[i] == "(") {
            int start = i + 1, j = start;
            int count = 1;

            // Find matching paren
            while (j < tokens.size() && count > 0) {
                if (tokens[j] == "(") count++;
                else if (tokens[j] == ")") count--;
                j++;
            }

            vector<string> paranTokens(tokens.begin() + start, tokens.begin() + j - 1);
            string result = to_string(interpret(parse(paranTokens)));
            parsedTokens.push_back(result);
            i = j;
        }
        else {
            parsedTokens.push_back(tokens[i]);
            i++;
        }
    }

    // Now handle multiplication and division with proper precedence
    vector<string> finalTokens;
    i = 0;
    while (i < parsedTokens.size()) {
        if (i + 2 < parsedTokens.size() &&
            (parsedTokens[i + 1] == "*" || parsedTokens[i + 1] == "/")) {
            string left = parsedTokens[i];
            string op = parsedTokens[i + 1];
            string right = parsedTokens[i + 2];

            double result = evaluate(left, op, right);
            finalTokens.push_back(to_string(result));
            i += 3;
        } else {
            finalTokens.push_back(parsedTokens[i]);
            i++;
        }
    }

    return finalTokens;
}

/*********************************
    INTERPRETER
*********************************/
double interpret(vector<string> tokens) {
    double result = stod(tokens[0]);
    int i = 1;

    while (i < tokens.size()) {
        string op = tokens[i];
        string nextNum = tokens[i + 1];

        result = evaluate(to_string(result), op, nextNum);
        i += 2;
    }

    return result;
}

/*********************************
    EVAL
*********************************/
double eval(string input) {
    return interpret(parse(lex(input)));
}