Review spaceship usage

1 files changed, 232 insertions, 38 deletions

diff --git a/boot/result.cc b/boot/result.cc
index 0eb5c12..f9f57db 100644
--- a/boot/result.cc
+++ b/boot/result.cc
@@ -91,22 +91,9 @@ namespace elna::boot
         return this->m_position;
     }
 
-    std::strong_ordering identifier::operator<=>(const identifier& that) const
+    bool identifier::operator==(const identifier& that) const
     {
-        auto comparison = this->m_name.compare(that.name());
-
-        if (comparison < 0)
-        {
-            return std::strong_ordering::less;
-        }
-        else if (comparison > 0)
-        {
-            return std::strong_ordering::greater;
-        }
-        else
-        {
-            return std::strong_ordering::equal;
-        }
+        return this->m_name == that;
     }
 
     bool identifier::operator==(std::string_view that) const
@@ -114,11 +101,6 @@ namespace elna::boot
         return this->m_name == that;
     }
 
-    bool identifier::operator!=(std::string_view that) const
-    {
-        return !(*this == that);
-    }
-
     identifier_definition::identifier_definition(const std::string& name,
             const source_position& position, const bool exported)
         : m_identifier(name, position), m_exported(exported)
@@ -140,6 +122,231 @@ namespace elna::boot
         return this->m_exported;
     }
 
