From 87387999f374dc845e77928628946db28c899de5 Mon Sep 17 00:00:00 2001 From: Sandu Liviu Catalin Date: Sat, 25 Jun 2022 02:30:33 +0300 Subject: [PATCH] Remove old POCO RegEx. --- module/CMakeLists.txt | 1 - module/PocoLib/RegEx.cpp | 112 --------- module/PocoLib/RegEx.hpp | 481 ------------------------------------ module/PocoLib/Register.cpp | 2 - 4 files changed, 596 deletions(-) delete mode 100644 module/PocoLib/RegEx.cpp delete mode 100644 module/PocoLib/RegEx.hpp diff --git a/module/CMakeLists.txt b/module/CMakeLists.txt index c1089187..92fb3440 100644 --- a/module/CMakeLists.txt +++ b/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 diff --git a/module/PocoLib/RegEx.cpp b/module/PocoLib/RegEx.cpp deleted file mode 100644 index 7b36382c..00000000 --- a/module/PocoLib/RegEx.cpp +++ /dev/null @@ -1,112 +0,0 @@ -// ------------------------------------------------------------------------------------------------ -#include "PocoLib/RegEx.hpp" - -// ------------------------------------------------------------------------------------------------ -#include - -// ------------------------------------------------------------------------------------------------ -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 diff --git a/module/PocoLib/RegEx.hpp b/module/PocoLib/RegEx.hpp deleted file mode 100644 index d45b9427..00000000 --- a/module/PocoLib/RegEx.hpp +++ /dev/null @@ -1,481 +0,0 @@ -#pragma once - -// ------------------------------------------------------------------------------------------------ -#include "Core/Utility.hpp" - -// ------------------------------------------------------------------------------------------------ -#include - -// ------------------------------------------------------------------------------------------------ -#include - -// ------------------------------------------------------------------------------------------------ -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 diff --git a/module/PocoLib/Register.cpp b/module/PocoLib/Register.cpp index a73de8b2..ef5976d4 100644 --- a/module/PocoLib/Register.cpp +++ b/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);