Review spaceship usage

4 files changed, 153 insertions, 40 deletions

diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h
index cc5878b..0eda1a3 100644
--- a/include/elna/boot/ast.h
+++ b/include/elna/boot/ast.h
@@ -139,7 +139,7 @@ namespace elna::boot
         virtual void visit(field_access_expression *) = 0;
         virtual void visit(dereference_expression *) = 0;
         virtual void visit(literal<std::int32_t> *) = 0;
-        virtual void visit(literal<std::uint32_t> *) = 0;
+        virtual void visit(literal<integer_literal> *) = 0;
         virtual void visit(literal<double> *) = 0;
         virtual void visit(literal<bool> *) = 0;
         virtual void visit(literal<unsigned char> *) = 0;
@@ -189,7 +189,7 @@ namespace elna::boot
         [[noreturn]] void visit(field_access_expression *) override;
         [[noreturn]] void visit(dereference_expression *) override;
         [[noreturn]] void visit(literal<std::int32_t> *) override;
-        [[noreturn]] void visit(literal<std::uint32_t> *) override;
+        [[noreturn]] void visit(literal<integer_literal> *) override;
         [[noreturn]] void visit(literal<double> *) override;
         [[noreturn]] void visit(literal<bool> *) override;
         [[noreturn]] void visit(literal<unsigned char> *) override;
@@ -237,7 +237,7 @@ namespace elna::boot
         void visit(field_access_expression *expression) override;
         void visit(dereference_expression *expression) override;
         void visit(literal<std::int32_t> *) override;
-        void visit(literal<std::uint32_t> *) override;
+        void visit(literal<integer_literal> *) override;
         void visit(literal<double> *) override;
         void visit(literal<bool> *) override;
         void visit(literal<unsigned char> *) override;
diff --git a/include/elna/boot/name_analysis.h b/include/elna/boot/name_analysis.h
index 626e9f2..5d43f67 100644
--- a/include/elna/boot/name_analysis.h
+++ b/include/elna/boot/name_analysis.h
@@ -158,7 +158,7 @@ namespace elna::boot
         void visit(for_statement *statement) override;
 
         void visit(literal<std::int32_t> *literal) override;
-        void visit(literal<std::uint32_t> *literal) override;
+        void visit(literal<integer_literal> *literal) override;
         void visit(literal<double> *literal) override;
         void visit(literal<bool> *literal) override;
         void visit(literal<unsigned char> *literal) override;
diff --git a/include/elna/boot/result.h b/include/elna/boot/result.h
index 42c96f2..3e8dfdf 100644
--- a/include/elna/boot/result.h
+++ b/include/elna/boot/result.h
@@ -29,6 +29,8 @@ along with GCC; see the file COPYING3.  If not see
 #include <vector>
 #include <unordered_map>
 