+    integer_literal::integer_literal(bool is_signed, std::size_t size)
+        : m_signed(is_signed), m_size(size)
+    {
+        mpz_init(this->raw);
+    }
+
+    integer_literal::integer_literal(integer_literal&& that) noexcept
+    {
+        mpz_init(this->raw);
+        mpz_swap(this->raw, that.raw);
+    }
+
+    integer_literal::integer_literal(const integer_literal& that)
+    {
+        mpz_init(this->raw);
+        mpz_set(this->raw, that.raw);
+    }
+
+    integer_literal::~integer_literal()
+    {
+        mpz_clear(this->raw);
+    }
+
+    std::optional<integer_literal> integer_literal::add(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        mpz_add(result.raw, this->raw, that.raw);
+
+        return std::move(result).check();
+    }
+
+    std::optional<integer_literal> integer_literal::sub(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        mpz_sub(result.raw, this->raw, that.raw);
+
+        return std::move(result).check();
+    }
+
+    std::optional<integer_literal> integer_literal::mul(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        mpz_mul(result.raw, this->raw, that.raw);
+
+        return std::move(result).check();
+    }
+
+    std::optional<integer_literal> integer_literal::div(const integer_literal& that) const
+    {
+        if (mpz_cmp_ui(that.raw, 0U) == 0)
+        {
+            return std::nullopt;
+        }
+        else
+        {
+            integer_literal result = *this;
+
+            mpz_div(result.raw, this->raw, that.raw);
+
+            return std::make_optional(std::move(result));
+        }
+    }
+
+    std::optional<integer_literal> integer_literal::mod(const integer_literal& that) const
+    {
+        if (mpz_cmp_ui(that.raw, 0U) == 0)
+        {
+            return std::nullopt;
+        }
+        else
+        {
+            integer_literal result = *this;
+
+            mpz_mod(result.raw, this->raw, that.raw);
+
+            return std::make_optional(std::move(result));
+        }
+    }
+
+    std::optional<integer_literal> integer_literal::neg() const
+    {
+        if (!is_signed() || is_negative_minimum())
+        {
+            return std::nullopt;
+        }
+        integer_literal result = *this;
+
+        mpz_neg(result.raw, this->raw);
+
+        return result;
+    }
+
+    std::optional<integer_literal> integer_literal::shl(const integer_literal& that) const
+    {
+        if (that >= bits())
+        {
+            return std::nullopt;
+        }
+        integer_literal result = *this;
+
+        mpz_mul_2exp(result.raw, this->raw, static_cast<mp_bitcnt_t>(mpz_get_ui(that.raw)));
+
+        return std::move(result).check();
+    }
+
+    std::optional<integer_literal> integer_literal::shr(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        if (that >= bits())
+        {
+            mpz_set_si(result.raw, *this > 0 ? 0 : -1);
+        }
+        else
+        {
+            mpz_fdiv_q_2exp(result.raw, this->raw, static_cast<mp_bitcnt_t>(mpz_get_ui(that.raw)));
+        }
+        return std::make_optional(std::move(result));
+    }
+
+    integer_literal integer_literal::operator|(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        mpz_ior(result.raw, this->raw, that.raw);
+
+        return result;
+    }
+
+    integer_literal integer_literal::operator&(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        mpz_and(result.raw, this->raw, that.raw);
+
+        return result;
+    }
+
+    integer_literal integer_literal::operator^(const integer_literal& that) const
+    {
+        integer_literal result = *this;
+
+        mpz_xor(result.raw, this->raw, that.raw);
+
+        return result;
+    }
+
+    integer_literal integer_literal::operator~() const
+    {
+        integer_literal result = *this;
+
+        mpz_com(result.raw, this->raw);
+
+        return result;
+    }
+
+    bool integer_literal::operator==(const integer_literal& that) const
+    {
+        return mpz_cmp(this->raw, that.raw) == 0;
+    }
+
+    std::weak_ordering integer_literal::operator<=>(const integer_literal& that) const
+    {
+        return mpz_cmp(this->raw, that.raw) <=> 0;
+    }
+
+    integer_literal& integer_literal::operator=(integer_literal&& that) noexcept
+    {
+        if (this != &that)
+        {
+            mpz_swap(this->raw, that.raw);
+        }
+        return *this;
+    }
+
+    integer_literal& integer_literal::operator=(const integer_literal& that)
+    {
+        if (this != &that)
+        {
+            mpz_set(this->raw, that.raw);
+        }
+        return *this;
+    }
+
+    bool integer_literal::is_signed() const
+    {
+        return this->m_signed;
+    }
+
+    std::size_t integer_literal::size() const
+    {
+        return this->m_size;
+    }
+
+    std::optional<integer_literal> integer_literal::check() &&
+    {
+        std::size_t required_bits = mpz_sizeinbase(this->raw, 2);
+
+        if (!is_negative_minimum())
+        {
+            ++required_bits; // Add one bit for the sign.
+        }
+        if (required_bits > bits() || (mpz_sgn(this->raw) < 0 && !is_signed()))
+        {
+            return std::nullopt;
+        }
+        else
+        {
+            return std::move(*this);
+        }
+    }
+
+    bool integer_literal::is_negative_minimum() const
+    {
+        return mpz_sgn(this->raw) < 0 && mpz_scan1(this->raw, 0) == bits() - 1;
+    }
+
+    std::size_t integer_literal::bits() const
+    {
+        return size() * CHAR_BIT;
+    }
+
     std::size_t constant_value_hash::operator()(const elna::boot::constant_value& value) const noexcept
     {
         return std::visit([](auto&& alternative) -> std::size_t {
@@ -149,24 +356,6 @@ namespace elna::boot
         }, value);
     }
 
-    bool constant_value_hash::operator()(const elna::boot::constant_value& lhs,
-            const elna::boot::constant_value& rhs) const noexcept
-    {
-        return std::visit([](auto&& first, auto&& second) -> bool {
-            using T = std::decay_t<decltype(first)>;
-            using U = std::decay_t<decltype(second)>;
-
-            if constexpr (std::is_same_v<T, U>)
-            {
-                return first == second;
-            }
-            else
-            {
-                return false;
-            }
-        }, lhs, rhs);
-    }
-
     hash_accumulator hash_accumulator::operator+(const std::size_t& that) const
     {
         hash_accumulator result{};
@@ -219,3 +408,8 @@ std::size_t std::hash<elna::boot::constant_aggregate<elna::boot::ordered_map>>::
 
     return hash.seed();
 }
+
+std::size_t std::hash<elna::boot::integer_literal>::operator()(const elna::boot::integer_literal& key) const noexcept
+{
+    return std::hash<std::uint32_t>{}(key.to<std::uint32_t>());
+}