.clang-format

@@ -118,7 +118,7 @@ IncludeIsMainSourceRegex: ''
 IndentAccessModifiers: false
 IndentCaseBlocks: false
 IndentCaseLabels: false
-IndentExternBlock: NoIndent
+IndentExternBlock: AfterExternBlock
 IndentGotoLabels: true
 IndentPPDirectives: None
 IndentRequiresClause: true

src/internal/mana_arena.h

@@ -13,11 +13,6 @@
 namespace mesytec::mnode::mana
 {
 
-template <typename T> inline bool is_aligned(const T *ptr, size_t alignment = alignof(T))
-{
-    return (((uintptr_t)ptr) % alignment) == 0;
-}
-
 class Arena
 {
   public:
@@ -31,11 +26,16 @@ class Arena
     Arena(Arena &&other) = default;
     Arena &operator=(Arena &&other) = default;
 
-    // Pushes at least the required amount of memory onto the arena. The memory is aligned to
+    // pushes at least the required amount of memory onto the arena.
-    // 'default_align_to' and zeroed
+    // 'required' is rounded up to the nearest multiple of 'default_align_to' to make
+    // subsequent allocations aligned.
     u8 *push_size(size_t required)
     {
-        if (!segment_)
+        size_t padded = round_up(required, default_align_to);
+        size_t pad_waste = padded - required;
+        required = padded;
+
+        if (!segment_ || segment_->free() < required)
         {
             if (segment_count() < max_segments())
             {
@@ -52,20 +52,12 @@ class Arena
 
         assert(segment_ && segment_->free() >= required);
 
-        void *ptr = segment_->cur();
+        auto result = segment_->cur();
-        size_t space = segment_->free();
+        std::memset(result, 0, required);
-        if (!std::align(default_align_to, required, ptr, space))
+        segment_->used += required;
-            throw std::bad_alloc();
-
-        assert(is_aligned(ptr, default_align_to));
-
-        size_t pad_waste = segment_->free() - space;
-        segment_->used += required + pad_waste;
-        pad_waste_ += pad_waste;
         ++allocations_;
-
+        pad_waste_ += pad_waste;
-        std::memset(ptr, 0, required);
+        return result;
-        return reinterpret_cast<u8 *>(ptr);
     }
 
     template <typename T> T *push_t(size_t count = 1)

src/internal/mana_c_api.h

@@ -9,55 +9,42 @@ extern "C"
 {
 #endif
 
-typedef enum
+    typedef enum
-{
+    {
         mana_custom,
         mana_uint8,
         mana_sint8,
         mana_uint16,
-    mana_sint16,
         mana_uint32,
-    mana_sint32,
         mana_uint64,
-    mana_sint64,
         mana_float,
         mana_double,
-} mana_data_type_t;
+    } mana_data_type_t;
 
-// Offset based pointer. Allows to memcpy() structures with these pointers
+    typedef struct
-// inside as long as the range covered by the pointers is also copied.
+    {
-//
-// Raw pointer value is '&ptr + offset'. nullptr is defined as offset=1.
-// => Cannot point to the first byte of the struct itself but that's fine.
-// Do not create temporaries of these. The offset will then be relative to the
-// temporary on the stack! Do not copy these unless you copy the full memory
-// range so that the offset_ptr_t in the new location stays valid.
-typedef struct
-{
         mana_data_type_t data_type;
         ptrdiff_t offset;
-} mana_offset_ptr_t;
+    } mana_offset_ptr_t;
 
-// Typed offset pointer based array. Stores the array size in bytes instead of
+    typedef struct
-// elements to allow storing any type using mana_custom.
+    {
-typedef struct
-{
         mana_offset_ptr_t ptr;
         size_t size_bytes;
-} mana_offset_array_t;
+    } mana_offset_array_t;
 
-typedef enum
+    typedef enum
-{
+    {
         mana_status_ok,
         mana_status_invalid_argument,
         mana_status_internal_error,
-} mana_status_code_t;
+    } mana_status_code_t;
 
-typedef struct
+    typedef struct
-{
+    {
         mana_status_code_t code;
         char message[256];
-} mana_status_t;
+    } mana_status_t;
 
 #define MANA_DEFINE_PLUGIN_INIT(name) void *name(int plugin_argc, const char **plugin_argv)
 
@@ -76,22 +63,22 @@ typedef struct
 #define MANA_DEFINE_PLUGIN_SYSTEM_EVENT(name)                                                      \
     void name(void *context, const uint32_t *data, size_t size)
 
-typedef MANA_DEFINE_PLUGIN_INIT(mana_init_t);
+    typedef MANA_DEFINE_PLUGIN_INIT(mana_init_t);
-typedef MANA_DEFINE_PLUGIN_SHUTDOWN(mana_shutdown_t);
+    typedef MANA_DEFINE_PLUGIN_SHUTDOWN(mana_shutdown_t);
-typedef MANA_DEFINE_PLUGIN_BEGIN_RUN(mana_begin_run_t);
+    typedef MANA_DEFINE_PLUGIN_BEGIN_RUN(mana_begin_run_t);
-typedef MANA_DEFINE_PLUGIN_END_RUN(mana_end_run_t);
+    typedef MANA_DEFINE_PLUGIN_END_RUN(mana_end_run_t);
-typedef MANA_DEFINE_PLUGIN_EVENT_DATA(mana_process_event_t);
+    typedef MANA_DEFINE_PLUGIN_EVENT_DATA(mana_process_event_t);
-typedef MANA_DEFINE_PLUGIN_SYSTEM_EVENT(mana_process_system_event_t);
+    typedef MANA_DEFINE_PLUGIN_SYSTEM_EVENT(mana_process_system_event_t);
 
-typedef struct
+    typedef struct
-{
+    {
         mana_init_t *init;
         mana_shutdown_t *shutdown;
         mana_begin_run_t *begin_run;
         mana_end_run_t *end_run;
         mana_process_event_t *process_event;
         mana_process_system_event_t *process_system_event;
-} mana_sink_plugin_t;
+    } mana_sink_plugin_t;
 
 // use this to define the entry point into the plugin
 // from c++: extern "C" MANA_C_SINK_PLUGIN() { ... return plugin; }

src/internal/mana_lib.hpp

@@ -16,11 +16,8 @@
 namespace mesytec::mnode::mana
 {
 
-inline bool is_null(const mana_offset_ptr_t &ptr) { return ptr.offset == 1; }
-
 namespace detail
 {
-
 inline void set(mana_offset_ptr_t &ptr, void *p)
 {
     assert(p != reinterpret_cast<u8 *>(&ptr) + 1);
@@ -36,19 +33,18 @@ inline void set(mana_offset_ptr_t &ptr, void *p)
         ptr.offset = 1;
     }
 }
+} // namespace detail
 
-inline void set(mana_offset_ptr_t &ptr, mana_data_type_t data_type, void *p)
+inline bool is_null(const mana_offset_ptr_t &ptr) { return ptr.offset == 1; }
-{
-    ptr.data_type = data_type;
-    detail::set(ptr, p);
-}
 
 inline void *get(mana_offset_ptr_t &ptr)
 {
     return is_null(ptr) ? nullptr : reinterpret_cast<u8 *>(&ptr) + ptr.offset;
 }
 
-template <typename T> T *get(mana_offset_ptr_t &ptr, mana_data_type_t expected)
+template <typename T> T *get(mana_offset_ptr_t &ptr); // to catch unsupported types
+
+template <typename T> T *get_(mana_offset_ptr_t &ptr, mana_data_type_t expected)
 {
     if (ptr.data_type != expected)
         return nullptr;
@@ -56,34 +52,26 @@ template <typename T> T *get(mana_offset_ptr_t &ptr, mana_data_type_t expected)
     return reinterpret_cast<T *>(get(ptr));
 }
 
-} // namespace detail
+template <> u32 *get(mana_offset_ptr_t &ptr) { return get_<u32>(ptr, mana_uint32); }
+template <> u64 *get(mana_offset_ptr_t &ptr) { return get_<u64>(ptr, mana_uint64); }
+template <> s8 *get(mana_offset_ptr_t &ptr) { return get_<s8>(ptr, mana_sint8); }
+template <> char *get(mana_offset_ptr_t &ptr) { return get_<char>(ptr, mana_sint8); }
+template <> float *get(mana_offset_ptr_t &ptr) { return get_<float>(ptr, mana_float); }
+template <> double *get(mana_offset_ptr_t &ptr) { return get_<double>(ptr, mana_double); }
 
-template <typename T> T *get(mana_offset_ptr_t &ptr); // to catch unsupported types
+inline void set(mana_offset_ptr_t &ptr, mana_data_type_t data_type, void *p)
-
-template <> u32 *get(mana_offset_ptr_t &ptr) { return detail::get<u32>(ptr, mana_uint32); }
-template <> u64 *get(mana_offset_ptr_t &ptr) { return detail::get<u64>(ptr, mana_uint64); }
-template <> s8 *get(mana_offset_ptr_t &ptr) { return detail::get<s8>(ptr, mana_sint8); }
-template <> char *get(mana_offset_ptr_t &ptr) { return detail::get<char>(ptr, mana_sint8); }
-template <> float *get(mana_offset_ptr_t &ptr) { return detail::get<float>(ptr, mana_float); }
-template <> double *get(mana_offset_ptr_t &ptr) { return detail::get<double>(ptr, mana_double); }
-
-// To make 'set(ptr, nullptr)' work.
-inline void set(mana_offset_ptr_t &ptr, std::nullptr_t)
 {
-    detail::set(ptr, ptr.data_type, nullptr);
+    ptr.data_type = data_type;
+    detail::set(ptr, p);
 }
 
-inline void set(mana_offset_ptr_t &ptr, u8 *p) { detail::set(ptr, mana_uint8, p); }
+inline void set(mana_offset_ptr_t &ptr, std::nullptr_t) { set(ptr, mana_uint32, nullptr); }
-inline void set(mana_offset_ptr_t &ptr, s8 *p) { detail::set(ptr, mana_sint8, p); }
+inline void set(mana_offset_ptr_t &ptr, u32 *p) { set(ptr, mana_uint32, p); }
-inline void set(mana_offset_ptr_t &ptr, char *p) { detail::set(ptr, mana_sint8, p); }
+inline void set(mana_offset_ptr_t &ptr, u64 *p) { set(ptr, mana_uint64, p); }
-inline void set(mana_offset_ptr_t &ptr, u16 *p) { detail::set(ptr, mana_uint16, p); }
+inline void set(mana_offset_ptr_t &ptr, s8 *p) { set(ptr, mana_sint8, p); }
-inline void set(mana_offset_ptr_t &ptr, s16 *p) { detail::set(ptr, mana_sint16, p); }
+inline void set(mana_offset_ptr_t &ptr, char *p) { set(ptr, mana_sint8, p); }
-inline void set(mana_offset_ptr_t &ptr, u32 *p) { detail::set(ptr, mana_uint32, p); }
+inline void set(mana_offset_ptr_t &ptr, float *p) { set(ptr, mana_float, p); }
-inline void set(mana_offset_ptr_t &ptr, s32 *p) { detail::set(ptr, mana_sint32, p); }
+inline void set(mana_offset_ptr_t &ptr, double *p) { set(ptr, mana_double, p); }
-inline void set(mana_offset_ptr_t &ptr, u64 *p) { detail::set(ptr, mana_uint64, p); }
-inline void set(mana_offset_ptr_t &ptr, s64 *p) { detail::set(ptr, mana_sint64, p); }
-inline void set(mana_offset_ptr_t &ptr, float *p) { detail::set(ptr, mana_float, p); }
-inline void set(mana_offset_ptr_t &ptr, double *p) { detail::set(ptr, mana_double, p); }
 
 template <typename T>
 T *push_offset_array(mana::Arena &arena, mana_offset_array_t &dest, size_t size)
@@ -98,7 +86,7 @@ template <typename T>
 T *push_typed_offset_array(mana::Arena &arena, mana_offset_array_t &dest, size_t size)
 {
     T *ptr = arena.push_t<T>(size);
-    set(dest.ptr, ptr);
+    mana::set(dest.ptr, ptr);
     dest.size_bytes = size * sizeof(T);
     return ptr;
 }
@@ -110,7 +98,7 @@ template <typename T> size_t element_count(mana_offset_array_t &array)
 
 template <typename T> mvlc::util::span<T> get_span(mana_offset_array_t &array)
 {
-    auto ptr = get<T>(array.ptr);
+    auto ptr = reinterpret_cast<T *>(get(array.ptr));
     auto size = element_count<T>(array);
     return {ptr, size};
 }