// compile_time_calc.hpp — reference implementation of the constexpr calculator
// C++20/23, single-header.  Drop it into a project and `#include`.

#ifndef COMPILE_TIME_CALC_HPP
#define COMPILE_TIME_CALC_HPP

#include <string_view>
#include <optional>
#include <limits>
#include <cstddef>
#include <type_traits>

//---------------------------------------------------------------------
// 1.  NTTP-строка как тип
//---------------------------------------------------------------------

template<char... Cs>
struct lit {
    static constexpr char str[sizeof...(Cs) + 1]{ Cs..., '\0' };
};

// пользовательский литерал       "42*(3+1)"_expr  →  объект типа lit<'4','2','*', ...>

template<typename CharT, CharT... Cs>
consteval auto operator"" _expr() {
    static_assert(std::is_same_v<CharT, char>, "_expr supports only narrow char literals");
    return lit<Cs...>{};
}

//---------------------------------------------------------------------
// 2.  Проверка переполнения для пяти базовых операций
//---------------------------------------------------------------------

constexpr unsigned long long MAX = std::numeric_limits<unsigned long long>::max();

constexpr std::optional<unsigned long long> add(unsigned long long a, unsigned long long b) {
    return (a > MAX - b) ? std::nullopt : std::optional{ a + b };
}
constexpr std::optional<unsigned long long> sub(unsigned long long a, unsigned long long b) {
    return (a < b) ? std::nullopt : std::optional{ a - b };
}
constexpr std::optional<unsigned long long> mul(unsigned long long a, unsigned long long b) {
    return (b != 0 && a > MAX / b) ? std::nullopt : std::optional{ a * b };
}
constexpr std::optional<unsigned long long> div(unsigned long long a, unsigned long long b) {
    return (b == 0) ? std::nullopt : std::optional{ a / b };
}
constexpr std::optional<unsigned long long> mod(unsigned long long a, unsigned long long b) {
    return (b == 0) ? std::nullopt : std::optional{ a % b };
}

//---------------------------------------------------------------------
// 3.  Рекурсивный парсер-оценщик
//---------------------------------------------------------------------

struct parser {
    std::string_view s;
    std::size_t pos = 0;

    constexpr bool eof() const { return pos >= s.size(); }
    constexpr char peek() const { return eof() ? '\0' : s[pos]; }
    constexpr void skip_ws() {
        while (!eof() && (peek() == ' ' || peek() == '\t' || peek() == '\n')) ++pos;
    }
    constexpr bool consume(char c) {
        skip_ws();
        if (peek() == c) { ++pos; return true; }
        return false;
    }

    // number := [0-9]+
    constexpr std::optional<unsigned long long> number() {
        skip_ws();
        if (peek() < '0' || peek() > '9') return std::nullopt;
        unsigned long long v = 0;
        while (!eof() && peek() >= '0' && peek() <= '9') {
            int digit = peek() - '0';
            if (auto nv = mul(v, 10)) {
                if (auto nv2 = add(*nv, digit)) {
                    v = *nv2;
                } else return std::nullopt;
            } else return std::nullopt;
            ++pos;
        }
        return v;
    }

    // factor := number | '(' expr ')'
    constexpr std::optional<unsigned long long> factor() {
        skip_ws();
        if (consume('(')) {
            auto val = expr();
            if (!val || !consume(')')) return std::nullopt;
            return val;
        }
        return number();
    }

    // term := factor { ('*' | '/' | '%') factor }
    constexpr std::optional<unsigned long long> term() {
        auto lhs = factor();
        if (!lhs) return std::nullopt;
        while (true) {
            skip_ws();
            char op = peek();
            if (op != '*' && op != '/' && op != '%') break;
            ++pos;
            auto rhs = factor();
            if (!rhs) return std::nullopt;
            switch (op) {
            case '*': lhs = mul(*lhs, *rhs); break;
            case '/': lhs = div(*lhs, *rhs); break;
            case '%': lhs = mod(*lhs, *rhs); break;
            }
            if (!lhs) return std::nullopt;
        }
        return lhs;
    }

    // expr := term { ('+' | '-') term }
    constexpr std::optional<unsigned long long> expr() {
        auto lhs = term();
        if (!lhs) return std::nullopt;
        while (true) {
            skip_ws();
            char op = peek();
            if (op != '+' && op != '-') break;
            ++pos;
            auto rhs = term();
            if (!rhs) return std::nullopt;
            switch (op) {
            case '+': lhs = add(*lhs, *rhs); break;
            case '-': lhs = sub(*lhs, *rhs); break;
            }
            if (!lhs) return std::nullopt;
        }
        return lhs;
    }
};

//---------------------------------------------------------------------
// 4.  Вспомогательный meta-проход: lit<Cs...> → optional<ULL>
//---------------------------------------------------------------------

template<char... Cs>
consteval std::optional<unsigned long long> eval_impl() {
    constexpr std::string_view sv{ lit<Cs...>::str, sizeof...(Cs) }; // без NUL
    parser p{ sv };
    auto val = p.expr();
    p.skip_ws();
    return (!val || !p.eof()) ? std::nullopt : val;
}

