TinyExpr.hpp

#ifndef TINYEXPR_HPP
#define TINYEXPR_HPP

#define TINYEXPR_VERSION_MAJOR 0
#define TINYEXPR_VERSION_MINOR 1
#define TINYEXPR_VERSION_PATCH 0
#define TINYEXPR_VERSION "0.1.0"

#include <cstdint>
#include <string>
#include <vector>
#include <map>
#include <cctype>
#include <stdexcept>

namespace tinyexpr {

template<typename T>
class TinyExprT {
public:
    using Type = T;
    using Vars = std::map<std::string, T>;

    T evaluate(const std::string& expression, const Vars& vars) {
        tokens = tokenize(expression);
        pos = 0;
        this->vars = vars;
        return parseTernary();
    }

private:
    enum class TokenType {
        Number, Variable, Plus, Minus, Mul, Div, 
        And, Or, Xor, Tilde, Not, Shl, Shr,
        LogicalAnd, LogicalOr,
        Question, Colon, Eq, Ne, Lt, Gt, Le, Ge, LParen, RParen, End
    };

    struct Token { TokenType type; std::string value; };
    std::vector<Token> tokens;
    size_t pos;
    Vars vars;

    std::vector<Token> tokenize(const std::string& str) {
        std::vector<Token> res;

        // helper to push tokens in a C++11-safe way
        auto push = [&](TokenType t, const std::string &v) {
            res.push_back(Token{t, v});
        };

        for (size_t i = 0; i < str.length(); ++i) {
            char c = str[i];
            if (std::isspace(static_cast<unsigned char>(c))) continue;

            if (std::isdigit(static_cast<unsigned char>(c))) {
                std::string s;
                if (c == '0' && i + 1 < str.length() && (std::tolower(str[i+1]) == 'x')) {
                    s += str[i++]; s += str[i++];
                    while (i < str.length() && std::isxdigit(static_cast<unsigned char>(str[i]))) s += str[i++];
                } else {
                    while (i < str.length() && std::isdigit(static_cast<unsigned char>(str[i]))) s += str[i++];
                }
                push(TokenType::Number, s);
                --i;
                continue;
            }

            if (std::isalpha(static_cast<unsigned char>(c)) || c == '_' || c == '$') {
                std::string s; s += c; ++i;
                while (i < str.length() && (std::isalnum(static_cast<unsigned char>(str[i])) || str[i] == '_' || str[i] == '$')) s += str[i++];
                push(TokenType::Variable, s);
                --i;
                continue;
            }

            // two-char operators
            if (c == '<' && i + 1 < str.length() && str[i+1] == '<') { push(TokenType::Shl, "<<"); ++i; continue; }
            if (c == '>' && i + 1 < str.length() && str[i+1] == '>') { push(TokenType::Shr, ">>"); ++i; continue; }
            if (c == '<' && i + 1 < str.length() && str[i+1] == '=') { push(TokenType::Le, "<="); ++i; continue; }
            if (c == '>' && i + 1 < str.length() && str[i+1] == '=') { push(TokenType::Ge, ">="); ++i; continue; }
            if (c == '=' && i + 1 < str.length() && str[i+1] == '=') { push(TokenType::Eq, "=="); ++i; continue; }
            if (c == '!' && i + 1 < str.length() && str[i+1] == '=') { push(TokenType::Ne, "!="); ++i; continue; }
            if (c == '&' && i + 1 < str.length() && str[i+1] == '&') { push(TokenType::LogicalAnd, "&&"); ++i; continue; }
            if (c == '|' && i + 1 < str.length() && str[i+1] == '|') { push(TokenType::LogicalOr, "||"); ++i; continue; }

            // single-char operators
            switch (c) {
                case '!': push(TokenType::Not, "!"); break;
                case '+': push(TokenType::Plus, "+"); break;
                case '-': push(TokenType::Minus, "-"); break;
                case '*': push(TokenType::Mul, "*"); break;
                case '/': push(TokenType::Div, "/"); break;
                case '&': push(TokenType::And, "&"); break;
                case '|': push(TokenType::Or, "|"); break;
                case '^': push(TokenType::Xor, "^"); break;
                case '~': push(TokenType::Tilde, "~"); break;
                case '?': push(TokenType::Question, "?"); break;
                case ':': push(TokenType::Colon, ":"); break;
                case '<': push(TokenType::Lt, "<"); break;
                case '>': push(TokenType::Gt, ">"); break;
                case '(': push(TokenType::LParen, "("); break;
                case ')': push(TokenType::RParen, ")"); break;
                default: throw std::runtime_error("Unknown char: " + std::string(1, c));
            }
        }
        push(TokenType::End, "");
        return res;
    }

