Merge commit '74b13b4d7049f9181b1241195324e85af2d9653a'

external/ircolib/.clang-format

@@ -0,0 +1,56 @@
+---
+Language: Cpp
+BasedOnStyle: LLVM
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignOperands: false
+AlignTrailingComments: false
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: false
+  AfterEnum: false
+  AfterFunction: false
+  AfterNamespace: false
+  AfterStruct: false
+  AfterUnion: false
+  AfterExternBlock: false
+  BeforeCatch: true
+  BeforeElse: false
+  BeforeLambdaBody: false
+  BeforeWhile: true
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakConstructorInitializers: AfterColon
+BreakConstructorInitializersBeforeComma: false
+ColumnLimit: 120
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+IndentAccessModifiers: false
+AccessModifierOffset: 0
+ContinuationIndentWidth: 0
+IncludeCategories:
+  - Regex: '^<.*'
+    Priority: 1
+  - Regex: '^".*'
+    Priority: 2
+  - Regex: '.*'
+    Priority: 3
+IncludeIsMainRegex: '([-_](test|unittest))?$'
+IndentCaseBlocks: true
+InsertNewlineAtEOF: true
+MacroBlockBegin: ''
+MacroBlockEnd: ''
+SortIncludes: Never
+MaxEmptyLinesToKeep: 2
+NamespaceIndentation: Inner
+SpaceInEmptyParentheses: false
+SpacesInAngles: false
+SpacesInConditionalStatement: false
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+TabWidth: 4
+IndentWidth: 4
+...

external/ircolib/file.hpp

@@ -1,5 +1,5 @@
 #pragma once
-#include <types.hpp>
+#include "types.hpp"
 #include <fstream>
 #include <vector>
 #include <filesystem>
