#pragma once

// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"

// ------------------------------------------------------------------------------------------------
#ifdef POCO_UNBUNDLED
	#include <pcre.h>
#else
	#include "pcre2_config.h"
	#include "pcre2.h"
#endif

// ------------------------------------------------------------------------------------------------
#include <utility>

// ------------------------------------------------------------------------------------------------
namespace SqMod {

/* ------------------------------------------------------------------------------------------------
 *
*/
struct RxMatch
{
    /* --------------------------------------------------------------------------------------------
     *
    */
	SQInteger mOffset{0};

    /* --------------------------------------------------------------------------------------------
     *
    */
	SQInteger mLength{0};

    /* --------------------------------------------------------------------------------------------
     * Default constructor.
    */
    RxMatch() noexcept = default;

    /* --------------------------------------------------------------------------------------------
     * Offset constructor.
    */
    explicit RxMatch(SQInteger offset) noexcept
        : mOffset{offset}
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Explicit constructor.
    */
    RxMatch(SQInteger offset, SQInteger length) noexcept
        : mOffset{offset}, mLength{length}
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Copy constructor.
    */
    RxMatch(const RxMatch & o) = default;

    /* --------------------------------------------------------------------------------------------
     * Move constructor.
    */
    RxMatch(RxMatch && o) noexcept = default;

    /* --------------------------------------------------------------------------------------------
     * Copy assignment operator.
    */
    RxMatch & operator = (const RxMatch & o) = default;

    /* --------------------------------------------------------------------------------------------
     * Move assignment operator.
    */
    RxMatch & operator = (RxMatch && o) noexcept = default;

    /* --------------------------------------------------------------------------------------------
     * Retrieve offset.
    */
    SQMOD_NODISCARD SQInteger GetOffset() const noexcept
    {
        return mOffset;
    }

    /* --------------------------------------------------------------------------------------------
     * Modify offset.
    */
    void SetOffset(SQInteger value) noexcept
    {
        mOffset = value;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve length.
    */
    SQMOD_NODISCARD SQInteger GetLength() const noexcept
    {
        return mLength;
    }

    /* --------------------------------------------------------------------------------------------
     * Modify length.
    */
    void SetLength(SQInteger value) noexcept
    {
        mLength = value;
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve match end.
    */
    SQMOD_NODISCARD SQInteger GetEnd() const noexcept
    {
        return mOffset + mLength;
    }

    /* --------------------------------------------------------------------------------------------
     * Extract a sub-string.
    */
    [[nodiscard]] LightObj SubStr(StackStrF & str) const
    {
        if ((mOffset + mLength) > str.mLen)
        {
            STHROWF("Rx: Match is outside the range of the specified string.");
        }
        // Return the sub-string
        return LightObj{str.mPtr + mOffset, mLength};
    }
};

/* ------------------------------------------------------------------------------------------------
 *
*/
struct RxMatches
{
    using List = std::vector< RxMatch >;

    /* --------------------------------------------------------------------------------------------
     * Internal RegularExpression instance.
    */
    List mList;

    /* --------------------------------------------------------------------------------------------
     * Default constructor.
    */
    RxMatches() = default;

    /* --------------------------------------------------------------------------------------------
     * Copy list constructor.
    */
    explicit RxMatches(const List & l) // NOLINT(modernize-pass-by-value)
            : mList{l}
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Move list constructor.
    */
    explicit RxMatches(List && m) noexcept
            : mList{std::move(m)}
    {
    }

    /* --------------------------------------------------------------------------------------------
     * Copy constructor.
    */
    RxMatches(const RxMatches & o) = default;

    /* --------------------------------------------------------------------------------------------
     * Move constructor.
    */
    RxMatches(RxMatches && o) noexcept = default;

    /* --------------------------------------------------------------------------------------------
     * Copy assignment operator.
    */
    RxMatches & operator = (const RxMatches & o) = default;

    /* --------------------------------------------------------------------------------------------
     * Move assignment operator.
    */
    RxMatches & operator = (RxMatches && 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) >= mList.size())
        {
            STHROWF("Invalid Regular Expression match list index({})", i);
        }
        return mList;
    }

