Home /Modules/impl/wide_integer.h

wide_integer.h

impl/frontend/wide_integer.h · 170 line(s) · c

#ifndef SLEELA_WIDE_INTEGER_H
#define SLEELA_WIDE_INTEGER_H

#include <cstddef>
#include <string>

namespace sleela {

/*
 * SignedWideInteger -- recognizer for the base-2 series of named *signed*
 * integer primitive type names (syntax 2.7):
 *
 *     int32  int64  int128  int256  int512  int1024  ...  int16777216
 *
 * The family is the type name "int" immediately followed by a decimal bit
 * width that is a power of two in the inclusive range 2^5 (32) .. 2^24
 * (16777216) -- the full binary base-2 series of widths: 32, 64, 128, 256,
 * 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288,
 * 1048576, 2097152, 4194304, 8388608, 16777216 (twenty widths, 2^5..2^24).
 *
 * These names are NOT lexer keywords: like the arbitrary-width unsigned
 * `U<width>` family (see unsigned_integer.h) they lex as ordinary identifiers
 * and are recognized here by the front end wherever a primitive type may
 * appear. Two series members, `int64` and `int128`, are ALSO spelled as lexer
 * keywords for source convenience (and `int`/`long` are 64-bit too); the
 * keyword and pattern paths are deliberately kept consistent -- a width is
 * routed to the same runtime backing however it was spelled.
 *
 * RUNTIME BACKING. The native VM carries each value in the narrowest native
 * integer slot that holds its declared width:
 *   - widths <= 64 bits  (int32, int64)       -> SL_INT    (64-bit int64_t)
 *   - widths >= 128 bits (int128 .. 2^24)      -> SL_INT128 (true 128-bit
 *                                                 __int128 on GCC/Clang)
 * Arithmetic exact up to 128 bits today; true arbitrary-width arithmetic beyond
 * 128 bits is a documented follow-up. The compiler and VM accept and handle
 * every member so declarations, stores, parameters, returns, casts and arrays
 * all work across the whole series.
 */
class SignedWideInteger {
public:
    // Smallest and largest declared bit widths of the series (powers of two).
    static constexpr std::size_t kMinimumWidth = 32;         // 2^5
    static constexpr std::size_t kMaximumWidth = 16777216;   // 2^24
    // Widths at or below this ride the 64-bit native slot; wider values use the
    // 128-bit slot. (Matches the VM's SL_INT / SL_INT128 split.)
    static constexpr std::size_t kNativeNarrowWidth = 64;

    // True when `name` is exactly "int" + <decimal width>, the width is a power
    // of two, and kMinimumWidth <= width <= kMaximumWidth.
    static bool isValidTypeName(const std::string& name) noexcept {
        return widthOf(name) != 0;
    }

    // Parse the declared bit width out of a valid name (0 when `name` is not a
    // member of the series). Useful for callers that need the width directly.
    static std::size_t widthOf(const std::string& name) noexcept {
        std::size_t width = 0;
        if (!parseWidth(name, width)) return 0;
        if (width < kMinimumWidth || width > kMaximumWidth || !isPowerOfTwo(width)) return 0;
        return width;
    }

    // True when a valid family member fits the VM's 64-bit native integer slot
    // (int32, int64). Wider members (int128 and up) use the 128-bit slot.
    static bool fitsNativeNarrow(const std::string& name) noexcept {
        const std::size_t w = widthOf(name);
        return w != 0 && w <= kNativeNarrowWidth;
    }

private:
    // Match "int" followed by a non-empty run of decimal digits with no leading
    // zero. Fills `width` with the decimal value; returns false on any other
    // shape (overflow-guarded against absurd input).
    static bool parseWidth(const std::string& name, std::size_t& width) noexcept {
        const char prefix[] = "int";
        const std::size_t plen = 3;
        if (name.size() <= plen) return false;
        for (std::size_t i = 0; i < plen; ++i)
            if (name[i] != prefix[i]) return false;
        if (name[plen] == '0') return false;  // no leading zero / bare "int0"
        std::size_t w = 0;
        for (std::size_t i = plen; i < name.size(); ++i) {
            const char c = name[i];
            if (c < '0' || c > '9') return false;
            if (w > (kMaximumWidth / 10) + 1) return false;  // overflow guard
            w = w * 10 + static_cast<std::size_t>(c - '0');
        }
        width = w;
        return true;
    }