// превращаем объект lit<...> в мета-информацию

template<typename T>
struct parsed;                       // общая шаблонная декларация

template<char... Cs>
struct parsed<lit<Cs...>> {
    static constexpr auto opt = eval_impl<Cs...>();
    static constexpr bool ok  = opt.has_value();
    static constexpr unsigned long long value = *opt; // ОК использовать, только если ok == true
};

//---------------------------------------------------------------------
// 5.  Концепты и основной шаблон calc
//---------------------------------------------------------------------

template<auto Lit>
concept ValidExpr = parsed<decltype(Lit)>::ok;

template<auto Lit>
requires ValidExpr<Lit>
struct calc {
    static constexpr unsigned long long value = parsed<decltype(Lit)>::value;
    constexpr operator unsigned long long() const { return value; }
};

//---------------------------------------------------------------------
// 6.  Утилита-alias для SFINAE-френдли value-типа
//---------------------------------------------------------------------

template<auto Lit>
using calc_v = std::integral_constant<unsigned long long, calc<Lit>::value>;


#endif // COMPILE_TIME_CALC_HPP


int main(int argc, const char * argv[]) {
    static_assert(calc<"42 * (10 - 8)"_expr>::value == 84);
    static_assert(ValidExpr<"((7+5)*3)"_expr>);
}

template<auto Lit>
requires ValidExpr<Lit>
using calc_v = std::integral_constant<unsigned long long, calc<Lit>::value>;

static_assert(std::string("Hello World!").size() == 12);
static_assert(std::string("Hello World!")[0] == 'H');
static_assert(std::string("Hello World!")[6] == 'W');
static_assert(std::string("Hello World!")[11] == '!');

// "Моковая" реализация calc,
// демонстрирующая возмость работы с объектами std::string в компайл-тайм.
constexpr auto calc(const std::string& s) {return s.size() * 1000;} 

static_assert(calc("80 * 100") == 8000);

S>// compile_time_calc.hpp — reference implementation of the constexpr calculator
S>// C++20/23, single-header.  Drop it into a project and `#include`.

S>#ifndef COMPILE_TIME_CALC_HPP
S>#define COMPILE_TIME_CALC_HPP

S>#include <string_view>
S>#include <optional>
S>#include <limits>
S>#include <cstddef>
S>#include <type_traits>

S>//---------------------------------------------------------------------
S>// 1.  NTTP-строка как тип
S>//---------------------------------------------------------------------

S>template<char... Cs>
S>struct lit {
S>    static constexpr char str[sizeof...(Cs) + 1]{ Cs..., '\0' };
S>};

S>// пользовательский литерал       "42*(3+1)"_expr  →  объект типа lit<'4','2','*', ...>

S>template<typename CharT, CharT... Cs>
S>consteval auto operator"" _expr() {
S>    static_assert(std::is_same_v<CharT, char>, "_expr supports only narrow char literals");
S>    return lit<Cs...>{};
S>}

S>//---------------------------------------------------------------------
S>// 2.  Проверка переполнения для пяти базовых операций
S>//---------------------------------------------------------------------

S>constexpr unsigned long long MAX = std::numeric_limits<unsigned long long>::max();

S>constexpr std::optional<unsigned long long> add(unsigned long long a, unsigned long long b) {
S>    return (a > MAX - b) ? std::nullopt : std::optional{ a + b };
S>}
S>constexpr std::optional<unsigned long long> sub(unsigned long long a, unsigned long long b) {
S>    return (a < b) ? std::nullopt : std::optional{ a - b };
S>}
S>constexpr std::optional<unsigned long long> mul(unsigned long long a, unsigned long long b) {
S>    return (b != 0 && a > MAX / b) ? std::nullopt : std::optional{ a * b };
S>}
S>constexpr std::optional<unsigned long long> div(unsigned long long a, unsigned long long b) {
S>    return (b == 0) ? std::nullopt : std::optional{ a / b };
S>}
S>constexpr std::optional<unsigned long long> mod(unsigned long long a, unsigned long long b) {
S>    return (b == 0) ? std::nullopt : std::optional{ a % b };
S>}

S>//---------------------------------------------------------------------
S>// 3.  Рекурсивный парсер-оценщик
S>//---------------------------------------------------------------------

