Download YuPcre2 1.22.0 for Delphi 11-12 Athens + Crack

YuPcre2 1.22.0 for Delphi 11-12 Athens + Crack

YuPcre2 1.22.0 for Delphi 11-12 Athens + Crack
YuPcre2 1.22.0 for Delphi 11-12 Athens + Crack

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 v1.22.0 – 25 Mar 2024

Update to PCRE2 v10.43 final.

Perl 5.34.0 changed the meaning of (for example) {,3} which did not used to be treated as a quantifier. Now it is interpreted as {0,3} and PCRE2 has changed to match. Note that {,} is still not a quantifier.
Perl allows spaces and/or horizontal tabs after { or before } in all items that use braces, and also before or after the comma in quantifiers. PCRE2 now does the same, except for \u{…}, which is recognized only when PCRE2_EXTRA_ALT_BSUX is set. This an ECMAScript, non-Perl compatible, extension, so PCRE2 follows ECMAScript rather than Perl.
Fix a bug that pcre2_match was not fully resetting all captures that had been set within a (possibly recursive) subroutine call such as (?3).
Changed the meaning of \w (and its synonyms) in UCP mode to match Perl. It now matches characters whose general categories are L or N or whose particular categories are Mn (non-spacing mark) or Pc (combining puntuation). The latter includes underscore.
Changed the meaning of [:xdigit:] in UCP mode to match Perl. It now also matches the “fullwidth” versions of the hex digits. Just like it is done for [:digit:], PCRE2_EXTRA_ASCII_DIGIT can be used to keep this class ASCII only without affecting other POSIX classes.
Fix a potential integer overflow in pcre2_dfa_match.
Updated handling of \b and \B in UCP mode to match the changes to \w because \b and \B are defined in terms of \w.
Within a pattern (?aT) and (?-aT) set and reset the PCRE2_EXTRA_ASCII_DIGIT option, and (?aP) also sets (?aT) so that (?-aP) disables all ASCII restrictions on POSIX classes.
If PCRE2_FIRSTLINE was set on an anchored pattern, pcre2_match and pcre2_dfa_match misbehaved. PCRE2_FIRSTLINE is now ignored for anchored patterns.
Add a test for ridiculous ovector offset values to the substring extraction functions.
In the 32-bit library, in non-UTF mode, a quantifier that followed a literal character with a value greater than or equal to $80000000 caused undefined behaviour.
\z was misbehaving when matching fragments inside invalid UTF strings.
Fix \X matching in 32 bit mode without UTF in JIT.
Fix backref iterators when PCRE2_MATCH_UNSET_BACKREF is set in JIT.
Refactor the handling of whole-pattern recursion (?0) in pcre2_match so that its end is handled similarly to other recursions. This has altered the behaviour of |(?0). with PCRE2_ENDANCHORED which was previously not right.
Improved the test for looping recursion by checking the last referenced character as well as the current character. This allows some patterns that previously triggered the check to run to completion instead of giving the loop error.
In 32-bit mode, the compiler looped for the pattern [\x{ffffffff}] when PCRE2_CASELESS and PCRE2_UCP (but not PCRE2_UTF) were set.
In caseless 32-bit mode with UCP (but not UTF) set, the character $ffffffff incorrectly matched any character that has more than one other case, in particular k and s.
Fix accept and endanchored interaction in JIT.
Fix backreferences with unset backref and non-greedy iterators in JIT.
Improve the logic that checks for a list of starting code units – positive lookahead assertions are now ignored if the immediately following item is one that sets a mandatory starting character. For example, a?(?=bc|)d used to set all of a, b, and d as possible starting code units; now it sets only a and d.
Fix incorrect class character matches in JIT.
Insert omitted setting of subject length in match data at the end of pcre2_jit_match.
Implemented PCRE2_DISABLE_RECURSELOOP_CHECK for pcre2_match to enable some apparently looping recursions to run to completion and therefore match the JIT behaviour. With this set, real loops will eventually get caught by match or heap limits or run out of resource.

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