    /* --------------------------------------------------------------------------------------------
     * 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) >= mList.size())
        {
            STHROWF("Invalid Regular Expression match list index({})", i);
        }
        return mList;
    }

    /* --------------------------------------------------------------------------------------------
     * Make sure a container instance is populated, then return it.
    */
    SQMOD_NODISCARD List & ValidPop()
    {
        if (mList.empty())
        {
            STHROWF("Regular Expression match list container is empty");
        }
        return mList;
    }

    /* --------------------------------------------------------------------------------------------
     * 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 mList.back();
    }

    /* --------------------------------------------------------------------------------------------
     * Check if the container has no elements.
    */
    SQMOD_NODISCARD bool Empty() const
    {
        return mList.empty();
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the number of elements in the container.
    */
    SQMOD_NODISCARD SQInteger Size() const
    {
        return static_cast< SQInteger >(mList.size());
    }

    /* --------------------------------------------------------------------------------------------
     * Retrieve the number of elements that the container has currently allocated space for.
    */
    SQMOD_NODISCARD SQInteger Capacity() const
    {
        return static_cast< SQInteger >(mList.capacity());
    }

    /* --------------------------------------------------------------------------------------------
     * Increase the capacity of the container to a value that's greater or equal to the one specified.
    */
    RxMatches & Reserve(SQInteger n)
    {
        mList.reserve(ClampL< SQInteger, size_t >(n));
        return *this;
    }

    /* --------------------------------------------------------------------------------------------
     * Request the removal of unused capacity.
    */
    void Compact()
    {
        mList.shrink_to_fit();
    }

    /* --------------------------------------------------------------------------------------------
     * Erase all elements from the container.
    */
    void Clear()
    {
        mList.clear();
    }

    /* --------------------------------------------------------------------------------------------
     * Pop the last element in the container.
    */
    void Pop()
    {
        ValidPop().pop_back();
    }

    /* --------------------------------------------------------------------------------------------
     * Erase the element at a certain position.
    */
    void EraseAt(SQInteger i)
    {
        mList.erase(ValidIdx(i).begin() + static_cast< size_t >(i)); // NOLINT(cppcoreguidelines-narrowing-conversions)
    }

    /* --------------------------------------------------------------------------------------------
     * Erase a certain amount of elements starting from a specific position.
    */
    void EraseFrom(SQInteger i, SQInteger n)
    {
        mList.erase(ValidIdx(i).begin() + static_cast< size_t >(i), // NOLINT(cppcoreguidelines-narrowing-conversions)
                     ValidIdx(i + n).begin() + static_cast< size_t >(i + n)); // NOLINT(cppcoreguidelines-narrowing-conversions)
    }

    /* --------------------------------------------------------------------------------------------
     * Iterate all values through a functor.
    */
    void Each(Function & fn) const
    {
        for (const auto & e : mList)
        {
            fn.Execute(static_cast< SQInteger >(e.mOffset), static_cast< SQInteger >(e.mLength));
        }
    }

    /* --------------------------------------------------------------------------------------------
     * 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), // NOLINT(cppcoreguidelines-narrowing-conversions)
                      ValidIdx(p + n).begin() + static_cast< size_t >(p + n), // NOLINT(cppcoreguidelines-narrowing-conversions)
                      [&](List::const_reference & e) {
                          fn.Execute(static_cast< SQInteger >(e.mOffset), static_cast< SQInteger >(e.mLength));
                      });
    }

    /* --------------------------------------------------------------------------------------------
     * Iterate all values through a functor until stopped (i.e. false is returned).
    */
    void While(Function & fn) const
    {
        for (const auto & e : mList)
        {
            auto ret = fn.Eval(static_cast< SQInteger >(e.mOffset), static_cast< SQInteger >(e.mLength));
            // (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); // NOLINT(cppcoreguidelines-narrowing-conversions)
        auto end = ValidIdx(p + n).begin() + static_cast< size_t >(p + n); // NOLINT(cppcoreguidelines-narrowing-conversions)
        for (; itr != end; ++itr)
        {
            auto ret = fn.Eval(static_cast< SQInteger >(itr->mOffset), static_cast< SQInteger >(itr->mLength));
            // (null || true) == continue & false == break
            if (!ret.IsNull() || !ret.template Cast< bool >())
            {
                break;
            }
        }
    }

    /* --------------------------------------------------------------------------------------------
     * Extract a sub-string.
    */
    [[nodiscard]] LightObj SubStr(SQInteger i, StackStrF & str) const
    {
        const RxMatch & m = ValidIdx(i)[i];
        // Check if match is within range
        if ((m.mOffset + m.mLength) > str.mLen)
        {
            STHROWF("Rx: Match is outside the range of the specified string.");
        }
        // Return the sub-string
        return LightObj{str.mPtr + m.mOffset, m.mLength};
    }
};

// /* ------------------------------------------------------------------------------------------------
//  *
// */
// struct RxInstance
// {
//     /* --------------------------------------------------------------------------------------------
//      * Whether to analyze and optimize the pattern by default for evey new instance (true).
//     */
//     static bool STUDY;

//     /* --------------------------------------------------------------------------------------------
//      * Default options for every new instance (0).
//     */
//     static int OPTIONS;

//     /* --------------------------------------------------------------------------------------------
//      * Default study options for every new instance (0).
//     */
//     static int STUDY_OPTIONS;

//     /* --------------------------------------------------------------------------------------------
//      * Default offset vector size (must be multiple of 3).
//     */
//     static constexpr int OVEC_SIZE = 63;

//     /* --------------------------------------------------------------------------------------------
//      * Internal vector type used for offsets buffer.
//     */
//     using OVEC_t = std::vector< int >;

//     /* --------------------------------------------------------------------------------------------
//      * Internal RegularExpression instance.
//     */
// 	pcre * 			mPCRE{nullptr};

//     /* --------------------------------------------------------------------------------------------
//      * Internal RegularExpression instance.
//     */
// 	pcre_extra * 	mExtra{nullptr};

//     /* --------------------------------------------------------------------------------------------
//      * Internal buffer used for offsets.
//     */
//     OVEC_t          mOVEC{};

//     /* --------------------------------------------------------------------------------------------
//      * Default constructor.
//     */
//     RxInstance() noexcept = default;

//     /* --------------------------------------------------------------------------------------------
//      * Copy constructor (disabled).
//     */
//     RxInstance(const RxInstance &) = delete;

//     /* --------------------------------------------------------------------------------------------
//      * Move constructor.
//     */
//     RxInstance(RxInstance && o) noexcept
//         : mPCRE(o.mPCRE), mExtra(o.mExtra), mOVEC(std::move(o.mOVEC)) // Replicate it
//     {
//         o.mPCRE = nullptr; // Take ownership
//         o.mExtra = nullptr; // Take ownership
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Basic constructor.
//     */
//     explicit RxInstance(StackStrF & pattern)
//         : RxInstance(OPTIONS, STUDY, pattern)
//     {
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Basic constructor. With specific options.
//     */
//     explicit RxInstance(int options, StackStrF & pattern)
//         : RxInstance(options, STUDY, pattern)
//     {
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Basic constructor. With specific options.
//     */
//     explicit RxInstance(int options, bool study, StackStrF & pattern)
//         : mPCRE(Compile_(pattern.mPtr, options)), mExtra(nullptr)
//     {
//         if (study)
//         {
//             Study0();
//         }
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Internal constructor.
//     */
//     RxInstance(const char * pattern, int options, bool study)
//         : mPCRE(Compile_(pattern, options)), mExtra(nullptr)
//     {
//         if (study)
//         {
//             Study0();
//         }
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Destructor.
//     */
// 	~RxInstance()
// 	{
//         Destroy();
// 	}

//     /* --------------------------------------------------------------------------------------------
//      * Copy assignment operator (disabled).
//     */
//     RxInstance & operator = (const RxInstance &) = delete;

//     /* --------------------------------------------------------------------------------------------
//      * Move assignment operator.
//     */
//     RxInstance & operator = (RxInstance && o) noexcept
//     {
//         // Prevent self assignment
//         if (this != &o)
//         {
//             // Release current instance, if any
//             Destroy();
//             // Replicate it
//             mPCRE = o.mPCRE;
//             mExtra = o.mExtra;
//             mOVEC = std::move(o.mOVEC);
//             // Take ownership
//             o.mPCRE = nullptr;
//             o.mExtra = nullptr;
//         }
//         return *this;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Estimate the size necessary for the offsets vector buffer.
//     */
//     void EstimateOVEC(bool force = false)
//     {
//         if (mOVEC.empty() || force)
//         {
//             int size = 0;
//             // Attempt to estimate the size of the offsets vector buffer
//             const int r = pcre_fullinfo(ValidPCRE(), mExtra, PCRE_INFO_CAPTURECOUNT, &size);
//             // Check for errors
//             if (r != 0)
//             {
//                 STHROWF("Rx: Offsets vector buffer estimation failed ({})", r);
//             }
//             // Attempt to scale the vector (must be multiple of 3)
//             mOVEC.resize((size + 1) * 3);
//         }
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Return a valid `pcre` instance pointer or throw an exception.
//     */
//     SQMOD_NODISCARD pcre * ValidPCRE() const
//     {
//         // Do we manage a valid instance?
//         if (mPCRE == nullptr)
//         {
//             STHROWF("Uninitialized Regular Expression instance.");
//         }
//         // Return it
//         return mPCRE;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Return a valid `pcre_extra` instance pointer or throw an exception.
//     */
//     SQMOD_NODISCARD pcre_extra * ValidExtra() const
//     {
//         // Do we manage a valid instance?
//         if (mExtra == nullptr)
//         {
//             STHROWF("Regular Expression was not studied and optimized.");
//         }
//         // Return it
//         return mExtra;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Compile the specified pattern.
//     */
//     SQMOD_NODISCARD static pcre * Compile_(const char * pattern, int options = OPTIONS)
//     {
//         const char * error_msg = nullptr;
//         int error_code, error_offset = 0;
//         // Attempt to compile the specified pattern
//         pcre * ptr = pcre_compile2(pattern, options, &error_code, &error_msg, &error_offset, nullptr);
//         // Did the compilation failed?
//         if (ptr == nullptr)
//         {
//             STHROWF("Rx: {s} (code {}) (at offset {})", error_msg, error_code, error_offset);
//         }
//         // Return the `pcre` instance
//         return ptr;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Attempt to compile the specified pattern. Error information is returned instead of thrown.
//     */
//     SQMOD_NODISCARD static std::pair< pcre *, Table > TryCompile_(const char * pattern, int options = OPTIONS)
//     {
//         const char * error_msg = nullptr;
//         int error_code, error_offset = 0;
//         // Attempt to compile the specified pattern
//         pcre * ptr = pcre_compile2(pattern, options, &error_code, &error_msg, &error_offset, nullptr);
//         // Did the compilation failed?
//         if (ptr == nullptr)
//         {
//             Table t;
//             t.SetValue("message", error_msg);
//             t.SetValue("code", error_code);
//             t.SetValue("offset", error_offset);
//             // Return the table with error information
//             return std::make_pair(ptr, std::move(t));
//         }
//         // Return the `pcre` instance with no error information
//         return std::make_pair(ptr, Table{});
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Compile the specified pattern.
//     */
//     RxInstance & Compile1(StackStrF & pattern)
//     {
//         return Compile2(OPTIONS, pattern);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Compile the specified pattern. With specific options.
//     */
//     RxInstance & Compile2(int options, StackStrF & pattern)
//     {
//         // Release current instance, if any
//         Destroy();
//         // Attempt to compile
//         mPCRE = Compile_(pattern.mPtr, options);
//         // Allocate offsets vector buffer
//         EstimateOVEC();
//         // Allow chaining
//         return *this;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Compile the specified pattern.
//     */
//     Table TryCompile1(StackStrF & pattern)
//     {
//         return TryCompile2(OPTIONS, pattern);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Compile the specified pattern. With specific options.
//     */
//     Table TryCompile2(int options, StackStrF & pattern)
//     {
//         // Release current instance, if any
//         Destroy();
//         // Attempt to compile
//         auto p = TryCompile_(pattern.mPtr, options);
//         // Were there any compilation errors?
//         if (p.first != nullptr)
//         {
//             mPCRE = p.first;
//         }
//         // Return compilation info
//         return p.second;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Analyze the managed pattern and optimized it.
//     */
//     RxInstance & Study0()
//     {
//         return Study1(STUDY_OPTIONS);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Analyze the managed pattern and optimized it. With specific options.
//     */
//     RxInstance & Study1(int options)
//     {
//         if (mExtra != nullptr)
//         {
//             STHROWF("Regular Expression was already analyzed and optimized");
//         }
//         const char * error = nullptr;
//         // Study and optimize the expression
//         mExtra = pcre_study(ValidPCRE(), options, &error);
//         // If there was an error studying the expression then throw it
//         if (mExtra == nullptr && error != nullptr)
//         {
//             STHROWF("Rx: {s}", error);
//         }
//         // Allow chaining
//         return *this;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Release managed resources and revert to uninitialized instance.
//     */
//     SQMOD_NODISCARD bool IsValid() const
//     {
//         return (mPCRE != nullptr);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Release managed resources and revert to uninitialized instance.
//     */
//     SQMOD_NODISCARD bool IsStudied() const
//     {
//         return (mExtra != nullptr);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * Release managed resources and revert to uninitialized instance.
//     */
//     void Destroy()
//     {
//         // Do we manage any instance?
//         if (mPCRE != nullptr)
//         {
//             pcre_free(mPCRE);
//             mPCRE = nullptr;
//         }
//         // Is the expression optimized?
//         if (mExtra != nullptr)
//         {
//             pcre_free(mExtra);
//             mExtra = nullptr;
//         }
//     }

//     /* --------------------------------------------------------------------------------------------
//      * 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.mOffset is -1 and m.mLength is 0.
//      * Returns the number of matches. Throws a exception in case of an error.
//     */
//     SQMOD_NODISCARD int MatchFirstFrom(SQInteger o, RxMatch & m, StackStrF & s)
//     {
//         return MatchFirstFrom_(OPTIONS, o, m, s);
//     }
//     SQMOD_NODISCARD int MatchFirstFrom_(int f, SQInteger o, RxMatch & m, StackStrF & s)
//     {
//         if (o > s.mLen)
//         {
//             STHROWF("Rx: Offset is out of range");
//         }
//         EstimateOVEC();
//         // Attempt to execute the expression on the specified subject
//         const int rc = pcre_exec(ValidPCRE(), mExtra, s.mPtr, static_cast< int >(s.mLen), static_cast< int >(o), f & 0xFFFF, mOVEC.data(), static_cast< int >(mOVEC.size()));
//         // Was there a match?
//         if (rc == PCRE_ERROR_NOMATCH)
//         {
//             m.mOffset = -1;
//             m.mLength = 0;
//             // No match found
//             return 0;
//         }
//         // Bad options/flags?
//         else if (rc == PCRE_ERROR_BADOPTION)
//         {
//             STHROWF("Rx: Bad option");
//         }
//         // Overflow?
//         else if (rc == 0)
//         {
//             STHROWF("Rx: too many captured sub-strings");
//         }
//         // Some other error?
//         else if (rc < 0)
//         {
//             STHROWF("Rx: error {}", rc);
//         }
//         // Store match
//         m.mOffset = mOVEC[0];
//         m.mLength = mOVEC[1] - mOVEC[0];
//         // Yield result back to script
//         return rc;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * 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.mOffset is -1 and m.mLength is 0.
//      * Returns the number of matches. Throws a exception in case of an error.
//     */
//     SQMOD_NODISCARD int MatchFirst(RxMatch & m, StackStrF & s)
//     {
//         return MatchFirstFrom_(OPTIONS, 0, m, s);
//     }
//     SQMOD_NODISCARD int MatchFirst_(int f, RxMatch & m, StackStrF & s)
//     {
//         return MatchFirstFrom_(f, 0, m, s);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * 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 sub-patterns. 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 an exception in case of an error.
//     */
//     SQMOD_NODISCARD int MatchFrom(SQInteger o, RxMatches & m, StackStrF & s)
//     {
//         return MatchFrom_(OPTIONS, o, m, s);
//     }
//     SQMOD_NODISCARD int MatchFrom_(int f, SQInteger o, RxMatches & m, StackStrF & s)
//     {
//         if (o > s.mLen)
//         {
//             STHROWF("Rx: Offset is out of range");
//         }
//         EstimateOVEC();
//         // Clear previous matches, if any
//         m.mList.clear();
//         // Attempt to execute the expression on the specified subject
//         const int rc = pcre_exec(ValidPCRE(), mExtra, s.mPtr, static_cast< int >(s.mLen), static_cast< int >(o), f & 0xFFFF, mOVEC.data(), static_cast< int >(mOVEC.size()));
//         // Was there a match?
//         if (rc == PCRE_ERROR_NOMATCH)
//         {
//             return 0; // No match found
//         }
//         // Bad options/flags?
//         else if (rc == PCRE_ERROR_BADOPTION)
//         {
//             STHROWF("Rx: Bad option");
//         }
//         // Overflow?
//         else if (rc == 0)
//         {
//             STHROWF("Rx: too many captured sub-strings");
//         }
//         // Some other error?
//         else if (rc < 0)
//         {
//             STHROWF("Rx: error {}", rc);
//         }
//         // Reserve space in advance
//         m.mList.reserve(static_cast< size_t >(rc));
//         // Transfer matches to match-list
//         for (int i = 0; i < rc; ++i)
//         {
//             m.mList.emplace_back(mOVEC[i*2], mOVEC[i*2+1] - mOVEC[i*2]);
//         }
//         // Yield result back to script
//         return rc;
//     }

//     /* --------------------------------------------------------------------------------------------
//      * 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 sub-patterns. 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 an exception in case of an error.
//     */
//     SQMOD_NODISCARD int Match(RxMatches & m, StackStrF & s)
//     {
//         return MatchFrom_(OPTIONS, 0, m, s);
//     }
//     SQMOD_NODISCARD int Match_(int f, RxMatches & m, StackStrF & s)
//     {
//         return MatchFrom_(f, 0, m, s);
//     }

//     /* --------------------------------------------------------------------------------------------
//      * 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)
//     {
//         return Matches_(PCRE_ANCHORED | PCRE_NOTEMPTY, s);
//     }
//     SQMOD_NODISCARD bool Matches_(SQInteger o, StackStrF & s)
//     {
//         return MatchesEx(PCRE_ANCHORED | PCRE_NOTEMPTY, 0, s);
//     }
//     SQMOD_NODISCARD bool MatchesEx(int f, SQInteger o, StackStrF & s)
//     {
//         RxMatch m;
//         const int rc = MatchFirstFrom_(f, o, m, s);
//         return (rc > 0) && (m.mOffset == o) && (m.mLength == (s.mLen - o));
//     }
// };

} // Namespace:: SqMod