YuPcre2 1.11.0 for Delphi 10.3 Rio Cracked

YuPcre2 1.11.0 for Delphi 10.3 Rio Cracked

YuPcre2 1.11.0  for Delphi 10.3 Rio Cracked
YuPcre2 1.11.0 for Delphi 10.3 Rio Cracked

YuPcre2 is a library of Delphi components and procedures that implement regular expression pattern matching using the same syntax and semantics as Perl, with just a few differences. There are two matching algorithms, the standard Perl and alternative DFA algorithm:

The Perl algorithm is what you are used to from Perl and j@vascript. It is fast and supports the complete pattern syntax. You will likely be using it most of the time.
DFA is a special purpose algorithm. If finds all possible matches and, in particular, it finds the longest. It never backtracks and supports partial matching better, in particular multi-segment matching of very long subject strings.

YuPcre2 has native interfaces for 8-bit, 16-bit, and 32-bit strings. Component wrappers are available for UnicodeString / WideString and AnsiString / Utf8String / RawBytestring:

The YuPcre2 RegEx2 classes descend from common ancestors which implement the core functionalities:

Match strings and and extract full or substring matches.
Search for regular expressions within streams and memory buffers. TDIRegExSearchStream descendants employ a buffered search within streams and files (of virtually unlimited size) and use little memory.
Replace full matches or partial substrings.
List full matches or partial substrings.
Format full matches or partial substrings by adding static or dynamic text.

Users familiar with the DIRegEx might be interessted in the differences between YuPcre2 and DIRegEx.

Pattern Syntax

YuPcre2 RegEx2 Workbench Application The YuPcre2 regular expression pattern syntax is mostly compatible with Perl. It includes the following:

Escaped Characters
Character Types
General Category Properties for \p and \P
PCRE2 Special Category Properties for \p and \P
Script Names for \p and \P
Character Classes
Anchors and Simple Assertions
Match Point Reset
Atomic Groups
Option Setting
Newline Convention
What \R Matches
Lookahead and Lookbehind Assertions
Subroutine References (possibly recursive)
Conditional Patterns
Backtracking Control

YuPcre2 RegEx2 String Processing

YuPcre2 can Replace, List, or Format regular expressions matches or any of its substrings, useful for text editors and word processors. Variable portions of the match can be included into the result text. The full match can be referenced by number, substrings also by name. The character to introduce these reference is freely configurable. FormatOptions allow to turn features on or off as required.

Replace returns the original subject string with matches replaced, similar to but more flexible than Delphi's StringReplace() function.
List collects all string matches into a single string. It extracts multiple phone numbers, e-mail addresses, or URLs, with a single call.

YuPcre2 RegEx2 MaskControls

The YuPcre2 RegEx2 MaskControls Demo ApplicationYuPcre2 includes two regular expression mask edits: TDIRegEx2MaskEdit and TDIRegEx2ComboBox. Both controls validate keyboard input against a regular expression. They work similar to Delphi's TMaskEdit, but more flexible and powerful.

The regular expression mask edits can:

accept / reject specific characters at determined positions;
allow / reject particular characters if they follow defined character(s);
restrict input text to begin / end with exact character(s);
flag incomplete text to show that more input is needed.

Examples: Numbers, number ranges, dates, phone numbers, e-mail addresses, URLs, currency, and more.

Workbench Application

The YuPcre2 RegEx2 Workbench helps to design and test regular expressions. It allows to set options, measure execution times, and to save and load settings for later use.

The YuPcre2 RegEx2 Workbench is available as

Design-Time Component Editor and
Standalone Application.

 YuPcre2 1.11.0 – 8 Oct 2019

    Fix subject buffer overread in JIT when UTF is disabled and \X or \R has a greater than 1 fixed quantifier.
    Added support for callouts from pcre2_substitute.
    Fix an xclass matching issue in JIT.
    Implement the Perl 5.28 experimental alphabetic names for atomic groups and lookaround assertions, for example, (*pla:…) and (*atomic:…). These are characterized by a lower case letter following (*.
    Implement the new Perl “script run” features (*script_run:…) and (*atomic_script_run:…) aka (*sr:…) and (*asr:…).
    Implement PCRE2_COPY_MATCHED_SUBJECT for pcre2_match (including JIT via pcre2_match) and pcre2_dfa_match, but *not* the pcre2_jit_match fast path. Also, when a match fails, set the subject field in the match data to nil for tidiness - none of the substring extractors should reference this after match failure.
    If a pattern started with a subroutine call that had a quantifier with a minimum of zero, an incorrect “match must start with this character” could be recorded. Example: (?&xxx)*ABC(?<xxx>XYZ) would (incorrectly) expect 'A' to be the first character of a match.
    The heap limit checking code in pcre2_dfa_match could suffer from overflow if the heap limit was set very large. This could cause incorrect “heap limit exceeded” errors.
    If a pattern started with (*MARK), (*COMMIT), (*PRUNE), (*SKIP)#, or (*THEN) followed by ^ it was not recognized as anchored.
    With PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL set, escape sequences such as \s which are valid in character classes, but not as the end of ranges, were being treated as literals. An example is [_-\s] (but not [\s-_] because that gave an error at the start of a range). Now an “invalid range” error is given independently of PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL.
    PCRE2_EXTRA_BAD_ESCAPE_IS_LITERAL was affecting known escape sequences such as \eX when they appeared invalidly in a character class. Now the option applies only to unrecognized or malformed escape sequences.
    The pcre2_dfa_match function was incorrectly handling conditional version tests such as (?(VERSION>=0)…) when the version test was true. Incorrect processing or a crash could result.
    When PCRE2_UTF is set, allow non-ASCII letters and decimal digits in group names, as Perl does.
    Implemented PCRE2_EXTRA_ALT_BSUX to support ECMAScript 6's \u{hhh} construct.
    Compile \p{Any} to be the same as . in PCRE2_DOTALL mode, so that it benefits from auto-anchoring if \p{Any}* starts a pattern.
    Disable SSE2 JIT optimizations in x86 CPUs when SSE2 is not available.
    Improve DIUtils.pas Unicode processing to support Unicode Code Points from $000000 to $10FFFF. Adjust remaining source code accordingly.
    Update DIUtils Unicode functions to Unicode 12.1.0.
    Remove DI.inc include file. Directly link in DICompilers.inc instead.

Only for V.I.P
Warning! You are not allowed to view this text.

Users of Guests are not allowed to comment this publication.