RegExMBS.CompileOptionAnchored as Boolean

(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionAutoCallOut as Boolean

(Read and Write property)

RegExMBS.CompileOptionBSRAnyCRLF as Boolean

The choice is either to match only CR, LF, or CRLF, or to match any Unicode newline sequence. The default is specified when PCRE is built. It can be overridden from within the pattern, or by setting an option when a compiled pattern is matched.
(Read and Write property)

RegExMBS.CompileOptionBSRUnicode as Boolean

dim rg As new RegExMBS
rg.CompileOptionUngreedy = false
rg.CompileOptionBSRUnicode = true

dim ts as string = "one" + EndOfLine.UNIX + "test" + chr(&h2028) + "more"

// replace all end lines with #
if rg.Compile("\R+") then
  
  ts = rg.ReplaceAll(ts,"#")
  
end if

MsgBox ts

The choice is either to match only CR, LF, or CRLF, or to match any Unicode newline sequence. The default is specified when PCRE is built. It can be overridden from within the pattern, or by setting an option when a compiled pattern is matched.
(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionCaseLess as Boolean

dim r as new RegExMBS
dim searchString as string = "hello"

r.CompileOptionCaseLess=True

if r.Compile(searchString) then
  
  dim s as string="äöü Hello World"
  
  if r.Execute(s,0)>0 then
    MsgBox "Found: "+mid(s, r.OffsetCharacters(0)+1, r.OffsetCharacters(1)-r.OffsetCharacters(0))
  else
    MsgBox "nothing found"
  end if
  
else
  MsgBox "failed to compile"
end if

(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionDollarEndOnly as Boolean

(Read and Write property)

RegExMBS.CompileOptionDotAll as Boolean

dim r as new RegExMBS
dim searchString as string = "<.+>"

r.CompileOptionDotAll = false // finds only if true

if r.Compile(searchString) then
  
  dim s as string="<Step enable=""True"""+EndOfLine.unix+"id=""93"" name=""Beep""/>"
  
  if r.Execute(s,0)>0 then
    MsgBox "Found: "+mid(s, r.OffsetCharacters(0)+1, r.OffsetCharacters(1)-r.OffsetCharacters(0))
  else
    MsgBox "nothing found"
  end if
  
else
  MsgBox "failed to compile"
end if

(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionDuplicateNames as Boolean

This can be helpful for certain types of pattern when it is known that only one instance of the named subpattern can ever be matched. There are more details of named subpatterns below; see also the pcrepattern documentation.
(Read and Write property)

RegExMBS.CompileOptionExtended as Boolean

(Read and Write property)

RegExMBS.CompileOptionFirstLine as Boolean

(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegEx Multiline

RegExMBS.CompileOptionJavaScriptCompat as Boolean

The changes are as follows:

(1) A lone closing square bracket in a pattern causes a compile-time error, because this is illegal in JavaScript (by default it is treated as a data character). Thus, the pattern AB]CD becomes illegal when this option is set.

(2) At run time, a back reference to an unset subpattern group matches an empty string (by default this causes the current matching alternative to fail). A pattern such as (\1)(a) succeeds when this option is set (assuming it can find an "a" in the subject), whereas it fails by default, for Perl compatibility.
(Read and Write property)

RegExMBS.CompileOptionMultiline as Boolean

dim r as RegExMBS
dim n,i,c as Integer
dim s as string

s=ReplaceLineEndings(EditField1.text,EndOfLine.UNIX)

r=new RegExMBS

'r.CompileOptionFirstLine=True
r.CompileOptionMultiline=True

if r.Compile("^....$") then
  n=0
  do
    c=r.Execute(s,n)
    
    if c>0 then
      MsgBox r.Substring(0)
      n=r.Offset(1)
    end if
    
  loop until c=0
end if

(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Multiline
• /RegEx/RegEx/RegEx Speed Test
• /RegEx/RegEx/RegExMBS
• /RegEx/RegEx/Test RegEx1
• /RegEx/RegEx/Test RegEx2

RegExMBS.CompileOptionNewLineAny as Boolean

Setting CompileOptionNewLineCR or CompileOptionNewLineLF specifies that a newline is indicated by a single character (CR or LF, respectively). Setting CompileOptionNewLineCRLF specifies that a newline is indicated by the two-character CRLF sequence. Setting CompileOptionNewLineAnyCRLF specifies that any of the three preceding sequences should be recognized. Setting CompileOptionNewLineAny specifies that any Unicode newline sequence should be recognized. The Unicode newline sequences are the three just mentioned, plus the single characters VT (vertical tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS (paragraph separator, U+2029). The last two are recognized only in UTF-8 mode.
The newline setting in the options word uses three bits that are treated as a number, giving eight possibilities. Currently only six are used (default plus the five values above). This means that if you set more than one newline option, the combination may or may not be sensible. For example, CompileOptionNewLineCR with CompileOptionNewLineLF is equivalent to CompileOptionNewLineCRLF, but other combinations may yield unused numbers and cause an error.

The only time that a line break in a pattern is specially recognized when compiling is when PCRE_EXTENDED is set. CR and LF are whitespace characters, and so are ignored in this mode. Also, an unescaped # outside a character class indicates a comment that lasts until after the next line break sequence. In other circumstances, line break sequences in patterns are treated as literal data.
(Read and Write property)

RegExMBS.CompileOptionNewLineAnyCRLF as Boolean

See CompileOptionNewLineAny for more details.
(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionNewLineCR as Boolean

See CompileOptionNewLineAny for more details.
(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionNewLineCRLF as Boolean

See CompileOptionNewLineAny for more details.
(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionNewLineLF as Boolean

See CompileOptionNewLineAny for more details.
(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegEx Speed Test

RegExMBS.CompileOptionNoAutoCapture as Boolean

(Read and Write property)

RegExMBS.CompileOptionNoStartOptimize as Boolean

If it is set at compile time, it is remembered with the compiled pattern and assumed at matching time.
(Read and Write property)

RegExMBS.CompileOptionNoUTF8Check as Boolean

(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test
• /RegEx/RegEx/RegExMBS

RegExMBS.CompileOptions as Integer

You can get and set the bits using the CompileOption* Boolean properties.
(Read and Write property)

RegExMBS.CompileOptionUngreedy as Boolean

Basicly this is about whether to find the next matching item or the last matching item in the whole string.
Matching the next item is always much faster.
(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test
• /RegEx/RegEx/RegExMBS
• /RegEx/RegEx/Test RegEx1
• /RegEx/RegEx/Test RegEx2

RegExMBS.CompileOptionUnicodeCodePoints as Boolean

This option changes the way PCRE processes \B, \b, \D, \d, \S, \s, \W, \w, and some of the POSIX character classes. By default, only ASCII characters are recognized, but if PCRE_UCP is set, Unicode properties are used instead to classify characters. More details are given in the section on generic character types in the pcrepattern page. If you set PCRE_UCP, matching one of the items it affects takes much longer. The option is available only if PCRE has been compiled with Unicode property support.
(Read and Write property)

RegExMBS.CompileOptionUTF8 as Boolean

(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test

RegExMBS.Count as Integer

dim r as new RegExMBS
dim searchString as string = ".o"

if r.Compile(searchString) then
  
  dim s as string="äöü Hello World"
  
  if r.Execute(s,0)>0 then
    dim lines(-1) as string
    
    lines.Append str(R.Count)+" offset found."
    lines.Append "In Bytes:"
    lines.Append "  Start of matched patern: "+str(R.Offset(0))
    lines.Append "  End of matched patern: "+str(R.Offset(1))
    lines.Append "  Length of matched patern: "+str(R.Offset(1)-r.Offset(0))
    
    lines.Append "In Characters:"
    lines.Append "  Start of matched patern: "+str(R.OffsetCharacters(0))
    lines.Append "  End of matched patern: "+str(R.OffsetCharacters(1))
    lines.Append "  Length of matched patern: "+str(R.OffsetCharacters(1)-r.OffsetCharacters(0))
    
    MsgBox Join(lines,EndOfLine)
  end if
  
else
  MsgBox "failed to compile"
end if

(Read only property)

RegExMBS.ErrorMessage as String

Set by Study and Compile.
(Read only property)

RegExMBS.ErrorOffset as Integer

(Read only property)

RegExMBS.ExecuteOptionAnchored as Boolean

(Read and Write property)

RegExMBS.ExecuteOptionBSRAnyCRLF as Boolean

The choice is either to match only CR, LF, or CRLF, or to match any Unicode newline sequence. The default is specified when PCRE is built. It can be overridden from within the pattern, or by setting an option when a compiled pattern is matched.
(Read and Write property)

RegExMBS.ExecuteOptionBSRUnicode as Boolean

dim rg As new RegExMBS
rg.CompileOptionUngreedy = false
rg.ExecuteOptionBSRUnicode = true

dim ts as string = "one" + EndOfLine.UNIX + "test" + chr(&h2028) + "more"

// replace all end lines with #
if rg.Compile("\R+") then
  
  ts = rg.ReplaceAll(ts,"#")
  
end if

MsgBox ts

The choice is either to match only CR, LF, or CRLF, or to match any Unicode newline sequence. The default is specified when PCRE is built. It can be overridden from within the pattern, or by setting an option when a compiled pattern is matched.
(Read and Write property)

RegExMBS.ExecuteOptionNewLineAny as Boolean

Setting ExecuteOptionNewLineCR or ExecuteOptionNewLineLF specifies that a newline is indicated by a single character (CR or LF, respectively). Setting ExecuteOptionNewLineCRLF specifies that a newline is indicated by the two-character CRLF sequence. Setting ExecuteOptionNewLineAnyCRLF specifies that any of the three preceding sequences should be recognized. Setting ExecuteOptionNewLineAny specifies that any Unicode newline sequence should be recognized. The Unicode newline sequences are the three just mentioned, plus the single characters VT (vertical tab, U+000B), FF (formfeed, U+000C), NEL (next line, U+0085), LS (line separator, U+2028), and PS (paragraph separator, U+2029). The last two are recognized only in UTF-8 mode.
The newline setting in the options word uses three bits that are treated as a number, giving eight possibilities. Currently only six are used (default plus the five values above). This means that if you set more than one newline option, the combination may or may not be sensible. For example, ExecuteOptionNewLineCR with ExecuteOptionNewLineLF is equivalent to ExecuteOptionNewLineCRLF, but other combinations may yield unused numbers and cause an error.

The only time that a line break in a pattern is specially recognized when compiling is when PCRE_EXTENDED is set. CR and LF are whitespace characters, and so are ignored in this mode. Also, an unescaped # outside a character class indicates a comment that lasts until after the next line break sequence. In other circumstances, line break sequences in patterns are treated as literal data.
(Read and Write property)

RegExMBS.ExecuteOptionNewLineAnyCRLF as Boolean

See ExecuteOptionNewLineAny for more details.
(Read and Write property)

RegExMBS.ExecuteOptionNewLineCR as Boolean

See ExecuteOptionNewLineAny for more details.
(Read and Write property)

RegExMBS.ExecuteOptionNewLineCRLF as Boolean

See ExecuteOptionNewLineAny for more details.
(Read and Write property)

RegExMBS.ExecuteOptionNewLineLF as Boolean

See ExecuteOptionNewLineAny for more details.
(Read and Write property)

RegExMBS.ExecuteOptionNoStartOptimize as Boolean

For example, if it is known that an unanchored match must start with a specific character, it searches the subject for that character, and fails immediately if it cannot find it, without actually running the main matching function. This means that a special item such as (*COMMIT) at the start of a pattern is not considered until after a suitable starting point for the match has been found. When callouts or (*MARK) items are in use, these "start-up" optimizations can cause them to be skipped if the pattern is never actually used. The start-up optimizations are in effect a pre-scan of the subject that takes place before the pattern is run.
The ExecuteOptionNoStartOptimize option disables the start-up optimizations, possibly causing performance to suffer, but ensuring that in cases where the result is "no match", the callouts do occur, and that items such as (*COMMIT) and (*MARK) are considered at every possible starting position in the subject string. If ExecuteOptionNoStartOptimize is set at compile time, it cannot be unset at matching time.

Setting ExecuteOptionNoStartOptimize can change the outcome of a matching operation. Consider the pattern

(*COMMIT)ABC
When this is compiled, PCRE records the fact that a match must start with the character "A". Suppose the subject string is "DEFABC". The start-up optimization scans along the subject, finds "A" and runs the first match attempt from there. The (*COMMIT) item means that the pattern must match the current starting position, which in this case, it does. However, if the same match is run with ExecuteOptionNoStartOptimize set, the initial scan along the subject string does not happen. The first match attempt is run starting from "D" and when this fails, (*COMMIT) prevents any further matches being tried, so the overall result is "no match". If the pattern is studied, more start-up optimizations may be used. For example, a minimum length for the subject may be recorded. Consider the pattern
(*MARK:A)(X|Y)
The minimum length for a match is one character. If the subject is "ABC", there will be attempts to match "ABC", "BC", "C", and then finally an empty string. If the pattern is studied, the final attempt does not take place, because PCRE knows that the subject is too short, and so the (*MARK) is never encountered. In this case, studying the pattern does not affect the overall match result, which is still "no match", but it does affect the auxiliary information that is returned.
(Read and Write property)

RegExMBS.ExecuteOptionNotBOL as Boolean

(Read and Write property)

RegExMBS.ExecuteOptionNotEmpty as Boolean

(Read and Write property)

Some examples using this property:

• /RegEx/PCRE2/PCRE2 Speed Test
• /RegEx/RegEx/RegEx Speed Test

RegExMBS.ExecuteOptionNotEmptyAtStart as Boolean

This is like ExecuteOptionNotEmpty, except that an empty string match that is not at the start of the subject is permitted. If the pattern is anchored, such a match can occur only if the pattern contains \K.
Perl has no direct equivalent of ExecuteOptionNotEmpty or ExecuteOptionNotEmptyAtStart, but it does make a special case of a pattern match of the empty string within its split() function, and when using the /g modifier. It is possible to emulate Perl's behaviour after matching a null string by first trying the match again at the same offset with ExecuteOptionNotEmptyAtStart and ExecuteOptionAnchored, and then if that fails, by advancing the starting offset (see below) and trying an ordinary match again. There is some code that demonstrates how to do this in the pcredemo sample program. In the most general case, you have to check to see if the newline convention recognizes CRLF as a newline, and if so, and the current character is CR followed by LF, advance the starting offset by two characters instead of one.
(Read and Write property)

RegExMBS.ExecuteOptionNotEOL as Boolean

(Read and Write property)

RegExMBS.ExecuteOptionNoUTF8Check as Boolean

(Read and Write property)

Some examples using this property:

• /RegEx/RegEx/RegExMBS

RegExMBS.ExecuteOptionPartial as Boolean

(Read and Write property)

RegExMBS.ExecuteOptionPartialHard as Boolean

A partial match occurs if the end of the subject string is reached successfully, but there are not enough subject characters to complete the match. If this happens when ExecuteOptionPartial (but not ExecuteOptionPartialHard) is set, matching continues by testing any remaining alternatives. Only if no complete match can be found is ErrorPartial returned instead of PCRE_ERROR_NOMATCH. In other words, ExecuteOptionPartial says that the caller is prepared to handle a partial match, but only if no complete match can be found.
If ExecuteOptionPartialHard is set, it overrides ExecuteOptionPartial. In this case, if a partial match is found, Execute() immediately returns ErrorPartial, without considering any other alternatives. In other words, when ExecuteOptionPartialHard is set, a partial match is considered to be more important that an alternative complete match.

In both cases, the portion of the string that was inspected when the partial match was found is set as the first matching string. There is a more detailed discussion of partial and multi-segment matching, with examples, in the pcrepartial documentation.
(Read and Write property)

RegExMBS.ExecuteOptions as Integer

You can get and set the bits using the CompileOption* Boolean properties.
(Read and Write property)

RegExMBS.Handle as Integer

(Read only property)

RegExMBS.InfoCaptureCount as Integer

Only valid after pattern was compiled.
(Read only property)