+#include <gmp.h>
+
 namespace elna::boot
 {
     /**
@@ -143,7 +145,7 @@ namespace elna::boot
         {
         }
 
-        auto operator<=>(const return_declaration&) const = default;
+        bool operator==(const return_declaration&) const = default;
 
         T proper_type{};
         bool no_return{ false };
@@ -156,9 +158,8 @@ namespace elna::boot
         const std::string& name() const;
         const source_position& position() const;
 
-        std::strong_ordering operator<=>(const identifier& that) const;
+        bool operator==(const identifier& that) const;
         bool operator==(std::string_view that) const;
-        bool operator!=(std::string_view that) const;
 
     private:
         std::string m_name;
@@ -180,6 +181,138 @@ namespace elna::boot
     };
 
     /**
+     * Checks whether \p T is a signed, std::int*_t type.
+     *
+     * \tparam T The examined type.
+     *
+     * \see is_unsigned
+     */
+    template<typename T>
+    inline constexpr bool is_signed = std::is_same_v<T, std::int8_t>
+        || std::is_same_v<T, std::int16_t>
+        || std::is_same_v<T, std::int32_t>
+        || std::is_same_v<T, std::int64_t>;
+
+    /**
+     * Checks whether \p T is a signed, std::uint*_t type.
+     *
+     * \tparam T The examined type.
+     *
+     * \see is_signed
+     */
+    template<typename T>
+    inline constexpr bool is_unsigned = std::is_same_v<T, std::uint8_t>
+        || std::is_same_v<T, std::uint16_t>
+        || std::is_same_v<T, std::uint32_t>
+        || std::is_same_v<T, std::uint64_t>;
+
+    /**
+     * Checks whether \p T is any of std::int*_t or std::uint*_t types.
+     *
+     * Contrary to \c std::is_integral characters and booleans do not count.
+     *
+     * \tparam T The examined type.
+     */
+    template<typename T>
+    inline constexpr bool is_integral = is_signed<T> || is_unsigned<T>;
+
+    /**
+     * Checks whether \p T is an integral or floating point type.
+     *
+     * \tparam T The examined type.
+     *
+	 * \see is_integral
+     */
+    template<typename T>
+    inline constexpr bool is_arithmetic = is_integral<T> || std::is_floating_point_v<T>;
+
+    struct integer_literal
+    {
+        integer_literal(integer_literal&& that) noexcept;
+        integer_literal(const integer_literal& that);
+        ~integer_literal();
+
+        std::optional<integer_literal> add(const integer_literal& that) const;
+        std::optional<integer_literal> sub(const integer_literal& that) const;
+        std::optional<integer_literal> mul(const integer_literal& that) const;
+        std::optional<integer_literal> div(const integer_literal& that) const;
+        std::optional<integer_literal> mod(const integer_literal& that) const;
+        std::optional<integer_literal> neg() const;
+        std::optional<integer_literal> shl(const integer_literal& that) const;
+        std::optional<integer_literal> shr(const integer_literal& that) const;
+
+        integer_literal operator|(const integer_literal& that) const;
+        integer_literal operator&(const integer_literal& that) const;
+        integer_literal operator^(const integer_literal& that) const;
+        integer_literal operator~() const;
+
+        bool operator==(const integer_literal& that) const;
+        std::weak_ordering operator<=>(const integer_literal& that) const;
+        template<typename U>
+        bool operator==(U that) const
+            requires(is_unsigned<U> && sizeof(U) <= sizeof(unsigned long int))
+        {
+            return mpz_cmp_ui(this->raw, that) == 0;
+        }
+        template<typename U>
+        bool operator==(U that) const
+            requires(is_signed<U> && sizeof(U) <= sizeof(signed long int))
+        {
+            return mpz_cmp_si(this->raw, that) == 0;
+        }
+        template<typename U>
+        std::weak_ordering operator<=>(U that) const
+            requires(is_unsigned<U> && sizeof(U) <= sizeof(unsigned long int))
+        {
+            return mpz_cmp_ui(this->raw, that) <=> 0;
+        }
+        template<typename U>
+        std::weak_ordering operator<=>(U that) const
+            requires(is_signed<U> && sizeof(U) <= sizeof(signed long int))
+        {
+            return mpz_cmp_si(this->raw, that) <=> 0;
+        }
+
+        integer_literal& operator=(integer_literal&& that) noexcept;
+        integer_literal& operator=(const integer_literal& that);
+
+        bool is_signed() const;
+        std::size_t size() const;
+
+        template<typename T>
+        T to() const
+            requires is_integral<T>
+        {
+            T result;
+
+            mpz_export(&result, nullptr, 1, sizeof(T), 0, 0, this->raw);
+
+            return result;
+        }
+
+        template<typename T>
+        static integer_literal from(T initial)
+            requires is_integral<T>
+        {
+            integer_literal result{ std::is_signed_v<T>, sizeof(T) };
+
+            mpz_import(result.raw, 1, 1, sizeof(T), 0, 0, &initial);
+
+            return result;
+        }
+
+    private:
+        bool m_signed;
+        std::size_t m_size;
+        mpz_t raw;
+
+        integer_literal(bool is_signed, std::size_t size);
+        std::optional<integer_literal> check() &&;
+        bool is_negative_minimum() const;
+        std::size_t bits() const;
+    };
+
+    /**
      * An associative container that contains key-value pairs with unique keys.
      * Keys preserve the insertion order.
      */
@@ -202,9 +335,9 @@ namespace elna::boot
         using iterator = std::vector<value_type>::iterator;
         using const_iterator = std::vector<value_type>::const_iterator;
 
-        auto operator<=>(const ordered_map& that) const
+        bool operator==(const ordered_map& that) const
         {
-            return this->payload <=> that.payload;
+            return this->payload == that.payload;
         }
 
         /**
@@ -357,7 +490,7 @@ namespace elna::boot
     {
         std::string name;
 
-        auto operator<=>(const global_address&) const = default;
+        bool operator==(const global_address&) const = default;
     };
 
     template<template<typename, typename> typename C, template<typename> typename Alloc = std::allocator>
@@ -371,7 +504,7 @@ namespace elna::boot
      */
     using constant_value = std::variant<
         std::int32_t,
-        std::uint32_t,
+        integer_literal,
         double,
         bool,
         unsigned char,
@@ -387,7 +520,6 @@ namespace elna::boot
     struct constant_value_hash
     {
         std::size_t operator()(const constant_value& value) const noexcept;
-        bool operator()(const constant_value& lhs, const constant_value& rhs) const noexcept;
     };
 
     /**
@@ -433,34 +565,9 @@ namespace elna::boot
             return this->container.get();
         }
 
-        bool operator==(const constant_aggregate<std::vector>& that) const
-            requires std::is_same_v<Container, std::vector<constant_value, Alloc<constant_value>>>
-        {
-            if (this->container->size() != that.container->size())
-            {
-                return false;
-            }
-            return std::ranges::equal(*this->container, *that.container, constant_value_hash{});
-        }
-
-        bool operator==(const constant_aggregate<ordered_map>& that) const
-            requires std::is_same_v<Container, ordered_map<constant_value, Alloc<constant_value>>>
-        {
-            if (this->container->size() != that.container->size())
-            {
-                return false;
-            }
-            const constant_value_hash comparator{};
-
-            return std::ranges::equal(*this->container, *that.container,
-                    [comparator](const auto& lhs, const auto& rhs) {
-                        return lhs.first == rhs.first && comparator(lhs.second, rhs.second);
-                    });
-        }
-
-        bool operator!=(const constant_aggregate& that) const
+        bool operator==(const constant_aggregate<C, Alloc>& that) const
         {
-            return !(*this == that);
+            return *this->container == *that.container;
         }
     };
 
@@ -540,3 +647,9 @@ struct std::hash<elna::boot::constant_aggregate<elna::boot::ordered_map>>
 {
     std::size_t operator()(const elna::boot::constant_aggregate<elna::boot::ordered_map>& key) const noexcept;
 };
+
+template<>
+struct std::hash<elna::boot::integer_literal>
+{
+    std::size_t operator()(const elna::boot::integer_literal& key) const noexcept;
+};
diff --git a/include/elna/gcc/elna-generic.h b/include/elna/gcc/elna-generic.h
index b5ba5e0..944c4d0 100644
--- a/include/elna/gcc/elna-generic.h
+++ b/include/elna/gcc/elna-generic.h
@@ -74,7 +74,7 @@ namespace elna::gcc
         void visit(boot::procedure_call *call) override;
         void visit(boot::cast_expression *expression) override;
         void visit(boot::literal<std::int32_t> *literal) override;
-        void visit(boot::literal<std::uint32_t> *literal) override;
+        void visit(boot::literal<boot::integer_literal> *literal) override;
         void visit(boot::literal<double> *literal) override;
         void visit(boot::literal<bool> *boolean) override;
         void visit(boot::literal<unsigned char> *character) override;