feat: Add variant support

Improved constexpr types

Signed-off-by Gordon Smith <GordonJSmith@gmail>

Author: GordonSmith

CMakeLists.txt

@@ -10,5 +10,7 @@ endif()
 
 enable_testing()
 
+set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
 add_subdirectory(src)
 add_subdirectory(test)

README.md

@@ -39,11 +39,9 @@ This repository contains a C++ ABI implementation of the WebAssembly Component M
 - [x] utf16 String
 - [x] latin1+utf16 String
 - [x] List
-- [ ] Field
-- [ ] Record
-- [ ] Tuple
-- [ ] Case
-- [ ] Variant
+- [x] Record
+- [x] Tuple
+- [x] Variant
 - [ ] Enum
 - [ ] Option
 - [ ] Result

ref/component-model

@@ -43,7 +43,7 @@ namespace cmcpp
         }
 
         template <Flags T>
-        T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+        T lift_flat(const CallContext &cx, const CoreValueIter &vi)
         {
             auto i = vi.next<int32_t>();
             uint8_t buff[ValTrait<T>::size];

src/flags.hpp

@@ -6,22 +6,22 @@ namespace cmcpp
     {
         int32_t encode_float_as_i32(float32_t f)
         {
-            return *reinterpret_cast<int32_t*>(&f);
+            return *reinterpret_cast<int32_t *>(&f);
         }
 
         int64_t encode_float_as_i64(float64_t f)
         {
-            return *reinterpret_cast<int64_t*>(&f);
+            return *reinterpret_cast<int64_t *>(&f);
         }
 
         float32_t decode_i32_as_float(int32_t i)
         {
-            return *reinterpret_cast<float32_t*>(&i);
+            return *reinterpret_cast<float32_t *>(&i);
         }
 
         float64_t decode_i64_as_float(int64_t i)
         {
-            return *reinterpret_cast<float64_t*>(&i);
+            return *reinterpret_cast<float64_t *>(&i);
         }
 
         float32_t core_f32_reinterpret_i32(int32_t i)

src/float.cpp

@@ -2,6 +2,7 @@
 #define CMCPP_INTEGER_HPP
 
 #include "context.hpp"
+#include "util.hpp"
 
 #include <cstring>
 #include <iostream>
@@ -36,19 +37,19 @@ namespace cmcpp
         }
 
         template <typename T>
-        T lift_flat_unsigned(const WasmValVectorIterator &vi, uint32_t core_width, uint32_t t_width)
+        T lift_flat_unsigned(const CoreValueIter &vi, uint32_t core_width, uint32_t t_width)
         {
             using WasmValType = ValTrait<T>::flat_type;
-            auto retVal = vi.next<WasmValType>();
+            auto retVal = std::get<WasmValType>(vi.next(ValTrait<T>::flat_types[0]));
             assert(ValTrait<WasmValType>::LOW_VALUE <= retVal && retVal < ValTrait<WasmValType>::HIGH_VALUE);
             return retVal;
         }
 
         template <typename T>
-        T lift_flat_signed(const WasmValVectorIterator &vi, uint32_t core_width, uint32_t t_width)
+        T lift_flat_signed(const CoreValueIter &vi, uint32_t core_width, uint32_t t_width)
         {
             using WasmValType = ValTrait<T>::flat_type;
-            auto retVal = static_cast<T>(vi.next<WasmValType>());
+            auto retVal = static_cast<T>(std::get<WasmValType>(vi.next(ValTrait<T>::flat_types[0])));
             assert(ValTrait<T>::LOW_VALUE <= retVal && retVal <= ValTrait<T>::HIGH_VALUE);
             return retVal;
         }

src/integer.hpp

@@ -8,64 +8,72 @@
 #include "list.hpp"
 #include "flags.hpp"
 #include "record.hpp"
+#include "variant.hpp"
 #include "util.hpp"
 
 namespace cmcpp
 {
     template <Boolean T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return convert_int_to_bool(vi.next<int32_t>());
     }
 
     template <Char T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return convert_i32_to_char(cx, vi.next<int32_t>());
     }
 
     template <UnsignedInteger T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return integer::lift_flat_unsigned<T>(vi, ValTrait<T>::size * 8, 8);
     }
 
     template <SignedInteger T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return integer::lift_flat_signed<T>(vi, ValTrait<T>::size * 8, 8);
     }
 
     template <Float T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