    static bool isPowerOfTwo(std::size_t n) noexcept {
        return n != 0 && (n & (n - 1)) == 0;
    }
};

/*
 * UnsignedWideInteger -- recognizer for the base-2 series of named *unsigned*
 * (positive-only) integer primitive type names (syntax 2.8):
 *
 *     uint32  uint64  uint128  uint256  uint512  uint1024  ...  uint16777216
 *
 * The exact unsigned mirror of SignedWideInteger: the type name "uint"
 * immediately followed by a decimal bit width that is a power of two in the
 * inclusive range 2^5 (32) .. 2^24 (16777216) -- the same twenty widths. The
 * names lex as ordinary identifiers (no keyword spelling) and are recognized by
 * the front end wherever a primitive type may appear.
 *
 * POSITIVE-ONLY semantics. A uint<width> value type-checks as the unsigned kind
 * (Kind::Unsigned), so unary minus is rejected and arithmetic / comparison
 * require operands of the same unsigned width -- the same positive-only,
 * width-strict discipline as the arbitrary-width U<width> family.
 *
 * RUNTIME BACKING. Identical to the signed series: widths <= 64 (uint32,
 * uint64) ride the 64-bit native slot (SL_INT); widths >= 128 (uint128 and up)
 * ride the 128-bit slot (SL_INT128, true __int128 on GCC/Clang). Exact up to
 * 128 bits; true arbitrary-width arithmetic beyond 128 bits is a documented
 * follow-up.
 */
class UnsignedWideInteger {
public:
    static constexpr std::size_t kMinimumWidth = 32;         // 2^5
    static constexpr std::size_t kMaximumWidth = 16777216;   // 2^24
    static constexpr std::size_t kNativeNarrowWidth = 64;

    static bool isValidTypeName(const std::string& name) noexcept {
        return widthOf(name) != 0;
    }

    static std::size_t widthOf(const std::string& name) noexcept {
        std::size_t width = 0;
        if (!parseWidth(name, width)) return 0;
        if (width < kMinimumWidth || width > kMaximumWidth || !isPowerOfTwo(width)) return 0;
        return width;
    }

    static bool fitsNativeNarrow(const std::string& name) noexcept {
        const std::size_t w = widthOf(name);
        return w != 0 && w <= kNativeNarrowWidth;
    }

private:
    // Match "uint" followed by a non-empty run of decimal digits (no leading
    // zero). Fills `width`; returns false on any other shape (overflow-guarded).
    static bool parseWidth(const std::string& name, std::size_t& width) noexcept {
        const char prefix[] = "uint";
        const std::size_t plen = 4;
        if (name.size() <= plen) return false;
        for (std::size_t i = 0; i < plen; ++i)
            if (name[i] != prefix[i]) return false;
        if (name[plen] == '0') return false;  // no leading zero / bare "uint0"
        std::size_t w = 0;
        for (std::size_t i = plen; i < name.size(); ++i) {
            const char c = name[i];
            if (c < '0' || c > '9') return false;
            if (w > (kMaximumWidth / 10) + 1) return false;  // overflow guard
            w = w * 10 + static_cast<std::size_t>(c - '0');
        }
        width = w;
        return true;
    }

    static bool isPowerOfTwo(std::size_t n) noexcept {
        return n != 0 && (n & (n - 1)) == 0;
    }
};

}  // namespace sleela
#endif  // SLEELA_WIDE_INTEGER_H