    T parseTernary() {
        T cond = parseLogicalOr();
        if (tokens[pos].type == TokenType::Question) {
            pos++;
            T trueVal = parseTernary();
            if (tokens[pos++].type != TokenType::Colon) throw std::runtime_error("Expected ':'");
            T falseVal = parseTernary();
            return cond ? trueVal : falseVal;
        }
        return cond;
    }

    // Logical OR (||)
    T parseLogicalOr() {
        T res = parseLogicalAnd();
        while (tokens[pos].type == TokenType::LogicalOr) {
            if (res != 0) {
                // short-circuit: consume RHS without evaluating
                pos++; skipLogicalAnd();
                res = 1;
            } else {
                pos++; T right = parseLogicalAnd();
                res = (right != 0) ? 1 : 0;
            }
        }
        return res;
    }

    // Logical AND (&&)
    T parseLogicalAnd() {
        T res = parseBitOr();
        while (tokens[pos].type == TokenType::LogicalAnd) {
            if (res == 0) {
                // short-circuit: consume RHS without evaluating
                pos++; skipBitOr();
                res = 0;
            } else {
                pos++; T right = parseBitOr();
                res = (right != 0) ? 1 : 0;
            }
        }
        return res;
    }

    T parseBitOr() {
        T res = parseBitXor();
        while (tokens[pos].type == TokenType::Or) { pos++; res |= parseBitXor(); }
        return res;
    }

    // --- Skipping helpers: consume tokens for an expression without evaluating ---
    void skipPrimary() {
        Token t = tokens[pos++];
        if (t.type == TokenType::LParen) {
            skipTernary();
            if (tokens[pos++].type != TokenType::RParen) throw std::runtime_error("Missing ')'");
        }
        // Number or Variable are consumed already; nothing else to do
    }

    void skipUnary() {
        if (tokens[pos].type == TokenType::Minus || tokens[pos].type == TokenType::Tilde || tokens[pos].type == TokenType::Not) {
            pos++; skipUnary();
        } else skipPrimary();
    }

    void skipMultiplicative() {
        skipUnary();
        while (tokens[pos].type == TokenType::Mul || tokens[pos].type == TokenType::Div) {
            pos++; skipUnary();
        }
    }

    void skipAdditive() {
        skipMultiplicative();
        while (tokens[pos].type == TokenType::Plus || tokens[pos].type == TokenType::Minus) {
            pos++; skipMultiplicative();
        }
    }

    void skipShift() {
        skipAdditive();
        while (tokens[pos].type == TokenType::Shl || tokens[pos].type == TokenType::Shr) {
            pos++; skipAdditive();
        }
    }

    void skipRelational() {
        skipShift();
        while (tokens[pos].type == TokenType::Lt || tokens[pos].type == TokenType::Gt || tokens[pos].type == TokenType::Le || tokens[pos].type == TokenType::Ge) {
            pos++; skipShift();
        }
    }

    void skipEquality() {
        skipRelational();
        while (tokens[pos].type == TokenType::Eq || tokens[pos].type == TokenType::Ne) {
            pos++; skipRelational();
        }
    }

    void skipBitAnd() { skipEquality(); while (tokens[pos].type == TokenType::And) { pos++; skipEquality(); } }
    void skipBitXor() { skipBitAnd(); while (tokens[pos].type == TokenType::Xor) { pos++; skipBitAnd(); } }
    void skipBitOr()  { skipBitXor(); while (tokens[pos].type == TokenType::Or) { pos++; skipBitXor(); } }

    void skipLogicalAnd() { skipBitOr(); while (tokens[pos].type == TokenType::LogicalAnd) { pos++; skipBitOr(); } }
    void skipLogicalOr()  { skipLogicalAnd(); while (tokens[pos].type == TokenType::LogicalOr) { pos++; skipLogicalAnd(); } }

    void skipTernary() {
        skipLogicalOr();
        if (tokens[pos].type == TokenType::Question) {
            pos++; skipTernary();
            if (tokens[pos++].type != TokenType::Colon) throw std::runtime_error("Expected ':'");
            skipTernary();
        }
    }

    T parseBitXor() {
        T res = parseBitAnd();
        while (tokens[pos].type == TokenType::Xor) { pos++; res ^= parseBitAnd(); }
        return res;
    }