-        return float_::canonicalize_nan<T>(vi.next<T>());
+        using WasmValType = ValTrait<T>::flat_type;
+        return float_::canonicalize_nan<T>(std::get<WasmValType>(vi.next(ValTrait<T>::flat_types[0])));
     }
 
     template <String T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return string::lift_flat<T>(cx, vi);
     }
 
     template <List T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return list::lift_flat<typename ValTrait<T>::inner_type>(cx, vi);
     }
 
     template <Flags T>
-    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
         return flags::lift_flat<T>(cx, vi);
     }
 
     template <Record T>
-    T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    T lift_flat(const CallContext &cx, const CoreValueIter &vi)
     {
-        auto x = record::lift_flat<T>(cx, vi);
+        auto x = record::lift_flat_record<T>(cx, vi);
         return x;
     }
+
+    template <Variant T>
+    T lift_flat(const CallContext &cx, const CoreValueIter &vi)
+    {
+        return variant::lift_flat<T>(cx, vi);
+    }
 }
 
 #endif

src/lift.hpp

@@ -57,7 +57,7 @@ namespace cmcpp
         }
 
         template <typename T>
-        WasmValVector lower_flat(CallContext &cx, const list_t<T> &v)
+        WasmValVector lower_flat_list(CallContext &cx, const list_t<T> &v)
         {
             auto [ptr, length] = store_into_range(cx, v);
             return {static_cast<int32_t>(ptr), static_cast<int32_t>(length)};
@@ -85,7 +85,7 @@ namespace cmcpp
         }
 
         template <typename T>
-        list_t<T> lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+        list_t<T> lift_flat(const CallContext &cx, const CoreValueIter &vi)
         {
             auto ptr = vi.next<int32_t>();
             auto length = vi.next<int32_t>();

src/list.hpp

@@ -57,7 +57,7 @@ namespace cmcpp
     template <List T>
     inline WasmValVector lower_flat(CallContext &cx, const T &v)
     {
-        return list::lower_flat(cx, v);
+        return list::lower_flat_list(cx, v);
     }
 
     template <Flags T>
@@ -69,7 +69,13 @@ namespace cmcpp
     template <Record T>
     inline WasmValVector lower_flat(CallContext &cx, const T &v)
     {
-        return record::lower_flat(cx, v);
+        return record::lower_flat_record(cx, v);
+    }
+
+    template <Variant T>
+    inline WasmValVector lower_flat(CallContext &cx, const T &v)
+    {
+        return variant::lower_flat_variant(cx, v);
     }
 }
 

src/lower.hpp

@@ -17,7 +17,7 @@ namespace cmcpp
     {
 
         template <Record T>
-        void store(const CallContext &cx, const T&v, uint32_t ptr)
+        void store(const CallContext &cx, const T &v, uint32_t ptr)
         {
             auto process_field = [&](auto &&field)
             {
@@ -31,7 +31,7 @@ namespace cmcpp
         }
 
         template <Record T>
-        WasmValVector lower_flat(CallContext &cx, const T &v)
+        WasmValVector lower_flat_record(CallContext &cx, const T &v)
         {
             WasmValVector retVal = {};
             auto process_field = [&](auto &&field)
@@ -62,7 +62,7 @@ namespace cmcpp
         }
 
         template <Record T>
-        inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+        inline T lift_flat_record(const CallContext &cx, const CoreValueIter &vi)
         {
             T result;
             auto process_field = [&](auto &&field)