Home /Modules/alphabet/character_runtime.cpp

character_runtime.cpp

lib/alphabet/native/character_runtime.cpp · 113 line(s) · c

#include "character_runtime.hpp"

#include <algorithm>
#include <stdexcept>
#include <utility>

namespace sleela::alphabet {
namespace {
bool scalar(char32_t cp) {
    return cp <= 0x10FFFF && !(cp >= 0xD800 && cp <= 0xDFFF);
}
}

Utf8Result decode_utf8(std::string_view s) {
    Utf8Result out;
    for (std::size_t i = 0; i < s.size();) {
        const auto b0 = static_cast<unsigned char>(s[i]);
        char32_t cp = 0;
        std::size_t n = 0;
        if (b0 <= 0x7F) { cp = b0; n = 1; }
        else if (b0 >= 0xC2 && b0 <= 0xDF) { cp = b0 & 0x1F; n = 2; }
        else if (b0 >= 0xE0 && b0 <= 0xEF) { cp = b0 & 0x0F; n = 3; }
        else if (b0 >= 0xF0 && b0 <= 0xF4) { cp = b0 & 0x07; n = 4; }
        else { out.error = "invalid UTF-8 leading byte"; return out; }
        if (i + n > s.size()) { out.error = "truncated UTF-8 sequence"; return out; }
        for (std::size_t j = 1; j < n; ++j) {
            const auto bx = static_cast<unsigned char>(s[i + j]);
            if ((bx & 0xC0) != 0x80) { out.error = "invalid UTF-8 continuation byte"; return out; }
            cp = static_cast<char32_t>((cp << 6) | (bx & 0x3F));
        }
        if ((n == 2 && cp < 0x80) || (n == 3 && cp < 0x800) ||
            (n == 4 && cp < 0x10000) || !scalar(cp)) {
            out.error = "non-scalar, overlong, or out-of-range UTF-8 sequence"; return out;
        }
        out.codepoints.push_back(cp);
        i += n;
    }
    return out;
}

std::optional<std::string> encode_utf8(char32_t cp) {
    if (!scalar(cp)) return std::nullopt;
    std::string out;
    if (cp <= 0x7F) out.push_back(static_cast<char>(cp));
    else if (cp <= 0x7FF) {
        out.push_back(static_cast<char>(0xC0 | (cp >> 6)));
        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
    } else if (cp <= 0xFFFF) {
        out.push_back(static_cast<char>(0xE0 | (cp >> 12)));
        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
    } else {
        out.push_back(static_cast<char>(0xF0 | (cp >> 18)));
        out.push_back(static_cast<char>(0x80 | ((cp >> 12) & 0x3F)));
        out.push_back(static_cast<char>(0x80 | ((cp >> 6) & 0x3F)));
        out.push_back(static_cast<char>(0x80 | (cp & 0x3F)));
    }
    return out;
}

std::optional<std::size_t> codepoint_count_utf8(std::string_view s) {
    auto decoded = decode_utf8(s);
    if (!decoded) return std::nullopt;
    return decoded.codepoints.size();
}

std::optional<std::size_t> parse_capacity_signature(std::string_view s) {
    if (s.size() < 2 || s[0] != 'C' || s[1] == '0') return std::nullopt;
    std::size_t n = 0;
    for (std::size_t i = 1; i < s.size(); ++i) {
        const char c = s[i];
        if (c < '0' || c > '9') return std::nullopt;
        const auto digit = static_cast<std::size_t>(c - '0');
        if (n > (1048576 - digit) / 10) return std::nullopt;
        n = n * 10 + digit;
    }
    if (n < 1 || n > 1048576) return std::nullopt;
    return n;
}

CharacterSet::CharacterSet(std::size_t capacity) : capacity_(capacity) {
    if (capacity < 1 || capacity > 1048576)
        throw std::invalid_argument("CharacterSet capacity must be 1..1048576");
}
bool CharacterSet::add(std::string symbol, std::string* error) {
    auto decoded = decode_utf8(symbol);
    if (!decoded || decoded.codepoints.empty()) {
        if (error) *error = decoded ? "symbol must not be empty" : decoded.error;
        return false;
    }
    if (std::find(symbols_.begin(), symbols_.end(), symbol) != symbols_.end()) {
        if (error) *error = "duplicate symbol";
        return false;
    }
    if (symbols_.size() >= capacity_) {
        if (error) *error = "character-set capacity exceeded";
        return false;
    }
    symbols_.push_back(std::move(symbol));
    if (error) error->clear();
    return true;
}
bool CharacterSet::contains(std::string_view symbol) const {
    auto decoded = decode_utf8(symbol);
    if (!decoded || decoded.codepoints.empty()) return false;
    return std::find(symbols_.begin(), symbols_.end(), symbol) != symbols_.end();
}
std::size_t CharacterSet::size() const noexcept { return symbols_.size(); }
std::size_t CharacterSet::capacity() const noexcept { return capacity_; }
const std::vector<std::string>& CharacterSet::ordered_symbols() const noexcept { return symbols_; }

} // namespace sleela::alphabet