    T parseBitAnd() {
        T res = parseEquality();
        while (tokens[pos].type == TokenType::And) { pos++; res &= parseEquality(); }
        return res;
    }

    T parseEquality() {
        T res = parseRelational();
        while (tokens[pos].type == TokenType::Eq || tokens[pos].type == TokenType::Ne) {
            TokenType op = tokens[pos++].type;
            T right = parseRelational();
            res = (op == TokenType::Eq) ? (res == right) : (res != right);
        }
        return res;
    }

    T parseRelational() {
        T res = parseShift();
        while (tokens[pos].type == TokenType::Lt || tokens[pos].type == TokenType::Gt ||
               tokens[pos].type == TokenType::Le || tokens[pos].type == TokenType::Ge) {
            TokenType op = tokens[pos++].type;
            T    right = parseShift();
            if (op == TokenType::Lt) res = (res < right);
            else if (op == TokenType::Gt) res = (res > right);
            else if (op == TokenType::Le) res = (res <= right);
            else res = (res >= right);
        }
        return res;
    }

    T parseShift() {
        T res = parseAdditive();
        while (tokens[pos].type == TokenType::Shl || tokens[pos].type == TokenType::Shr) {
            TokenType op = tokens[pos++].type;
            T right = parseAdditive();
            if (op == TokenType::Shl) res <<= right; else res >>= right;
        }
        return res;
    }

    T parseAdditive() {
        T res = parseMultiplicative();
        while (tokens[pos].type == TokenType::Plus || tokens[pos].type == TokenType::Minus) {
            TokenType op = tokens[pos++].type;
            T right = parseMultiplicative();
            if (op == TokenType::Plus) res += right; else res -= right;
        }
        return res;
    }

    T parseMultiplicative() {
        T res = parseUnary();
        while (tokens[pos].type == TokenType::Mul || tokens[pos].type == TokenType::Div) {
            TokenType op = tokens[pos++].type;
            T right = parseUnary();
            if (op == TokenType::Mul) res *= right;
            else { if (right == 0) throw std::runtime_error("Div by zero"); res /= right; }
        }
        return res;
    }

    T parseUnary() {
        if (tokens[pos].type == TokenType::Minus) { pos++; return -parseUnary(); }
        if (tokens[pos].type == TokenType::Tilde) { pos++; return ~parseUnary(); }
        if (tokens[pos].type == TokenType::Not)   { pos++; return parseUnary() == 0 ? 1 : 0; }
        return parsePrimary();
    }

    T parsePrimary() {
        Token t = tokens[pos++];
        if (t.type == TokenType::Number) {
            try {
                unsigned long long v = std::stoull(t.value, nullptr, 0);
                return static_cast<T>(v);
            } catch (const std::exception &e) {
                throw std::runtime_error(std::string("Number parse error: ") + e.what());
            }
        }
        if (t.type == TokenType::Variable) {
            if (vars.find(t.value) == vars.end()) throw std::runtime_error(std::string("Undefined variable: ") + t.value);
            return vars.at(t.value);
        }
        if (t.type == TokenType::LParen) {
            T res = parseTernary();
            if (tokens[pos++].type != TokenType::RParen) throw std::runtime_error("Missing ')'");
            return res;
        }
        throw std::runtime_error("Unexpected token: " + t.value);
    }

};

using TinyExpr64 = TinyExprT<int64_t>;
using TinyExpr32 = TinyExprT<int32_t>;
using TinyExpr16 = TinyExprT<int16_t>;
using TinyExpr8  = TinyExprT<int8_t>;

using TinyExpr = TinyExpr64;        // default 64-bit evaluator

using value64 = TinyExpr64::Type;   // int64_t
using vars64  = TinyExpr64::Vars;   // std::map<std::string, int64_t>

using value32 = TinyExpr32::Type;   // int32_t
using vars32  = TinyExpr32::Vars;   // std::map<std::string, int32_t>

using value16 = TinyExpr16::Type;   // int16_t
using vars16  = TinyExpr16::Vars;   // std::map<std::string, int16_t>

using value8 = TinyExpr8::Type;     // int8_t
using vars8  = TinyExpr8::Vars;     // std::map<std::string, int8_t>

// Convenience aliases for the default (64-bit) evaluator
using value = value64;   // int64_t
using vars  = vars64;    // std::map<std::string, int64_t>

} // namespace tinyexpr

#endif