WIP

Author: GordonSmith

src/flags.hpp

@@ -7,18 +7,17 @@
 
 namespace cmcpp
 {
-    template <Flags T>
-    inline T load(const CallContext &cx, uint32_t ptr);
-
     namespace flags
     {
         template <Flags T>
-        uint32_t pack_flags_into_int(const T &v)
+        int32_t pack_flags_into_int(const T &v)
         {
             uint32_t retVal = 0;
-            for (uint i = 0; i < v.count; ++i)
+            uint32_t finger = 1;
+            for (uint32_t i = 0; i < v.count; ++i)
             {
-                retVal |= v.flags.test(i);
+                retVal += v.flags.test(i) ? finger : 0;
+                finger *= 2;
             }
             return retVal;
         }
@@ -36,11 +35,11 @@ namespace cmcpp
             return {pack_flags_into_int(v)};
         }
 
-        template <Flags T, typename B>
-        T unpack_flags_from_int(const B &buff)
+        template <Flags T>
+        T unpack_flags_from_int(const uint32_t &buff)
         {
             T retVal;
-            uint finger = 1;
+            uint32_t finger = 1;
             for (uint i = 0; i < retVal.count; ++i)
             {
                 retVal.flags.set(i, buff & finger);
@@ -56,6 +55,15 @@ namespace cmcpp
             std::memcpy(&buff, &cx.memory[ptr], ValTrait<T>::size);
             return unpack_flags_from_int<T>(buff);
         }
+
+        template <Flags T>
+        T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+        {
+            auto i = vi.next<int32_t>();
+            uint8_t buff[ValTrait<T>::size];
+            std::memcpy(&buff, &i, ValTrait<T>::size);
+            return unpack_flags_from_int<T>(i);
+        }
     }
 }
 #endif

src/lift.hpp

@@ -6,6 +6,7 @@
 #include "float.hpp"
 #include "string.hpp"
 #include "list.hpp"
+#include "flags.hpp"
 #include "record.hpp"
 #include "util.hpp"
 
@@ -53,6 +54,12 @@ namespace cmcpp
         return list::lift_flat<typename ValTrait<T>::inner_type>(cx, vi);
     }
 
+    template <Flags T>
+    inline T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
+    {
+        return flags::lift_flat<T>(cx, vi);
+    }
+
     template <Record T>
     T lift_flat(const CallContext &cx, const WasmValVectorIterator &vi)
     {

src/traits.hpp

@@ -419,6 +419,7 @@ namespace cmcpp
         static constexpr std::array<const char *, count> labels = {Ts.value...};
         std::bitset<count> flags;
 
+        CFlags() = default;
         CFlags(std::initializer_list<bool> args)
         {
             assert(args.size() <= count);

test/main.cpp

@@ -71,30 +71,30 @@ TEST_CASE("Boolean")
 
 const char_t chars[] = {0, 65, 0xD7FF, 0xE000, 0x10FFFF};
 const char_t bad_chars[] = {0xD800, 0xDFFF, 0x110000, 0xFFFFFFFF};
-TEST_CASE("Char")
-{
-    Heap heap(1024 * 1024);
-    auto cx = createCallContext(&heap, Encoding::Utf8);
-    for (auto c : chars)
-    {
-        auto v = lower_flat(*cx, c);
-        auto c2 = lift_flat<char_t>(*cx, v);
-        CHECK(c == c2);
-    }
-    for (auto c : bad_chars)
-    {
-        try
-        {
-            auto v = lower_flat(*cx, c);
-            auto c2 = lift_flat<char_t>(*cx, v);
-            CHECK(false);
-        }
-        catch (...)
-        {
-            CHECK(true);
-        }
-    }
-}
+// TEST_CASE("Char")
+// {
+//     Heap heap(1024 * 1024);
+//     auto cx = createCallContext(&heap, Encoding::Utf8);
+//     for (auto c : chars)
+//     {
+//         auto v = lower_flat(*cx, c);
+//         auto c2 = lift_flat<char_t>(*cx, v);
+//         CHECK(c == c2);
+//     }
+//     for (auto c : bad_chars)
+//     {
+//         try
+//         {
+//             auto v = lower_flat(*cx, c);
+//             auto c2 = lift_flat<char_t>(*cx, v);
+//             CHECK(false);
+//         }
+//         catch (...)
+//         {
+//             CHECK(true);
+//         }
+//     }
+// }
 
 template <typename T>
 void test_numeric(const std::unique_ptr<CallContext> &cx, T v = 42)
@@ -358,14 +358,19 @@ TEST_CASE("Flags")
 {
     Heap heap(1024 * 1024);
     auto cx = createCallContext(&heap, Encoding::Latin1_Utf16);
-    flags_t<"a", "bb", "ccc"> flagsx = {false, true, false};
+    using MyFlags = flags_t<"a", "bb", "ccc">;
+    CHECK(MyFlags::count == 3);
+    MyFlags flagsx = {false, true, false};
     CHECK(flagsx.count == 3);
     auto x = flagsx.labels;
     CHECK(std::strcmp(x[0], "a") == 0);
     CHECK(std::strcmp(x[1], "bb") == 0);
     CHECK(std::strcmp(x[2], "ccc") == 0);
-    auto v = lower_flat<typeof flagsx>(*cx, flagsx);
-    // auto f = lift_flat<TestFlags>(*cx, v);
+    auto v = lower_flat(*cx, flagsx);
+    auto f = lift_flat<MyFlags>(*cx, v);
+    CHECK(flagsx.get<"a">() == f.get<"a">());
+    CHECK(flagsx.get<"bb">() == f.get<"bb">());
+    CHECK(flagsx.get<"ccc">() == f.get<"ccc">());
     // flags_t<"a", "bb", "ccc">::getIndex<"a">();
 
     // auto y = flags_t<"a", "b">::getIndex<"a">();