thijn/SqMod
1
0
Fork 0
mirror of https://github.com/VCMP-SqMod/SqMod.git synced 2024-11-08 00:37:15 +01:00
Code Releases Activity
master
SqMod/module/Library/RegEx.hpp

886 lines
32 KiB
C++
Raw Permalink Normal View History

Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
#pragma once
// ------------------------------------------------------------------------------------------------
#include "Core/Utility.hpp"
// ------------------------------------------------------------------------------------------------
#ifdef POCO_UNBUNDLED
#include <pcre.h>
#else
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
#include "pcre2_config.h"
#include "pcre2.h"
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
#endif
// ------------------------------------------------------------------------------------------------
#include <utility>
// ------------------------------------------------------------------------------------------------
namespace SqMod {
/* ------------------------------------------------------------------------------------------------
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
*
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
*/
struct RxMatch
{
/* --------------------------------------------------------------------------------------------
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
*
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
*/
SQInteger mOffset{0};
/* --------------------------------------------------------------------------------------------
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
*
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
*/
SQInteger mLength{0};
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
/* --------------------------------------------------------------------------------------------
* 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
{
Validate sub-str range.
2022-06-13 03:00:41 +02:00
if ((mOffset + mLength) > str.mLen)
{
STHROWF("Rx: Match is outside the range of the specified string.");
}
// Return the sub-string
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
return LightObj{str.mPtr + mOffset, mLength};
}
};
/* ------------------------------------------------------------------------------------------------
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
*
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
*/
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];
Validate sub-str range.
2022-06-13 03:00:41 +02:00
// 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
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
return LightObj{str.mPtr + m.mOffset, m.mLength};
}
};
Disable current RegEx implementation. POCO switched to pcre2.
2023-03-23 19:22:12 +01:00
// /* ------------------------------------------------------------------------------------------------
// *
// */
// 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));
// }
// };
Basic implementation of PCRE. Just the foundation is currently implemented. Utilities are to be added with time.
2022-06-13 02:51:39 +02:00
} // Namespace:: SqMod
Copy Permalink