@@ -7,29 +7,29 @@
 namespace fs = std::filesystem;
 
 namespace ircolib {
-static inline std::vector<u8> ReadFileBinary(const std::string &path) {
+static inline std::vector<u8> read_file_binary(const std::string &path) {
     std::ifstream file(path, std::ios::binary);
     return {std::istreambuf_iterator{file}, {}};
 }
 
-static inline void WriteFileBinary(const std::vector<u8> &data, const std::string &path) {
+static inline void write_file_binary(const std::vector<u8> &data, const std::string &path) {
     std::ofstream file(path, std::ios::binary);
     std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
 }
 
-static inline void WriteFileBinary(const u8 *data, const size_t size, const std::string &path) {
+static inline void write_file_binary(const u8 *data, const size_t size, const std::string &path) {
     FILE *out = fopen(path.c_str(), "wb");
     fwrite(data, size, 1, out);
     fclose(out);
 }
 
 template <size_t Size>
-static inline void WriteFileBinary(const std::array<u8, Size> &data, const std::string &path) {
+static inline void write_file_binary(const std::array<u8, Size> &data, const std::string &path) {
     std::ofstream file(path, std::ios::binary);
     std::copy(data.begin(), data.end(), std::ostreambuf_iterator{file});
 }
 
-static inline size_t NextPow2(size_t num) {
+static inline size_t next_pow2(size_t num) {
     // Taken from "Bit Twiddling Hacks" by Sean Anderson:
     // https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
     --num;
@@ -40,4 +40,4 @@ static inline size_t NextPow2(size_t num) {
     num |= num >> 16;
     return num + 1;
 }
-} // namespace Util
+} // namespace ircolib

external/ircolib/floats.hpp

@@ -1,6 +1,6 @@
 #pragma once
 #include <cmath>
-#include <types.hpp>
+#include "types.hpp"
 
 namespace ircolib {
 static inline auto roundCeil(float f) {
@@ -103,4 +103,4 @@ static inline auto roundTrunc(double f) {
     return trunc(f);
 #endif
 }
-} // namespace Util
+} // namespace ircolib

external/ircolib/mem_access.hpp

@@ -1,5 +1,6 @@
 #pragma once
-#include <types.hpp>
+#include "types.hpp"
+#include <cstddef>
 #include <cstring>
 #include <functional>
 #include <bit>
@@ -8,7 +9,7 @@
 #include <concepts>
 
 namespace ircolib {
-static inline std::vector<u8> IntegralToBuffer(const std::integral auto &val) {
+static inline std::vector<u8> integral_to_buffer(const std::integral auto &val) {
     std::vector<u8> ret{};
     ret.resize(sizeof(val));
 
@@ -17,65 +18,72 @@ static inline std::vector<u8> IntegralToBuffer(const std::integral auto &val) {
     return ret;
 }
 
-static inline constexpr bool IsInsideRange(const std::integral auto& addr,
+static inline auto integral_to_slice(const std::integral auto &val) -> std::array<u8, sizeof(val)> {
-                                                 const std::integral auto& start,
+    std::array<u8, sizeof(val)> ret{};
-                                                 const std::integral auto& end) {
+
+    memcpy(ret.data(), &val, sizeof(val));
+
+    return ret;
+}
+
+static inline constexpr bool is_inside_range(const std::integral auto &addr, const std::integral auto &start,
+                                             const std::integral auto &end) {
     return addr >= start && addr <= end;
 }
 
 template <typename T>
-static constexpr inline T ReadAccess(const u8 *data, const u32 index);
+static constexpr inline T read_access(const u8 *data, const u32 index);
 template <typename T>
-static constexpr inline T ReadAccess(const std::vector<u8> &data, const u32 index);
+static constexpr inline T read_access(const std::vector<u8> &data, const u32 index);
 template <typename T, size_t Size>
-static constexpr inline T ReadAccess(const std::array<u8, Size> &data, const u32 index);
+static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index);
 
 template <typename T>
-static constexpr inline void WriteAccess(u8 *data, const u32 index, const T val);
+static constexpr inline void write_access(u8 *data, const u32 index, const T val);
 template <typename T>
-static constexpr inline void WriteAccess(std::vector<u8> &data, const u32 index, const T val);
+static constexpr inline void write_access(std::vector<u8> &data, const u32 index, const T val);
 template <typename T, size_t Size>
-static constexpr inline void WriteAccess(std::array<u8, Size> &data, const u32 index, const T val);
+static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val);
 
 template <>
-constexpr inline u64 ReadAccess(const u8 *data, const u32 index) {
+constexpr inline u64 read_access(const u8 *data, const u32 index) {
     u32 hi = *reinterpret_cast<const u32 *>(&data[index + 0]);
     u32 lo = *reinterpret_cast<const u32 *>(&data[index + 4]);
-  const auto& result = static_cast<u64>(hi) << 32 | static_cast<u64>(lo);
+    const auto &result = static_cast<u64>(hi) << 32 | static_cast<u64>(lo);
     return result;
 }
 
 template <typename T>
-static constexpr inline T ReadAccess(const u8 *data, const u32 index) {
+static constexpr inline T read_access(const u8 *data, const u32 index) {
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
 template <>
-constexpr inline u64 ReadAccess(const std::vector<u8> &data, const u32 index) {
+constexpr inline u64 read_access(const std::vector<u8> &data, const u32 index) {
     u32 hi = *reinterpret_cast<const u32 *>(&data[index + 0]);
     u32 lo = *reinterpret_cast<const u32 *>(&data[index + 4]);
     return (static_cast<u64>(hi) << 32) | static_cast<u64>(lo);
 }
 
 template <typename T>
-static constexpr inline T ReadAccess(const std::vector<u8> &data, const u32 index) {
+static constexpr inline T read_access(const std::vector<u8> &data, const u32 index) {
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
 template <size_t Size>
-constexpr inline u64 ReadAccess(const std::array<u8, Size> &data, const u32 index) {
+constexpr inline u64 read_access(const std::array<u8, Size> &data, const u32 index) {
     u32 hi = *reinterpret_cast<const u32 *>(&data[index + 0]);
     u32 lo = *reinterpret_cast<const u32 *>(&data[index + 4]);
     return static_cast<u64>(hi) << 32 | static_cast<u64>(lo);
 }
 
 template <typename T, size_t Size>
-static constexpr inline T ReadAccess(const std::array<u8, Size> &data, const u32 index) {
+static constexpr inline T read_access(const std::array<u8, Size> &data, const u32 index) {
     return *reinterpret_cast<const T *>(&data[index]);
 }
 
 template <size_t Size>
-constexpr inline void WriteAccess(std::array<u8, Size> &data, const u32 index, const u64 val) {
+constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const u64 val) {
     const u32 hi = val >> 32;
     const u32 lo = val;
 
@@ -84,12 +92,12 @@ constexpr inline void WriteAccess(std::array<u8, Size> &data, const u32 index, c
 }
 
 template <typename T, size_t Size>
-static constexpr inline void WriteAccess(std::array<u8, Size> &data, const u32 index, const T val) {
+static constexpr inline void write_access(std::array<u8, Size> &data, const u32 index, const T val) {
     *reinterpret_cast<T *>(&data[index]) = val;
 }
 
 template <>
-constexpr inline void WriteAccess(std::vector<u8> &data, const u32 index, const u64 val) {
+constexpr inline void write_access(std::vector<u8> &data, const u32 index, const u64 val) {
     const u32 hi = val >> 32;
     const u32 lo = val;
 
@@ -98,12 +106,12 @@ constexpr inline void WriteAccess(std::vector<u8> &data, const u32 index, const
 }
 
 template <typename T>
-static constexpr inline void WriteAccess(std::vector<u8> &data, const u32 index, const T val) {
+static constexpr inline void write_access(std::vector<u8> &data, const u32 index, const T val) {
     *reinterpret_cast<T *>(&data[index]) = val;
 }
 
 template <>
-constexpr inline void WriteAccess(u8 *data, const u32 index, const u64 val) {
+constexpr inline void write_access(u8 *data, const u32 index, const u64 val) {
     const u32 hi = val >> 32;
     const u32 lo = val;
 
@@ -112,12 +120,12 @@ constexpr inline void WriteAccess(u8 *data, const u32 index, const u64 val) {
 }
 
 template <typename T>
-static constexpr inline void WriteAccess(u8 *data, const u32 index, const T val) {
+static constexpr inline void write_access(u8 *data, const u32 index, const T val) {
     *reinterpret_cast<T *>(&data[index]) = val;
 }
 
 template <typename T>
-static constexpr inline void SwapBuffer(std::vector<u8> &data) {
+static constexpr inline void swap_buffer(std::vector<u8> &data) {
     for (size_t i = 0; i < data.size(); i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
@@ -125,22 +133,28 @@ static constexpr inline void SwapBuffer(std::vector<u8> &data) {
 }
 
 template <typename T, size_t Size>
-static constexpr inline void SwapBuffer(std::array<u8, Size> &data) {
+static constexpr inline void swap_buffer(std::array<u8, Size> &data) {
     for (size_t i = 0; i < data.size(); i += sizeof(T)) {
         const T original = *reinterpret_cast<T *>(&data[i]);
         *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
     }
 }
 
+template <typename T>
+static constexpr inline void swap_buffer(u8 *data, size_t size) {
+    for (size_t i = 0; i < size; i += sizeof(T)) {
+        const T original = *reinterpret_cast<T *>(&data[i]);
+        *reinterpret_cast<T *>(&data[i]) = std::byteswap(original);
+    }
+}
+
 #ifdef _WIN32
 inline void *aligned_alloc(const size_t alignment, const size_t size) { return _aligned_malloc(size, alignment); }
 
 inline void aligned_free(void *ptr) { _aligned_free(ptr); }
 #else
-inline void *aligned_alloc(const size_t alignment, const size_t size) {
+inline void *aligned_alloc(const size_t alignment, const size_t size) { return std::aligned_alloc(alignment, size); }
-  return std::aligned_alloc(alignment, size);
-}
 
 inline void aligned_free(void *ptr) { std::free(ptr); }
 #endif
-} // namespace Util
+} // namespace ircolib

external/ircolib/types.hpp

@@ -10,4 +10,28 @@ using s8 = int8_t;
 using s16 = int16_t;
 using s32 = int32_t;
 using s64 = int64_t;
+
+template <typename T, std::size_t bit>
+static constexpr bool is_bit_set(const T &val) {
+    return val & (1 << bit);
 }
+
+template <typename T, std::size_t bit>
+static constexpr void set_bit(T &val) {
+    val |= 1 << bit;
+}
+
+template <typename T>
+inline bool is_bit_set(const T &val, const std::size_t &bit) {
+    return val & (1 << bit);
+}
+
+template <typename T>
+inline void set_bit(T &val, const std::size_t &bit) {
+    val |= 1 << bit;
+}
+} // namespace ircolib
+
+constexpr ircolib::u32 operator""_kib(const unsigned long long v) { return v * 1024; }
+constexpr ircolib::u32 operator""_mib(const unsigned long long v) { return v * 1024 * 1024; }
+constexpr ircolib::u32 operator""_gib(const unsigned long long v) { return v * 1024 * 1024 * 1024; }