chore: Refactor file layout

Step towards a header only release

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

.github/workflows/macos.yml

@@ -25,9 +25,9 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - name: Set up C++20 
-        uses: aminya/setup-cpp@v0.44.0
+        uses: aminya/setup-cpp@v1
         with: 
-          compiler: gcc 
+          compiler: gcc-13
           cmake: true 
           ninja: true 
 
@@ -42,7 +42,7 @@ jobs:
 
       - name: install dependencies
         run: |
-          brew install autoconf autoconf-archive automake coreutils libtool ninja
+          brew install pkg-config autoconf autoconf-archive automake coreutils libtool cmake ninja
 
       - name: configure
         run: |

.github/workflows/ubuntu.yml

@@ -19,7 +19,6 @@ jobs:
     strategy:
       matrix:
         include:
-          - os: "ubuntu-22.04"
           - os: "ubuntu-24.04"
       fail-fast: false
 

CMakeLists.txt

@@ -1,16 +1,29 @@
-cmake_minimum_required(VERSION 3.14...3.22)
+cmake_minimum_required(VERSION 3.5...3.16)
 
-project(component-model LANGUAGES CXX)
+project(cmcpp)
 
-if(PROJECT_SOURCE_DIR STREQUAL PROJECT_BINARY_DIR)
-    message(FATAL_ERROR
-        "In-source builds not allowed. Please make a new directory (called a build directory) and run CMake from there."
-    )
-endif()
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+find_package(Boost)
+
+add_library(cmcpp STATIC
+    src/context.cpp
+    src/util.cpp
+)
 
-enable_testing()
+target_include_directories(cmcpp
+    INTERFACE include
+    PRIVATE ${Boost_INCLUDE_DIR}
+)
 
-set(ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+target_link_libraries(cmcpp 
+)
 
-add_subdirectory(src)
-add_subdirectory(test)
+include_directories(
+    include
+)
+
+if (BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+    add_subdirectory(test)
+endif()

CMakePresets.json

@@ -25,7 +25,8 @@
             "name": "Debug",
             "installDir": "${sourceDir}/build/stage/Debug",
             "cacheVariables": {
-                "CMAKE_BUILD_TYPE": "Debug"
+                "CMAKE_BUILD_TYPE": "Debug",
+                "BUILD_TESTING": "ON"
             },
             "hidden": true
         },

include/cmcpp.hpp

@@ -0,0 +1,14 @@
+#ifndef CMCPP_HPP
+#define CMCPP_HPP
+
+#include <cmcpp/integer.hpp>
+#include <cmcpp/float.hpp>
+#include <cmcpp/string.hpp>
+#include <cmcpp/flags.hpp>
+#include <cmcpp/list.hpp>
+#include <cmcpp/tuple.hpp>
+#include <cmcpp/variant.hpp>
+#include <cmcpp/lower.hpp>
+#include <cmcpp/lift.hpp>
+
+#endif // CMCPP_HPP

src/context.hpp include/cmcpp/context.hppsrc/context.hpp renamed to include/cmcpp/context.hpp

@@ -58,10 +58,23 @@ namespace cmcpp
         flags::store(cx, v, ptr);
     }
 
+    template <Flags T>
+    inline WasmValVector lower_flat(CallContext &cx, const T &v)
+    {
+        return flags::lower_flat(cx, v);
+    }
+
     template <Flags T>
     inline T load(const CallContext &cx, uint32_t ptr)
     {
         return flags::load<T>(cx, ptr);
     }
+
+    template <Flags T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
+    {
+        return flags::lift_flat<T>(cx, vi);
+    }
+
 }
 #endif

src/flags.hpp include/cmcpp/flags.hppsrc/flags.hpp renamed to include/cmcpp/flags.hpp

@@ -11,11 +11,33 @@ namespace cmcpp
 
     namespace float_
     {
-        int32_t encode_float_as_i32(float32_t f);
-        int64_t encode_float_as_i64(float64_t f);
-        float32_t decode_i32_as_float(int32_t i);
-        float64_t decode_i64_as_float(int64_t i);
-        float32_t core_f32_reinterpret_i32(int32_t i);
+        inline int32_t encode_float_as_i32(float32_t f)
+
+        {
+            return *reinterpret_cast<int32_t *>(&f);
+        }
+
+        inline int64_t encode_float_as_i64(float64_t f)
+        {
+            return *reinterpret_cast<int64_t *>(&f);
+        }
+
+        inline float32_t decode_i32_as_float(int32_t i)
+        {
+            return *reinterpret_cast<float32_t *>(&i);
+        }
+
+        inline float64_t decode_i64_as_float(int64_t i)
+        {
+            return *reinterpret_cast<float64_t *>(&i);
+        }
+
+        inline float32_t core_f32_reinterpret_i32(int32_t i)
+        {
+            float f;
+            std::memcpy(&f, &i, sizeof f);
+            return f;
+        }
 
         template <Float T>
         T canonicalize_nan(T f)
@@ -78,11 +100,24 @@ namespace cmcpp
         float_::store<T>(cx, v, ptr);
     }
 
+    template <Float T>
+    inline WasmValVector lower_flat(CallContext &cx, const T &v)
+    {
+        return {float_::lower_flat<T>(v)};
+    }
+
     template <Float T>
     inline T load(const CallContext &cx, uint32_t ptr)
     {
         return float_::load<T>(cx, ptr);
     }
+
+    template <Float T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi)
+    {
+        using WasmValType = WasmValTypeTrait<ValTrait<T>::flat_types[0]>::type;
+        return float_::canonicalize_nan<T>(std::get<WasmValType>(vi.next(ValTrait<T>::flat_types[0])));
+    }
 }
 
 #endif

src/float.hpp include/cmcpp/float.hppsrc/float.hpp renamed to include/cmcpp/float.hpp

@@ -73,6 +73,13 @@ namespace cmcpp
         integer::store<T>(cx, v, ptr);
     }
 
+    template <SignedInteger T>
+    inline WasmValVector lower_flat(CallContext &cx, const T &v)
+    {
+        using WasmValType = WasmValTypeTrait<ValTrait<T>::flat_types[0]>::type;
+        return integer::lower_flat_signed(v, ValTrait<WasmValType>::size * 8);
+    }
+
     template <Boolean T>
     inline T load(const CallContext &cx, uint32_t ptr)
     {
@@ -90,6 +97,18 @@ namespace cmcpp
     {
         return integer::load<T>(cx, ptr);
     }
+
+    template <UnsignedInteger T>
+    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 CoreValueIter &vi)
+    {
+        return integer::lift_flat_signed<T>(vi, ValTrait<T>::size * 8, 8);
+    }
 }
 
 #endif

src/integer.hpp include/cmcpp/integer.hppsrc/integer.hpp renamed to include/cmcpp/integer.hpp

@@ -0,0 +1,50 @@
+#ifndef CMCPP_LIFT_HPP
+#define CMCPP_LIFT_HPP
+
+#include "context.hpp"
+#include "util.hpp"
+
+namespace cmcpp
+{
+    template <Boolean T>
+    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 CoreValueIter &vi)
+    {
+        return convert_i32_to_char(cx, vi.next<int32_t>());
+    }
+
+    template <UnsignedInteger T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <SignedInteger T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <Float T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <String T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <List T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <Flags T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <Tuple T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <Record T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+    template <Variant T>
+    inline T lift_flat(const CallContext &cx, const CoreValueIter &vi);
+
+}
+
+#endif