S>struct parser {
S>    std::string_view s;
S>    std::size_t pos = 0;

S>    constexpr bool eof() const { return pos >= s.size(); }
S>    constexpr char peek() const { return eof() ? '\0' : s[pos]; }
S>    constexpr void skip_ws() {
S>        while (!eof() && (peek() == ' ' || peek() == '\t' || peek() == '\n')) ++pos;
S>    }
S>    constexpr bool consume(char c) {
S>        skip_ws();
S>        if (peek() == c) { ++pos; return true; }
S>        return false;
S>    }

S>    // number := [0-9]+
S>    constexpr std::optional<unsigned long long> number() {
S>        skip_ws();
S>        if (peek() < '0' || peek() > '9') return std::nullopt;
S>        unsigned long long v = 0;
S>        while (!eof() && peek() >= '0' && peek() <= '9') {
S>            int digit = peek() - '0';
S>            if (auto nv = mul(v, 10)) {
S>                if (auto nv2 = add(*nv, digit)) {
S>                    v = *nv2;
S>                } else return std::nullopt;
S>            } else return std::nullopt;
S>            ++pos;
S>        }
S>        return v;
S>    }

S>    // factor := number | '(' expr ')'
S>    constexpr std::optional<unsigned long long> factor() {
S>        skip_ws();
S>        if (consume('(')) {
S>            auto val = expr();
S>            if (!val || !consume(')')) return std::nullopt;
S>            return val;
S>        }
S>        return number();
S>    }

S>    // term := factor { ('*' | '/' | '%') factor }
S>    constexpr std::optional<unsigned long long> term() {
S>        auto lhs = factor();
S>        if (!lhs) return std::nullopt;
S>        while (true) {
S>            skip_ws();
S>            char op = peek();
S>            if (op != '*' && op != '/' && op != '%') break;
S>            ++pos;
S>            auto rhs = factor();
S>            if (!rhs) return std::nullopt;
S>            switch (op) {
S>            case '*': lhs = mul(*lhs, *rhs); break;
S>            case '/': lhs = div(*lhs, *rhs); break;
S>            case '%': lhs = mod(*lhs, *rhs); break;
S>            }
S>            if (!lhs) return std::nullopt;
S>        }
S>        return lhs;
S>    }

S>    // expr := term { ('+' | '-') term }
S>    constexpr std::optional<unsigned long long> expr() {
S>        auto lhs = term();
S>        if (!lhs) return std::nullopt;
S>        while (true) {
S>            skip_ws();
S>            char op = peek();
S>            if (op != '+' && op != '-') break;
S>            ++pos;
S>            auto rhs = term();
S>            if (!rhs) return std::nullopt;
S>            switch (op) {
S>            case '+': lhs = add(*lhs, *rhs); break;
S>            case '-': lhs = sub(*lhs, *rhs); break;
S>            }
S>            if (!lhs) return std::nullopt;
S>        }
S>        return lhs;
S>    }
S>};

S>//---------------------------------------------------------------------
S>// 4.  Вспомогательный meta-проход: lit<Cs...> → optional<ULL>
S>//---------------------------------------------------------------------

S>template<char... Cs>
S>consteval std::optional<unsigned long long> eval_impl() {
S>    constexpr std::string_view sv{ lit<Cs...>::str, sizeof...(Cs) }; // без NUL
S>    parser p{ sv };
S>    auto val = p.expr();
S>    p.skip_ws();
S>    return (!val || !p.eof()) ? std::nullopt : val;
S>}

S>// превращаем объект lit<...> в мета-информацию

S>template<typename T>
S>struct parsed;                       // общая шаблонная декларация

S>template<char... Cs>
S>struct parsed<lit<Cs...>> {
S>    static constexpr auto opt = eval_impl<Cs...>();
S>    static constexpr bool ok  = opt.has_value();
S>    static constexpr unsigned long long value = *opt; // ОК использовать, только если ok == true
S>};

S>//---------------------------------------------------------------------
S>// 5.  Концепты и основной шаблон calc
S>//---------------------------------------------------------------------

S>template<auto Lit>
S>concept ValidExpr = parsed<decltype(Lit)>::ok;

S>template<auto Lit>
S>requires ValidExpr<Lit>
S>struct calc {
S>    static constexpr unsigned long long value = parsed<decltype(Lit)>::value;
S>    constexpr operator unsigned long long() const { return value; }
S>};

S>//---------------------------------------------------------------------
S>// 6.  Утилита-alias для SFINAE-френдли value-типа
S>//---------------------------------------------------------------------

S>template<auto Lit>
S>using calc_v = std::integral_constant<unsigned long long, calc<Lit>::value>;


S>#endif // COMPILE_TIME_CALC_HPP


S>int main(int argc, const char * argv[]) {
S>    static_assert(calc<"42 * (10 - 8)"_expr>::value == 84);
S>    static_assert(ValidExpr<"((7+5)*3)"_expr>);
S>}

S>

int main(int argc, const char * argv[]) {
    static_assert(42 * (10 - 8)) == 84);

 //а это вообще в компиляторе по умолчанию проверится.
    // static_assert(ValidExpr<"((7+5)*3)"_expr>);
}

S>

#embed "https://rsdn.org/account/info/2511"

int main(int argc, const char * argv[]) {
    static_assert(ValidExpr<"
#embed "формула"
    "_expr>);
}

const char* data[] = {
    #include "prepared.inc"
};

MQ>int main(int argc, const char * argv[]) {
MQ>    static_assert(ValidExpr<"
MQ>#embed "формула"
MQ>    "_expr>);
MQ>}
MQ>

int main(int argc, const char * argv[]) {
  static_assert( // ValidExpr
#include "формула"
);

  static_assert(
#include "формула"
  == 84
);