Update sqmem.cpp

module/CMakeLists.txt

@@ -107,7 +107,6 @@ add_library(SqModule MODULE SqBase.hpp Main.cpp
     PocoLib/Crypto.cpp PocoLib/Crypto.hpp
     PocoLib/Data.cpp PocoLib/Data.hpp
     PocoLib/Net.cpp PocoLib/Net.hpp
-    PocoLib/RegEx.cpp PocoLib/RegEx.hpp
     PocoLib/Register.cpp PocoLib/Register.hpp
     PocoLib/Time.cpp PocoLib/Time.hpp
     PocoLib/Util.cpp PocoLib/Util.hpp
@@ -133,7 +132,7 @@ if(WIN32 OR MINGW)
     target_link_libraries(SqModule wsock32 ws2_32 shlwapi)
 endif()
 # Link to base libraries
-target_link_libraries(SqModule Squirrel fmt::fmt SimpleINI TinyDir xxHash ConcurrentQueue SAJSON CPR UTF8Lib PUGIXML CivetWeb maxminddb libzmq-static)
+target_link_libraries(SqModule RPMalloc Squirrel fmt::fmt SimpleINI TinyDir xxHash ConcurrentQueue SAJSON CPR UTF8Lib PUGIXML CivetWeb maxminddb libzmq-static)
 # Link to POCO libraries
 target_link_libraries(SqModule Poco::Foundation Poco::Crypto Poco::Data Poco::Net)
 # Does POCO have SQLite support?

module/Core/Common.hpp

@@ -40,6 +40,7 @@
 #include <sqratTable.h>
 #include <sqratUtil.h>
 #include <fmt/core.h>
+#include <rpmalloc.h>
 
 // ------------------------------------------------------------------------------------------------
 namespace SqMod {
@@ -173,7 +174,7 @@ void OutputError(const char * msg, ...);
 /* ------------------------------------------------------------------------------------------------
  * Generate a formatted string and throw it as a Sqrat exception.
 */
-template < class... Args > void SqThrowF(Args &&... args)
+template < class... Args > inline void SqThrowF(Args &&... args)
 {
     throw Sqrat::Exception(fmt::format(std::forward< Args >(args)...));
 }
@@ -181,7 +182,7 @@ template < class... Args > void SqThrowF(Args &&... args)
 /* ------------------------------------------------------------------------------------------------
  * Generate a formatted string and throw it as a squirrel exception.
 */
-template < class... Args > SQRESULT SqThrowErrorF(HSQUIRRELVM vm, Args &&... args)
+template < class... Args > inline SQRESULT SqThrowErrorF(HSQUIRRELVM vm, Args &&... args)
 {
     String msg;
     try
@@ -266,4 +267,93 @@ SQMOD_NODISCARD SQFloat PopStackFloat(HSQUIRRELVM vm, SQInteger idx);
 */
 SQMOD_NODISCARD bool SToB(const SQChar * str);
 
+/* ------------------------------------------------------------------------------------------------
+ * RAII allocator initializer.
+*/
+struct RPMallocInit
+{
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    RPMallocInit()
+    {
+        if (rpmalloc_initialize() != 0)
+        {
+             OutputError("Failed to initialize memory allocator");
+        }
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    RPMallocInit(const RPMallocInit &) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor (disabled).
+    */
+    RPMallocInit(RPMallocInit &&) noexcept = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~RPMallocInit()
+    {
+        if (rpmalloc_is_thread_initialized()) rpmalloc_finalize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    RPMallocInit & operator = (const RPMallocInit &) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    RPMallocInit & operator = (RPMallocInit &&) noexcept = delete;
+
+};
+
+/* ------------------------------------------------------------------------------------------------
+ * RAII allocator thread initializer.
+*/
+struct RPMallocThreadInit
+{
+    /* --------------------------------------------------------------------------------------------
+     * Default constructor.
+    */
+    RPMallocThreadInit()
+    {
+        rpmalloc_thread_initialize();
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy constructor (disabled).
+    */
+    RPMallocThreadInit(const RPMallocThreadInit &) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Move constructor (disabled).
+    */
+    RPMallocThreadInit(RPMallocThreadInit &&) noexcept = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Destructor.
+    */
+    ~RPMallocThreadInit()
+    {
+        if (rpmalloc_is_thread_initialized()) rpmalloc_thread_finalize(1);
+    }
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    RPMallocThreadInit & operator = (const RPMallocThreadInit &) = delete;
+
+    /* --------------------------------------------------------------------------------------------
+     * Copy assignment operator (disabled).
+    */
+    RPMallocThreadInit & operator = (RPMallocThreadInit &&) noexcept = delete;
+
+};
+
 } // Namespace:: SqMod

module/Core/ThreadPool.cpp

@@ -138,6 +138,8 @@ void ThreadPool::WorkerProc()
     bool retry = false;
     // Pointer to the dequeued item
     Item item;
+    // Initialize third-party allocator for this thread
+    auto rpmallocinit = std::make_unique< RPMallocThreadInit >();
     // Constantly process items from the queue
     while (true)
     {

module/Core/ThreadPool.hpp

@@ -171,7 +171,7 @@ public:
     void Process();
 
     /* --------------------------------------------------------------------------------------------
-     * Queue an item to be processed.
+     * Queue an item to be processed. Will take ownership of the given pointer!
     */
     void Enqueue(ThreadPoolItem * item)
     {
@@ -191,16 +191,18 @@ public:
         }
         else
         {
+            // Take ownership
+            Item i{item};
             // Perform the task in-place
-            if (item->OnPrepare())
+            if (i->OnPrepare())
             {
-                if (item->OnProcess())
+                if (i->OnProcess())
                 {
-                    item->OnAborted(true); // Not accepted in single thread
+                    i->OnAborted(true); // Not accepted in single thread
                 }
             }
-            // Item was finished in main thread
-            item->OnCompleted();
+            // Task is completed in processing stage
+            m_Finished.enqueue(std::move(i));
         }
     }
 

module/Core/VecMap.hpp

@@ -251,6 +251,20 @@ template < class Key, class T, class Pred = std::equal_to< Key > > struct VecMap
         return m_Storage.back().second;
     }
 
+    /* --------------------------------------------------------------------------------------------
+     * Retrieves a reference to the front of the container.
+     * Available for internal use only.
+    */
+    reference front() { return m_Storage.front(); }
+    const_reference front() const { return m_Storage.front(); }
+
+    /* --------------------------------------------------------------------------------------------
+     * Retrieves a reference to the back of the container.
+     * Available for internal use only.
+    */
+    reference back() { return m_Storage.back(); }
+    const_reference back() const { return m_Storage.back(); }
+
 private:
 
     /* --------------------------------------------------------------------------------------------

module/Library/Net.hpp

@@ -756,5 +756,4 @@ protected:
     }
 };
 
-
 } // Namespace:: SqMod

module/Library/RegEx.hpp

@@ -505,7 +505,7 @@ struct RxInstance
     RxInstance & operator = (const RxInstance &) = delete;
 
     /* --------------------------------------------------------------------------------------------
-     * Move constructor.
+     * Move assignment operator.
     */
     RxInstance & operator = (RxInstance && o) noexcept
     {

module/Logger.cpp

@@ -556,6 +556,21 @@ void Logger::ProcessMessage()
     }
 }
 
+// ------------------------------------------------------------------------------------------------
+void Logger::Send(uint8_t level, bool sub, const char * msg)
+{
+    // Is this level even allowed?
+    if ((m_ConsoleLevels & level) || (m_LogFileLevels & level))
+    {
+        // Create a new message builder
+        MsgPtr message(new Message(level, sub));
+        // Generate the log message
+        message->Append(msg);
+        // Process the message in the buffer
+        PushMessage(message);
+    }
+}
+
 // ------------------------------------------------------------------------------------------------
 void Logger::Send(uint8_t level, bool sub, const char * msg, size_t len)
 {

module/Logger.hpp

@@ -409,6 +409,11 @@ public:
     */
     void BindCb(uint8_t level, Function & func);
 
+    /* --------------------------------------------------------------------------------------------
+     * Send a log message.
+    */
+    void Send(uint8_t level, bool sub, const char * msg);
+
     /* --------------------------------------------------------------------------------------------
      * Send a log message.
     */

module/Main.cpp

@@ -965,6 +965,11 @@ static void OnServerPerformanceReport(size_t /*entry_count*/, const char * * /*d
 
 } // Namespace:: SqMod
 
+/* ------------------------------------------------------------------------------------------------
+ * Automatically terminate the third-party allocator.
+*/
+static std::unique_ptr< SqMod::RPMallocInit > gsRPMallocInit;
+
 /* ------------------------------------------------------------------------------------------------
  * Plug-in initialization procedure.
 */
@@ -989,6 +994,8 @@ SQMOD_API_EXPORT unsigned int VcmpPluginInit(PluginFuncs * funcs, PluginCallback
     _Info->apiMinorVersion = PLUGIN_API_MINOR;
     // Assign the plug-in name
     std::snprintf(_Info->name, sizeof(_Info->name), "%s", SQMOD_HOST_NAME);
+    // Initialize third-party allocator
+    gsRPMallocInit = std::make_unique< RPMallocInit >();
     // Attempt to initialize the logger before anything else
     Logger::Get().Initialize(nullptr);
     // Attempt to initialize the plug-in core

module/Misc/Player.cpp

@@ -113,8 +113,8 @@ int32_t GetSkinID(StackStrF & name)
 {
     // Clone the string into an editable version
     String str(name.mPtr, static_cast< size_t >(name.mLen));
-    // Strip non alphanumeric characters from the name
-    str.erase(std::remove_if(str.begin(), str.end(), std::not1(std::ptr_fun(::isalnum))), str.end());
+    // Strip non-alphanumeric characters from the name
+    str.erase(std::remove_if(str.begin(), str.end(), std::function<int(int)>(::isalnum)), str.end());
     // Convert the string to lowercase
     std::transform(str.begin(), str.end(), str.begin(), ::tolower);
     // See if we still have a valid name after the cleanup

module/Misc/Vehicle.cpp

@@ -122,8 +122,8 @@ int32_t GetAutomobileID(StackStrF & name)
 {
     // Clone the string into an editable version
     String str(name.mPtr, static_cast< size_t >(name.mLen));
-    // Strip non alphanumeric characters from the name
-    str.erase(std::remove_if(str.begin(), str.end(), std::not1(std::ptr_fun(::isalnum))), str.end());
+    // Strip non-alphanumeric characters from the name
+    str.erase(std::remove_if(str.begin(), str.end(), std::function<int(int)>(::isalnum)), str.end());
     // Convert the string to lowercase
     std::transform(str.begin(), str.end(), str.begin(), ::tolower);
     // See if we still have a valid name after the cleanup

module/Misc/Weapon.cpp

@@ -162,8 +162,8 @@ int32_t GetWeaponID(StackStrF & name)
 {
     // Clone the string into an editable version
     String str(name.mPtr, static_cast< size_t >(name.mLen));
-    // Strip non alphanumeric characters from the name
-    str.erase(std::remove_if(str.begin(), str.end(), std::not1(std::ptr_fun(::isalnum))), str.end());
+    // Strip non-alphanumeric characters from the name
+    str.erase(std::remove_if(str.begin(), str.end(), std::function<int(int)>(::isalnum)), str.end());
     // Convert the string to lowercase
     std::transform(str.begin(), str.end(), str.begin(), ::tolower);
     // See if we still have a valid name after the cleanup

module/PocoLib/RegEx.cpp

@@ -1,112 +0,0 @@
-// ------------------------------------------------------------------------------------------------
-#include "PocoLib/RegEx.hpp"
-
-// ------------------------------------------------------------------------------------------------
-#include <sqratConst.h>
-
-// ------------------------------------------------------------------------------------------------
-namespace SqMod {
-
-// ------------------------------------------------------------------------------------------------
-SQMOD_DECL_TYPENAME(SqRegEx, _SC("SqRegEx"))
-SQMOD_DECL_TYPENAME(SqRegExMatch, _SC("SqRegExMatch"))
-SQMOD_DECL_TYPENAME(SqRegExMatches, _SC("SqRegExMatches"))
-
-// ------------------------------------------------------------------------------------------------
-
-
-// ================================================================================================
-void Register_POCO_RegEx(HSQUIRRELVM vm, Table & ns)
-{
-    // --------------------------------------------------------------------------------------------
-    ns.Bind(_SC("RegExMatch"),
-        Class< PcRegExMatch >(vm, SqRegExMatch::Str)
-        // Constructors
-        .Ctor()
-        .Ctor< SQInteger >()
-        .Ctor< SQInteger, SQInteger >()
-        // Meta-methods
-        .SquirrelFunc(_SC("_typename"), &SqRegExMatch::Fn)
-        // Properties
-        .Prop(_SC("Offset"), &PcRegExMatch::GetOffset, &PcRegExMatch::SetOffset)
-        .Prop(_SC("Length"), &PcRegExMatch::GetLength, &PcRegExMatch::SetLength)
-    );
-    // --------------------------------------------------------------------------------------------
-    ns.Bind(_SC("RegExMatches"),
-        Class< PcRegExMatches >(vm, SqRegExMatches::Str)
-        // Constructors
-        .Ctor()
-        // Meta-methods
-        .SquirrelFunc(_SC("_typename"), &SqRegExMatches::Fn)
-        // Properties
-        .Prop(_SC("Front"), &PcRegExMatches::Front)
-        .Prop(_SC("Back"), &PcRegExMatches::Back)
-        .Prop(_SC("Empty"), &PcRegExMatches::Empty)
-        .Prop(_SC("Size"), &PcRegExMatches::Size)
-        .Prop(_SC("Capacity"), &PcRegExMatches::Capacity, &PcRegExMatches::Reserve)
-        // Member Methods
-        .Func(_SC("Get"), &PcRegExMatches::Get)
-        .Func(_SC("Reserve"), &PcRegExMatches::Reserve)
-        .Func(_SC("Compact"), &PcRegExMatches::Compact)
-        .Func(_SC("Clear"), &PcRegExMatches::Clear)
-        .Func(_SC("Pop"), &PcRegExMatches::Pop)
-        .Func(_SC("EraseAt"), &PcRegExMatches::EraseAt)
-        .Func(_SC("EraseFrom"), &PcRegExMatches::EraseFrom)
-        .Func(_SC("Each"), &PcRegExMatches::Each)
-        .Func(_SC("EachRange"), &PcRegExMatches::EachRange)
-        .Func(_SC("While"), &PcRegExMatches::While)
-        .Func(_SC("WhileRange"), &PcRegExMatches::WhileRange)
-    );
-    // --------------------------------------------------------------------------------------------
-    ns.Bind(_SC("RegEx"),
-        Class< PcRegEx, NoCopy< PcRegEx > >(vm, SqRegEx::Str)
-        // Constructors
-        .Ctor< StackStrF & >()
-        .Ctor< int, StackStrF & >()
-        .Ctor< int, bool, StackStrF & >()
-        // Meta-methods
-        .SquirrelFunc(_SC("_typename"), &SqRegEx::Fn)
-        // Member Methods
-        //.Func(_SC("Assign"), &PcRegEx::assign)
-        // Overloaded Member Methods
-        .FmtFunc(_SC("MatchFirst"), &PcRegEx::MatchFirst)
-        .FmtFunc(_SC("MatchFirstEx"), &PcRegEx::MatchFirst_)
-        .FmtFunc(_SC("MatchFirstFrom"), &PcRegEx::MatchFirstFrom)
-        .FmtFunc(_SC("MatchFirstFromEx"), &PcRegEx::MatchFirstFrom_)
-        .FmtFunc(_SC("Match"), &PcRegEx::Match)
-        .FmtFunc(_SC("MatchEx"), &PcRegEx::Match_)
-        .FmtFunc(_SC("MatchFrom"), &PcRegEx::MatchFrom)
-        .FmtFunc(_SC("MatchFromEx"), &PcRegEx::MatchFrom_)
-        .FmtFunc(_SC("Matches"), &PcRegEx::Matches)
-        .FmtFunc(_SC("MatchesEx"), &PcRegEx::Matches_)
-        .FmtFunc(_SC("MatchesEx2"), &PcRegEx::MatchesEx)
-    );
-    // --------------------------------------------------------------------------------------------
-    ConstTable(vm).Enum(_SC("SqRegExOption"), Enumeration(vm)
-        .Const(_SC("Caseless"),         static_cast< SQInteger >(Poco::RegularExpression::RE_CASELESS))
-        .Const(_SC("MultiLine"),        static_cast< SQInteger >(Poco::RegularExpression::RE_MULTILINE))
-        .Const(_SC("DotAll"),           static_cast< SQInteger >(Poco::RegularExpression::RE_DOTALL))
-        .Const(_SC("Extended"),         static_cast< SQInteger >(Poco::RegularExpression::RE_EXTENDED))
-        .Const(_SC("Anchored"),         static_cast< SQInteger >(Poco::RegularExpression::RE_ANCHORED))
-        .Const(_SC("DollarEndOnly"),    static_cast< SQInteger >(Poco::RegularExpression::RE_DOLLAR_ENDONLY))
-        .Const(_SC("Extra"),            static_cast< SQInteger >(Poco::RegularExpression::RE_EXTRA))
-        .Const(_SC("NotBOL"),           static_cast< SQInteger >(Poco::RegularExpression::RE_NOTBOL))
-        .Const(_SC("NotEOL"),           static_cast< SQInteger >(Poco::RegularExpression::RE_NOTEOL))
-        .Const(_SC("Ungreedy"),         static_cast< SQInteger >(Poco::RegularExpression::RE_UNGREEDY))
-        .Const(_SC("NotEmpty"),         static_cast< SQInteger >(Poco::RegularExpression::RE_NOTEMPTY))
-        .Const(_SC("UTF8"),             static_cast< SQInteger >(Poco::RegularExpression::RE_UTF8))
-        .Const(_SC("NoAutoCapture"),    static_cast< SQInteger >(Poco::RegularExpression::RE_NO_AUTO_CAPTURE))
-        .Const(_SC("NoUTF8Check"),      static_cast< SQInteger >(Poco::RegularExpression::RE_NO_UTF8_CHECK))
-        .Const(_SC("FirstLine"),        static_cast< SQInteger >(Poco::RegularExpression::RE_FIRSTLINE))
-        .Const(_SC("DupNames"),         static_cast< SQInteger >(Poco::RegularExpression::RE_DUPNAMES))
-        .Const(_SC("NewLineCR"),        static_cast< SQInteger >(Poco::RegularExpression::RE_NEWLINE_CR))
-        .Const(_SC("NewLineLF"),        static_cast< SQInteger >(Poco::RegularExpression::RE_NEWLINE_LF))
-        .Const(_SC("NewLineCRLF"),      static_cast< SQInteger >(Poco::RegularExpression::RE_NEWLINE_CRLF))
-        .Const(_SC("NewLineAny"),       static_cast< SQInteger >(Poco::RegularExpression::RE_NEWLINE_ANY))
-        .Const(_SC("NewLineAnyCRLF"),   static_cast< SQInteger >(Poco::RegularExpression::RE_NEWLINE_ANYCRLF))
-        .Const(_SC("Global"),           static_cast< SQInteger >(Poco::RegularExpression::RE_GLOBAL))
-        .Const(_SC("NoVars"),           static_cast< SQInteger >(Poco::RegularExpression::RE_NO_VARS))
-    );
-}
-
-} // Namespace:: SqMod

module/PocoLib/RegEx.hpp

@@ -1,481 +0,0 @@
-#pragma once
-
-// ------------------------------------------------------------------------------------------------
-#include "Core/Utility.hpp"
-
-// ------------------------------------------------------------------------------------------------
-#include <algorithm>
-
-// ------------------------------------------------------------------------------------------------
-#include <Poco/RegularExpression.h>
-
-// ------------------------------------------------------------------------------------------------
-namespace SqMod {
-
-/* ------------------------------------------------------------------------------------------------
- * 
-*/
-struct PcRegExMatch : public Poco::RegularExpression::Match
-{
-    /* --------------------------------------------------------------------------------------------
-     * Default constructor.
-    */
-    PcRegExMatch() noexcept
-        : Poco::RegularExpression::Match{}
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Offset constructor.
-    */
-    explicit PcRegExMatch(SQInteger offset) noexcept
-        : Poco::RegularExpression::Match{static_cast< std::string::size_type >(offset), 0}
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    PcRegExMatch(SQInteger offset, SQInteger length) noexcept
-        : Poco::RegularExpression::Match{
-            static_cast< std::string::size_type >(offset),
-            static_cast< std::string::size_type >(length)
-        }
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy constructor.
-    */
-    PcRegExMatch(const PcRegExMatch & o) = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Move constructor.
-    */
-    PcRegExMatch(PcRegExMatch && o) noexcept = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy assignment operator.
-    */
-    PcRegExMatch & operator = (const PcRegExMatch & o) = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Move assignment operator.
-    */
-    PcRegExMatch & operator = (PcRegExMatch && o) noexcept = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve offset.
-    */
-    SQMOD_NODISCARD SQInteger GetOffset() const noexcept
-    {
-        return static_cast< SQInteger >(Poco::RegularExpression::Match::offset);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Modify offset.
-    */
-    void SetOffset(SQInteger value) noexcept
-    {
-        Poco::RegularExpression::Match::offset = static_cast< std::string::size_type >(value);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve length.
-    */
-    SQMOD_NODISCARD SQInteger GetLength() const noexcept
-    {
-        return static_cast< SQInteger >(Poco::RegularExpression::Match::length);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Modify length.
-    */
-    void SetLength(SQInteger value) noexcept
-    {
-        Poco::RegularExpression::Match::length = static_cast< std::string::size_type >(value);
-    }
-};
-
-/* ------------------------------------------------------------------------------------------------
- * 
-*/
-struct PcRegExMatches
-{
-    using List = Poco::RegularExpression::MatchVec;
-
-    /* --------------------------------------------------------------------------------------------
-     * Internal RegularExpression instance.
-    */
-    List m_List;
-
-    /* --------------------------------------------------------------------------------------------
-     * Default constructor.
-    */
-    PcRegExMatches() = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy list constructor.
-    */
-    explicit PcRegExMatches(const List & l) // NOLINT(modernize-pass-by-value)
-        : m_List{l}
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Move list constructor.
-    */
-    explicit PcRegExMatches(List && m) noexcept
-        : m_List{std::move(m)}
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy constructor.
-    */
-    PcRegExMatches(const PcRegExMatches & o) = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Move constructor.
-    */
-    PcRegExMatches(PcRegExMatches && o) noexcept = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy assignment operator.
-    */
-    PcRegExMatches & operator = (const PcRegExMatches & o) = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Move assignment operator.
-    */
-    PcRegExMatches & operator = (PcRegExMatches && o) noexcept = default;
-
-    /* --------------------------------------------------------------------------------------------
-     * Make sure an index is within range and return the container. Container must exist.
-    */
-    List & ValidIdx(SQInteger i)
-    {
-        if (static_cast< size_t >(i) >= m_List.size())
-        {
-            STHROWF("Invalid RegEx match list index({})", i);
-        }
-        return m_List;
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Make sure an index is within range and return the container. Container must exist.
-    */
-    SQMOD_NODISCARD const List & ValidIdx(SQInteger i) const
-    {
-        if (static_cast< size_t >(i) >= m_List.size())
-        {
-            STHROWF("Invalid RegEx match list index({})", i);
-        }
-        return m_List;
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Make sure a container instance is populated, then return it.
-    */
-    SQMOD_NODISCARD List & ValidPop()
-    {
-        if (m_List.empty())
-        {
-            STHROWF("RegEx match list container is empty");
-        }
-        return m_List;
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve a value from the container.
-    */
-    SQMOD_NODISCARD List::reference Get(SQInteger i)
-    {
-        return ValidIdx(i).at(ClampL< SQInteger, size_t >(i));
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve the first element in the container.
-    */
-    SQMOD_NODISCARD List::reference Front()
-    {
-        return ValidPop().front();
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve the last element in the container.
-    */
-    SQMOD_NODISCARD List::reference Back()
-    {
-        return m_List.back();
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Check if the container has no elements.
-    */
-    SQMOD_NODISCARD bool Empty() const
-    {
-        return m_List.empty();
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve the number of elements in the container.
-    */
-    SQMOD_NODISCARD SQInteger Size() const
-    {
-        return static_cast< SQInteger >(m_List.size());
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Retrieve the number of elements that the container has currently allocated space for.
-    */
-    SQMOD_NODISCARD SQInteger Capacity() const
-    {
-        return static_cast< SQInteger >(m_List.capacity());
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Increase the capacity of the container to a value that's greater or equal to the one specified.
-    */
-    PcRegExMatches & Reserve(SQInteger n)
-    {
-        m_List.reserve(ClampL< SQInteger, size_t >(n));
-        return *this;
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Request the removal of unused capacity.
-    */
-    void Compact()
-    {
-        m_List.shrink_to_fit();
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Erase all elements from the container.
-    */
-    void Clear()
-    {
-        m_List.clear();
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Pop the last element in the container.
-    */
-    void Pop()
-    {
-        ValidPop().pop_back();
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Erase the element at a certain position.
-    */
-    void EraseAt(SQInteger i)
-    {
-        m_List.erase(ValidIdx(i).begin() + static_cast< size_t >(i));
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Erase a certain amount of elements starting from a specific position.
-    */
-    void EraseFrom(SQInteger i, SQInteger n)
-    {
-        m_List.erase(ValidIdx(i).begin() + static_cast< size_t >(i),
-                        ValidIdx(i + n).begin() + static_cast< size_t >(i + n));
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Iterate all values through a functor.
-    */
-    void Each(Function & fn) const
-    {
-        for (const auto & e : m_List)
-        {
-            fn.Execute(static_cast< SQInteger >(e.offset), static_cast< SQInteger >(e.length));
-        }
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Iterate values in range through a functor.
-    */
-    void EachRange(SQInteger p, SQInteger n, Function & fn) const
-    {
-        std::for_each(ValidIdx(p).begin() + static_cast< size_t >(p),
-                      ValidIdx(p + n).begin() + static_cast< size_t >(p + n),
-        [&](List::const_reference & e) {
-            fn.Execute(static_cast< SQInteger >(e.offset), static_cast< SQInteger >(e.length));
-        });
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Iterate all values through a functor until stopped (i.e false is returned).
-    */
-    void While(Function & fn) const
-    {
-        for (const auto & e : m_List)
-        {
-            auto ret = fn.Eval(static_cast< SQInteger >(e.offset), static_cast< SQInteger >(e.length));
-            // (null || true) == continue & false == break
-            if (!ret.IsNull() || !ret.template Cast< bool >())
-            {
-                break;
-            }
-        }
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Iterate values in range through a functor until stopped (i.e false is returned).
-    */
-    void WhileRange(SQInteger p, SQInteger n, Function & fn) const
-    {
-        auto itr = ValidIdx(p).begin() + static_cast< size_t >(p);
-        auto end = ValidIdx(p + n).begin() + static_cast< size_t >(p + n);
-        for (; itr != end; ++itr)
-        {
-            auto ret = fn.Eval(static_cast< SQInteger >(itr->offset), static_cast< SQInteger >(itr->length));
-            // (null || true) == continue & false == break
-            if (!ret.IsNull() || !ret.template Cast< bool >())
-            {
-                break;
-            }
-        }
-    }
-};
-
-/* ------------------------------------------------------------------------------------------------
- * A class for working with regular expressions.
- * Implemented using PCRE, the Perl Compatible Regular Expressions library. (see http://www.pcre.org)
-*/
-struct PcRegEx
-{
-    /* --------------------------------------------------------------------------------------------
-     * Internal RegularExpression instance.
-    */
-    Poco::RegularExpression m_Rx;
-
-    /* --------------------------------------------------------------------------------------------
-     * Base constructor.
-    */
-    explicit PcRegEx(StackStrF & str)
-        : m_Rx(str.ToStr())
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    PcRegEx(int options, StackStrF & str)
-        : m_Rx(str.ToStr(), options)
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Explicit constructor.
-    */
-    PcRegEx(int options, bool study, StackStrF & str)
-        : m_Rx(str.ToStr(), options, study)
-    {
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy constructor. (disabled)
-    */
-    PcRegEx(const PcRegEx & o) = delete;
-
-    /* --------------------------------------------------------------------------------------------
-     * Move constructor. (disabled)
-    */
-    PcRegEx(PcRegEx && o) = delete;
-
-    /* --------------------------------------------------------------------------------------------
-     * Copy assignment operator. (disabled)
-    */
-    PcRegEx & operator = (const PcRegEx & o) = delete;
-
-    /* --------------------------------------------------------------------------------------------
-     * Move assignment operator. (disabled)
-    */
-    PcRegEx & operator = (PcRegEx && o) = delete;
-
-    /* --------------------------------------------------------------------------------------------
-     * Matches the given subject string against the pattern.
-     * Returns the position of the first captured sub-string in m.
-     * If no part of the subject matches the pattern, m.offset is std::string::npos and m.length is 0.
-     * Returns the number of matches. Throws a exception in case of an error.
-    */
-    SQMOD_NODISCARD int MatchFirst(PcRegExMatch & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), m);
-    }
-    SQMOD_NODISCARD int MatchFirst_(int f, PcRegExMatch & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), m, f);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Matches the given subject string against the pattern.
-     * Returns the position of the first captured sub-string in m.
-     * If no part of the subject matches the pattern, m.offset is std::string::npos and m.length is 0.
-     * Returns the number of matches. Throws a exception in case of an error.
-    */
-    SQMOD_NODISCARD int MatchFirstFrom(SQInteger o, PcRegExMatch & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), static_cast< std::string::size_type >(o), m);
-    }
-    SQMOD_NODISCARD int MatchFirstFrom_(int f, SQInteger o, PcRegExMatch & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), static_cast< std::string::size_type >(o), m, f);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Matches the given subject string against the pattern.
-     * The first entry in m contains the position of the captured sub-string.
-     * The following entries identify matching subpatterns. See the PCRE documentation for a more detailed explanation.
-     * If no part of the subject matches the pattern, m is empty.
-     * Returns the number of matches. Throws a exception in case of an error.
-    */
-    SQMOD_NODISCARD int Match(PcRegExMatches & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), 0, m.m_List);
-    }
-    SQMOD_NODISCARD int Match_(int f, PcRegExMatches & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), 0, m.m_List, f);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Matches the given subject string against the pattern.
-     * The first entry in m contains the position of the captured sub-string.
-     * The following entries identify matching subpatterns. See the PCRE documentation for a more detailed explanation.
-     * If no part of the subject matches the pattern, m is empty.
-     * Returns the number of matches. Throws a exception in case of an error.
-    */
-    SQMOD_NODISCARD int MatchFrom(SQInteger o, PcRegExMatches & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), static_cast< std::string::size_type >(o), m.m_List);
-    }
-    SQMOD_NODISCARD int MatchFrom_(int f, SQInteger o, PcRegExMatches & m, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), static_cast< std::string::size_type >(o), m.m_List, f);
-    }
-
-    /* --------------------------------------------------------------------------------------------
-     * Returns true if and only if the subject matches the regular expression.
-     * Internally, this method sets the RE_ANCHORED and RE_NOTEMPTY options for matching,
-     * which means that the empty string will never match and the pattern is treated as if it starts with a ^.
-    */
-    SQMOD_NODISCARD bool Matches(StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr());
-    }
-    SQMOD_NODISCARD bool Matches_(SQInteger o, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), static_cast< std::string::size_type >(o));
-    }
-    SQMOD_NODISCARD bool MatchesEx(int f, SQInteger o, StackStrF & s) const
-    {
-        return m_Rx.match(s.ToStr(), static_cast< std::string::size_type >(o), f);
-    }
-};
-
-} // Namespace:: SqMod

module/PocoLib/Register.cpp

@@ -8,7 +8,6 @@ namespace SqMod {
 extern void Register_POCO_Crypto(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Data(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Net(HSQUIRRELVM vm, Table & ns);
-extern void Register_POCO_RegEx(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Time(HSQUIRRELVM vm, Table & ns);
 extern void Register_POCO_Util(HSQUIRRELVM vm, Table & ns);
 
@@ -20,7 +19,6 @@ void Register_POCO(HSQUIRRELVM vm)
 	Register_POCO_Crypto(vm, ns);
 	Register_POCO_Data(vm, ns);
 	Register_POCO_Net(vm, ns);
-	Register_POCO_RegEx(vm, ns);
 	Register_POCO_Time(vm, ns);
 	Register_POCO_Util(vm, ns);
 

module/Sqrat/sqratClass.h

@@ -29,6 +29,7 @@
 
 #include <squirrelex.h>
 
+#include <cstring>
 #include <typeinfo>
 
 #include "sqratObject.h"
@@ -661,6 +662,80 @@ public:
         return *this;
     }
 
+protected:
+
+    // Used internally to proxy calls to wrapped squirrel methods.
+    template < class T = C, SQInteger(T::*Mptr)(HSQUIRRELVM) > static SQInteger SquirrelMethodProxy(HSQUIRRELVM vm) noexcept
+    {
+        try {
+            return ((::Sqrat::Var<T*>(vm, 1).value)->*Mptr)(vm);
+        } catch (const Poco::Exception& e) {
+            return sq_throwerror(vm, e.displayText().c_str());
+        } catch (const std::exception& e) {
+            return sq_throwerror(vm, e.what());
+        } catch (...) {
+            return sq_throwerror(vm, _SC("unknown exception occured"));
+        }
+    }
+
+    // Used internally to proxy calls to wrapped squirrel methods.
+    template < class T = C, SQInteger(T::*Mptr)(HSQUIRRELVM) const > static SQInteger SquirrelMethodProxy(HSQUIRRELVM vm) noexcept
+    {
+        try {
+            return ((::Sqrat::Var<T*>(vm, 1).value)->*Mptr)(vm);
+        } catch (const Poco::Exception& e) {
+            return sq_throwerror(vm, e.displayText().c_str());
+        } catch (const std::exception& e) {
+            return sq_throwerror(vm, e.what());
+        } catch (...) {
+            return sq_throwerror(vm, _SC("unknown exception occured"));
+        }
+    }
+
+public:
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Binds a class method that is treated as a squirrel function but invoked on the instance itself
+    ///
+    /// \param name Name of the function as it will appear in Squirrel
+    /// \param func Function to bind
+    ///
+    /// \return The Class itself so the call can be chained
+    ///
+    /// \remarks
+    /// Inside of the function, the class instance the function was called with will be at index 1 on the
+    /// stack and all arguments will be after that index in the order they were given to the function.
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template < class T = C, SQInteger(T::*Mptr)(HSQUIRRELVM) > Class& SquirrelMethod(const SQChar* name) {
+        return SquirrelFunc(name, &SquirrelMethodProxy< T, Mptr >);
+    }
+    template < class T = C, SQInteger(T::*Mptr)(HSQUIRRELVM) const > Class& SquirrelMethod(const SQChar* name) {
+        return SquirrelFunc(name, &SquirrelMethodProxy< T, Mptr >);
+    }
+
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /// Binds a class method that is treated as a squirrel function but invoked on the instance itself
+    ///
+    /// \param name Name of the function as it will appear in Squirrel
+    /// \param func Function to bind
+    /// \param pnum Number of parameters the function expects.
+    /// \param mask Types of parameters the function expects.
+    ///
+    /// \return The Class itself so the call can be chained
+    ///
+    /// \remarks
+    /// Inside of the function, the class instance the function was called with will be at index 1 on the
+    /// stack and all arguments will be after that index in the order they were given to the function.
+    ///
+    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    template < class T = C, SQInteger(T::*Mptr)(HSQUIRRELVM) > Class& SquirrelMethod(const SQChar* name, SQInteger pnum, const SQChar * mask) {
+        return SquirrelFunc(name, &SquirrelMethodProxy< T, Mptr >, pnum, mask);
+    }
+    template < class T = C, SQInteger(T::*Mptr)(HSQUIRRELVM) const > Class& SquirrelMethod(const SQChar* name, SQInteger pnum, const SQChar * mask) {
+        return SquirrelFunc(name, &SquirrelMethodProxy< T, Mptr >, pnum, mask);
+    }
+
     /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     /// Gets a Function from a name in the Class
     ///

module/Sqrat/sqratMemberMethods.h

@@ -157,7 +157,7 @@ template <class C,class R> struct SqMember {
             } catch (const std::exception& e) {
                 return sq_throwerror(vm, e.what());
             } catch (...) {
-                return sq_throwerror(vm, _SC("unknown exception occured"));
+                return sq_throwerror(vm, _SC("unknown exception occurred"));
             }
             SQ_UNREACHABLE
         };
@@ -178,7 +178,7 @@ template <class C,class R> struct SqMember {
             } catch (const std::exception& e) {
                 return sq_throwerror(vm, e.what());
             } catch (...) {
-                return sq_throwerror(vm, _SC("unknown exception occured"));
+                return sq_throwerror(vm, _SC("unknown exception occurred"));
             }
             SQ_UNREACHABLE
         };
@@ -206,7 +206,7 @@ template <class C, class R> struct SqMember<C,R&> {
             } catch (const std::exception& e) {
                 return sq_throwerror(vm, e.what());
             } catch (...) {
-                return sq_throwerror(vm, _SC("unknown exception occured"));
+                return sq_throwerror(vm, _SC("unknown exception occurred"));
             }
             SQ_UNREACHABLE
         };
@@ -227,7 +227,7 @@ template <class C, class R> struct SqMember<C,R&> {
             } catch (const std::exception& e) {
                 return sq_throwerror(vm, e.what());
             } catch (...) {
-                return sq_throwerror(vm, _SC("unknown exception occured"));
+                return sq_throwerror(vm, _SC("unknown exception occurred"));
             }
             SQ_UNREACHABLE
         };
@@ -256,7 +256,7 @@ template <class C> struct SqMember<C, void> {
             } catch (const std::exception& e) {
                 return sq_throwerror(vm, e.what());
             } catch (...) {
-                return sq_throwerror(vm, _SC("unknown exception occured"));
+                return sq_throwerror(vm, _SC("unknown exception occurred"));
             }
             SQ_UNREACHABLE
         };
@@ -277,7 +277,7 @@ template <class C> struct SqMember<C, void> {
             } catch (const std::exception& e) {
                 return sq_throwerror(vm, e.what());
             } catch (...) {
-                return sq_throwerror(vm, _SC("unknown exception occured"));
+                return sq_throwerror(vm, _SC("unknown exception occurred"));
             }
             SQ_UNREACHABLE
         };

vendor/CMakeLists.txt

@@ -1,6 +1,7 @@
 add_subdirectory(ConcurrentQueue)
 add_subdirectory(Fmt)
 add_subdirectory(xxHash)
+add_subdirectory(RPMalloc)
 add_subdirectory(Squirrel)
 add_subdirectory(SimpleIni)
 add_subdirectory(TinyDir)

vendor/RPMalloc/CMakeLists.txt

@@ -0,0 +1,13 @@
+# Create library
+add_library(RPMalloc STATIC include/rpmalloc.h rpmalloc.c)
+# Configure include folders
+target_include_directories(RPMalloc PRIVATE ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(RPMalloc PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
+# Configure macro options
+target_compile_definitions(RPMalloc PRIVATE _WIN32_WINNT=0x0601)
+# Debug options
+if (CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_compile_definitions(RPMalloc PUBLIC _DEBUG ENABLE_VALIDATE_ARGS=1)
+else()
+    target_compile_definitions(RPMalloc PUBLIC NDEBUG)
+endif()

vendor/RPMalloc/include/rpmalloc.h

@@ -0,0 +1,369 @@
+/* rpmalloc.h  -  Memory allocator  -  Public Domain  -  2016 Mattias Jansson
+ *
+ * This library provides a cross-platform lock free thread caching malloc implementation in C11.
+ * The latest source code is always available at
+ *
+ * https://github.com/mjansson/rpmalloc
+ *
+ * This library is put in the public domain; you can redistribute it and/or modify it without any restrictions.
+ *
+ */
+
+#pragma once
+
+#include <stddef.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(__clang__) || defined(__GNUC__)
+# define RPMALLOC_EXPORT __attribute__((visibility("default")))
+# define RPMALLOC_ALLOCATOR 
+# if (defined(__clang_major__) && (__clang_major__ < 4)) || (defined(__GNUC__) && defined(ENABLE_PRELOAD) && ENABLE_PRELOAD)
+# define RPMALLOC_ATTRIB_MALLOC
+# define RPMALLOC_ATTRIB_ALLOC_SIZE(size)
+# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count, size)
+# else
+# define RPMALLOC_ATTRIB_MALLOC __attribute__((__malloc__))
+# define RPMALLOC_ATTRIB_ALLOC_SIZE(size) __attribute__((alloc_size(size)))
+# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count, size)  __attribute__((alloc_size(count, size)))
+# endif
+# define RPMALLOC_CDECL
+#elif defined(_MSC_VER)
+# define RPMALLOC_EXPORT
+# define RPMALLOC_ALLOCATOR __declspec(allocator) __declspec(restrict)
+# define RPMALLOC_ATTRIB_MALLOC
+# define RPMALLOC_ATTRIB_ALLOC_SIZE(size)
+# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count,size)
+# define RPMALLOC_CDECL __cdecl
+#else
+# define RPMALLOC_EXPORT
+# define RPMALLOC_ALLOCATOR
+# define RPMALLOC_ATTRIB_MALLOC
+# define RPMALLOC_ATTRIB_ALLOC_SIZE(size)
+# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count,size)
+# define RPMALLOC_CDECL
+#endif
+
+//! Define RPMALLOC_CONFIGURABLE to enable configuring sizes. Will introduce
+//  a very small overhead due to some size calculations not being compile time constants
+#ifndef RPMALLOC_CONFIGURABLE
+#define RPMALLOC_CONFIGURABLE 0
+#endif
+
+//! Define RPMALLOC_FIRST_CLASS_HEAPS to enable heap based API (rpmalloc_heap_* functions).
+//  Will introduce a very small overhead to track fully allocated spans in heaps
+#ifndef RPMALLOC_FIRST_CLASS_HEAPS
+#define RPMALLOC_FIRST_CLASS_HEAPS 0
+#endif
+
+//! Flag to rpaligned_realloc to not preserve content in reallocation
+#define RPMALLOC_NO_PRESERVE    1
+//! Flag to rpaligned_realloc to fail and return null pointer if grow cannot be done in-place,
+//  in which case the original pointer is still valid (just like a call to realloc which failes to allocate
+//  a new block).
+#define RPMALLOC_GROW_OR_FAIL   2
+
+typedef struct rpmalloc_global_statistics_t {
+	//! Current amount of virtual memory mapped, all of which might not have been committed (only if ENABLE_STATISTICS=1)
+	size_t mapped;
+	//! Peak amount of virtual memory mapped, all of which might not have been committed (only if ENABLE_STATISTICS=1)
+	size_t mapped_peak;
+	//! Current amount of memory in global caches for small and medium sizes (<32KiB)
+	size_t cached;
+	//! Current amount of memory allocated in huge allocations, i.e larger than LARGE_SIZE_LIMIT which is 2MiB by default (only if ENABLE_STATISTICS=1)
+	size_t huge_alloc;
+	//! Peak amount of memory allocated in huge allocations, i.e larger than LARGE_SIZE_LIMIT which is 2MiB by default (only if ENABLE_STATISTICS=1)
+	size_t huge_alloc_peak;
+	//! Total amount of memory mapped since initialization (only if ENABLE_STATISTICS=1)
+	size_t mapped_total;
+	//! Total amount of memory unmapped since initialization  (only if ENABLE_STATISTICS=1)
+	size_t unmapped_total;
+} rpmalloc_global_statistics_t;
+
+typedef struct rpmalloc_thread_statistics_t {
+	//! Current number of bytes available in thread size class caches for small and medium sizes (<32KiB)
+	size_t sizecache;
+	//! Current number of bytes available in thread span caches for small and medium sizes (<32KiB)
+	size_t spancache;
+	//! Total number of bytes transitioned from thread cache to global cache (only if ENABLE_STATISTICS=1)
+	size_t thread_to_global;
+	//! Total number of bytes transitioned from global cache to thread cache (only if ENABLE_STATISTICS=1)
+	size_t global_to_thread;
+	//! Per span count statistics (only if ENABLE_STATISTICS=1)
+	struct {
+		//! Currently used number of spans
+		size_t current;
+		//! High water mark of spans used
+		size_t peak;
+		//! Number of spans transitioned to global cache
+		size_t to_global;
+		//! Number of spans transitioned from global cache
+		size_t from_global;
+		//! Number of spans transitioned to thread cache
+		size_t to_cache;
+		//! Number of spans transitioned from thread cache
+		size_t from_cache;
+		//! Number of spans transitioned to reserved state
+		size_t to_reserved;
+		//! Number of spans transitioned from reserved state
+		size_t from_reserved;
+		//! Number of raw memory map calls (not hitting the reserve spans but resulting in actual OS mmap calls)
+		size_t map_calls;
+	} span_use[64];
+	//! Per size class statistics (only if ENABLE_STATISTICS=1)
+	struct {
+		//! Current number of allocations
+		size_t alloc_current;
+		//! Peak number of allocations
+		size_t alloc_peak;
+		//! Total number of allocations
+		size_t alloc_total;
+		//! Total number of frees
+		size_t free_total;
+		//! Number of spans transitioned to cache
+		size_t spans_to_cache;
+		//! Number of spans transitioned from cache
+		size_t spans_from_cache;
+		//! Number of spans transitioned from reserved state
+		size_t spans_from_reserved;
+		//! Number of raw memory map calls (not hitting the reserve spans but resulting in actual OS mmap calls)
+		size_t map_calls;
+	} size_use[128];
+} rpmalloc_thread_statistics_t;
+
+typedef struct rpmalloc_config_t {
+	//! Map memory pages for the given number of bytes. The returned address MUST be
+	//  aligned to the rpmalloc span size, which will always be a power of two.
+	//  Optionally the function can store an alignment offset in the offset variable
+	//  in case it performs alignment and the returned pointer is offset from the
+	//  actual start of the memory region due to this alignment. The alignment offset
+	//  will be passed to the memory unmap function. The alignment offset MUST NOT be
+	//  larger than 65535 (storable in an uint16_t), if it is you must use natural
+	//  alignment to shift it into 16 bits. If you set a memory_map function, you
+	//  must also set a memory_unmap function or else the default implementation will
+	//  be used for both. This function must be thread safe, it can be called by
+	//  multiple threads simultaneously.
+	void* (*memory_map)(size_t size, size_t* offset);
+	//! Unmap the memory pages starting at address and spanning the given number of bytes.
+	//  If release is set to non-zero, the unmap is for an entire span range as returned by
+	//  a previous call to memory_map and that the entire range should be released. The
+	//  release argument holds the size of the entire span range. If release is set to 0,
+	//  the unmap is a partial decommit of a subset of the mapped memory range.
+	//  If you set a memory_unmap function, you must also set a memory_map function or
+	//  else the default implementation will be used for both. This function must be thread
+	//  safe, it can be called by multiple threads simultaneously.
+	void (*memory_unmap)(void* address, size_t size, size_t offset, size_t release);
+	//! Called when an assert fails, if asserts are enabled. Will use the standard assert()
+	//  if this is not set.
+	void (*error_callback)(const char* message);
+	//! Called when a call to map memory pages fails (out of memory). If this callback is
+	//  not set or returns zero the library will return a null pointer in the allocation
+	//  call. If this callback returns non-zero the map call will be retried. The argument
+	//  passed is the number of bytes that was requested in the map call. Only used if
+	//  the default system memory map function is used (memory_map callback is not set).
+	int (*map_fail_callback)(size_t size);
+	//! Size of memory pages. The page size MUST be a power of two. All memory mapping
+	//  requests to memory_map will be made with size set to a multiple of the page size.
+	//  Used if RPMALLOC_CONFIGURABLE is defined to 1, otherwise system page size is used.
+	size_t page_size;
+	//! Size of a span of memory blocks. MUST be a power of two, and in [4096,262144]
+	//  range (unless 0 - set to 0 to use the default span size). Used if RPMALLOC_CONFIGURABLE
+	//  is defined to 1.
+	size_t span_size;
+	//! Number of spans to map at each request to map new virtual memory blocks. This can
+	//  be used to minimize the system call overhead at the cost of virtual memory address
+	//  space. The extra mapped pages will not be written until actually used, so physical
+	//  committed memory should not be affected in the default implementation. Will be
+	//  aligned to a multiple of spans that match memory page size in case of huge pages.
+	size_t span_map_count;
+	//! Enable use of large/huge pages. If this flag is set to non-zero and page size is
+	//  zero, the allocator will try to enable huge pages and auto detect the configuration.
+	//  If this is set to non-zero and page_size is also non-zero, the allocator will
+	//  assume huge pages have been configured and enabled prior to initializing the
+	//  allocator.
+	//  For Windows, see https://docs.microsoft.com/en-us/windows/desktop/memory/large-page-support
+	//  For Linux, see https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt
+	int enable_huge_pages;
+	//! Respectively allocated pages and huge allocated pages names for systems
+	//  supporting it to be able to distinguish among anonymous regions.
+	const char *page_name;
+	const char *huge_page_name;
+} rpmalloc_config_t;
+
+//! Initialize allocator with default configuration
+RPMALLOC_EXPORT int
+rpmalloc_initialize(void);
+
+//! Initialize allocator with given configuration
+RPMALLOC_EXPORT int
+rpmalloc_initialize_config(const rpmalloc_config_t* config);
+
+//! Get allocator configuration
+RPMALLOC_EXPORT const rpmalloc_config_t*
+rpmalloc_config(void);
+
+//! Finalize allocator
+RPMALLOC_EXPORT void
+rpmalloc_finalize(void);
+
+//! Initialize allocator for calling thread
+RPMALLOC_EXPORT void
+rpmalloc_thread_initialize(void);
+
+//! Finalize allocator for calling thread
+RPMALLOC_EXPORT void
+rpmalloc_thread_finalize(int release_caches);
+
+//! Perform deferred deallocations pending for the calling thread heap
+RPMALLOC_EXPORT void
+rpmalloc_thread_collect(void);
+
+//! Query if allocator is initialized for calling thread
+RPMALLOC_EXPORT int
+rpmalloc_is_thread_initialized(void);
+
+//! Get per-thread statistics
+RPMALLOC_EXPORT void
+rpmalloc_thread_statistics(rpmalloc_thread_statistics_t* stats);
+
+//! Get global statistics
+RPMALLOC_EXPORT void
+rpmalloc_global_statistics(rpmalloc_global_statistics_t* stats);
+
+//! Dump all statistics in human readable format to file (should be a FILE*)
+RPMALLOC_EXPORT void
+rpmalloc_dump_statistics(void* file);
+
+//! Allocate a memory block of at least the given size
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc(size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(1);
+
+//! Free the given memory block
+RPMALLOC_EXPORT void
+rpfree(void* ptr);
+
+//! Allocate a memory block of at least the given size and zero initialize it
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpcalloc(size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(1, 2);
+
+//! Reallocate the given block to at least the given size
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rprealloc(void* ptr, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);
+
+//! Reallocate the given block to at least the given size and alignment,
+//  with optional control flags (see RPMALLOC_NO_PRESERVE).
+//  Alignment must be a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB)
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpaligned_realloc(void* ptr, size_t alignment, size_t size, size_t oldsize, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3);
+
+//! Allocate a memory block of at least the given size and alignment.
+//  Alignment must be a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB)
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpaligned_alloc(size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);
+
+//! Allocate a memory block of at least the given size and alignment, and zero initialize it.
+//  Alignment must be a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB)
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpaligned_calloc(size_t alignment, size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(2, 3);
+
+//! Allocate a memory block of at least the given size and alignment.
+//  Alignment must be a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB)
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmemalign(size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);
+
+//! Allocate a memory block of at least the given size and alignment.
+//  Alignment must be a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB)
+RPMALLOC_EXPORT int
+rpposix_memalign(void** memptr, size_t alignment, size_t size);
+
+//! Query the usable size of the given memory block (from given pointer to the end of block)
+RPMALLOC_EXPORT size_t
+rpmalloc_usable_size(void* ptr);
+
+//! Dummy empty function for forcing linker symbol inclusion
+RPMALLOC_EXPORT void
+rpmalloc_linker_reference(void);
+
+#if RPMALLOC_FIRST_CLASS_HEAPS
+
+//! Heap type
+typedef struct heap_t rpmalloc_heap_t;
+
+//! Acquire a new heap. Will reuse existing released heaps or allocate memory for a new heap
+//  if none available. Heap API is implemented with the strict assumption that only one single
+//  thread will call heap functions for a given heap at any given time, no functions are thread safe.
+RPMALLOC_EXPORT rpmalloc_heap_t*
+rpmalloc_heap_acquire(void);
+
+//! Release a heap (does NOT free the memory allocated by the heap, use rpmalloc_heap_free_all before destroying the heap).
+//  Releasing a heap will enable it to be reused by other threads. Safe to pass a null pointer.
+RPMALLOC_EXPORT void
+rpmalloc_heap_release(rpmalloc_heap_t* heap);
+
+//! Allocate a memory block of at least the given size using the given heap.
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc_heap_alloc(rpmalloc_heap_t* heap, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);
+
+//! Allocate a memory block of at least the given size using the given heap. The returned
+//  block will have the requested alignment. Alignment must be a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB).
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc_heap_aligned_alloc(rpmalloc_heap_t* heap, size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3);
+
+//! Allocate a memory block of at least the given size using the given heap and zero initialize it.
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc_heap_calloc(rpmalloc_heap_t* heap, size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(2, 3);
+
+//! Allocate a memory block of at least the given size using the given heap and zero initialize it. The returned
+//  block will have the requested alignment. Alignment must either be zero, or a power of two and a multiple of sizeof(void*),
+//  and should ideally be less than memory page size. A caveat of rpmalloc
+//  internals is that this must also be strictly less than the span size (default 64KiB).
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc_heap_aligned_calloc(rpmalloc_heap_t* heap, size_t alignment, size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(2, 3);
+
+//! Reallocate the given block to at least the given size. The memory block MUST be allocated
+//  by the same heap given to this function.
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc_heap_realloc(rpmalloc_heap_t* heap, void* ptr, size_t size, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3);
+
+//! Reallocate the given block to at least the given size. The memory block MUST be allocated
+//  by the same heap given to this function. The returned block will have the requested alignment.
+//  Alignment must be either zero, or a power of two and a multiple of sizeof(void*), and should ideally be
+//  less than memory page size. A caveat of rpmalloc internals is that this must also be strictly less than
+//  the span size (default 64KiB).
+RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
+rpmalloc_heap_aligned_realloc(rpmalloc_heap_t* heap, void* ptr, size_t alignment, size_t size, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(4);
+
+//! Free the given memory block from the given heap. The memory block MUST be allocated
+//  by the same heap given to this function.
+RPMALLOC_EXPORT void
+rpmalloc_heap_free(rpmalloc_heap_t* heap, void* ptr);
+
+//! Free all memory allocated by the heap
+RPMALLOC_EXPORT void
+rpmalloc_heap_free_all(rpmalloc_heap_t* heap);
+
+//! Set the given heap as the current heap for the calling thread. A heap MUST only be current heap
+//  for a single thread, a heap can never be shared between multiple threads. The previous
+//  current heap for the calling thread is released to be reused by other threads.
+RPMALLOC_EXPORT void
+rpmalloc_heap_thread_set_current(rpmalloc_heap_t* heap);
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif

vendor/SimpleIni/include/SimpleIni.h

@@ -328,7 +328,7 @@ public:
 #endif
 
         /** Strict less ordering by name of key only */
-        struct KeyOrder : std::binary_function<Entry, Entry, bool> {
+        struct KeyOrder {
             bool operator()(const Entry & lhs, const Entry & rhs) const {
                 const static SI_STRLESS isLess = SI_STRLESS();
                 return isLess(lhs.pItem, rhs.pItem);
@@ -336,7 +336,7 @@ public:
         };
 
         /** Strict less ordering by order, and then name of key */
-        struct LoadOrder : std::binary_function<Entry, Entry, bool> {
+        struct LoadOrder {
             bool operator()(const Entry & lhs, const Entry & rhs) const {
                 if (lhs.nOrder != rhs.nOrder) {
                     return lhs.nOrder < rhs.nOrder;

vendor/Squirrel/CMakeLists.txt

@@ -67,3 +67,5 @@ endif()
 target_include_directories(Squirrel PRIVATE ${CMAKE_CURRENT_LIST_DIR})
 target_include_directories(Squirrel PUBLIC ${CMAKE_CURRENT_LIST_DIR}/include)
 target_include_directories(Squirrel PRIVATE ${CMAKE_CURRENT_LIST_DIR}/stdlib)
+# Link to base libraries
+target_link_libraries(Squirrel PUBLIC RPMalloc)

vendor/Squirrel/sqmem.cpp

@@ -2,10 +2,14 @@
     see copyright notice in squirrel.h
 */
 #include "sqpcheader.h"
+//#include <rpmalloc.h>
 #ifndef SQ_EXCLUDE_DEFAULT_MEMFUNCTIONS
 void *sq_vm_malloc(SQUnsignedInteger size){ return malloc(size); }
+//void *sq_vm_malloc(SQUnsignedInteger size){ return rpmalloc(size); }
 
 void *sq_vm_realloc(void *p, SQUnsignedInteger SQ_UNUSED_ARG(oldsize), SQUnsignedInteger size){ return realloc(p, size); }
+//void *sq_vm_realloc(void *p, SQUnsignedInteger SQ_UNUSED_ARG(oldsize), SQUnsignedInteger size){ return rprealloc(p, size); }
 
 void sq_vm_free(void *p, SQUnsignedInteger SQ_UNUSED_ARG(size)){ free(p); }
+//void sq_vm_free(void *p, SQUnsignedInteger SQ_UNUSED_ARG(size)){ rpfree(p); }
 #endif