RegexMatch (String function)

Position after match of regex (String class)

The RegexMatch intrinsic function determines whether a given pattern (regular expression, or "regex") matches within a given string according to the rules of regular expression matching.

Syntax

%number = string:RegexMatch( regex, [Options= string], - [CaptureList= stringlist]) Throws InvalidRegex

Syntax terms

%number A variable to return the position of the character after the last character matched, or a zero if no characters in the method object string match the regular expression.

string The input string, to which the regular expression regex is applied.

regex A string that is interpreted as a regular expression and is applied to the method object string to determine whether the regex matches string.

Options

This is an optional, but nameRequired, parameter supplying a string of single letter options, which may be specified in uppercase or lowercase, in any combination, and blank separated or not as you prefer. For more information about these options, see "Common regex options".

`I`	Do case-insensitive matching between `string` and `regex`.
`S`	Dot-All mode: a period (`.`) can match any character, including carriage return and linefeed.
`M`	Multi-line mode: let anchor characters match end-of-line indicators *wherever* the indicator appears in the input string. `M` mode is ignored if `C` (XML Schema) mode is specified.
`C`	Do the match according to `"XML Schema regex rules"`. Each `regex` is implicitly anchored at the beginning and end, and no characters serve as anchors.

CaptureList

Exceptions

RegexMatch can throw the following exceptions:

InvalidRegex: If the regex parameter does not contain a valid regular expression. The exception object indicates the position of the character in the regex parameter where it was determined that the regular expression is invalid, and a description of the nature of the error.

Usage notes

It is strongly recommended that you protect your environment from regular expression processing demands on PDL and STBL space by setting, say, UTABLE LPDLST 3000 and UTABLE LSTBL 9000. See "User Language programming considerations".
For information about additional methods that support regular expressions, see "Regex Processing".
RegexMatch is something of a misnomer. It does not determine if a string matches a regular expression, it determines if a string contains a substring that matches a regular expression. RegexMatch behaves more like a matching method if the regular expression is "anchored" (begins with a caret ('&circ;') and ends with a dollar sign ('$')), or if the C option indicates XML Schema mode.
RegexMatch is available as of Sirius Mods Version 7.2.

Examples

Finding the first position of one of several characters

A common programming problem is to "scan" a string, and find the first position which is one of several characters. This can be readily accomplished with RegexMatch; here is an example of this:

%regex = '[aeiou]'; * Scan for any vowel %str = 'That quick brown fox' %i = %str:regexMatch(%regex) if %i then printText Before vowel: {%str:Left(%i - 2)} printText The vowel: {%str:Char(%i-1)} printText After vowel: {%str:Substring(%i)}

The result of the above fragment is:

Before vowel: Th The vowel: a After vowel: t quick brown fox

Notes:

The position returned by RegexMatch is the position of the character after the first successful match.
The square brackets enclose a character class ([aeiou]), which matches any of the character listed within it. RegexMatch recognizes either the codepage 1047 (X'AD'/X'BD') or codepage 0037 (X'BA'/X'BB') characters as square brackets.
In many cases, this programming problem is better performed using the StringTokenizer.

Finding the first position which isn't one of several characters

A similar programming task is finding the position of the first character which is not one of a set of characters; this is readily accomplished with RegexMatch (and is not as amenable to processing with the StringTokenizer. Here is an example:

%regex = '[' '5F':HexToString 'aeiou]'; * Scan for any non-vowel %i = %str:regexMatch(%regex) %str = 'albatross' if %i then printText Before non-vowel: {%str:Left(%i - 2)} printText The non-vowel: {%str:Char(%i-1)} printText After non-vowel: {%str:Substring(%i)}

The result of the above fragment is:

Before non-vowel: a The non-vowel: l After non-vowel: batross

Note the following statement:

%regex = '[' '5F':HexToString 'aeiou]'

This is the same as %regex = '[^aeiou]'; the circumflex or "caret" (^) has the meaning of "negation" at the start of a character class (the regex fragment within square brackets). The EBCDIC code which RegexMatch uses for the circumflex is X'5F', as used by codepage 1047. Using the hex code point as above ensures that your regex will work whether the program was entered with codepage 1047 or 0037.

Using a few other regex features

The following example tests whether the regex '\*bc?[5-8]' matches 'a*b6' (it does, and note that it matches "in the middle" of the string).

begin %rc float %regex longstring %string longstring %regex = '\*bc?[5-8]' %string = 'a*b6' %rc = %string:regexmatch(%regex) if %rc then printText '{%regex}' matches '{%string}' else printText '{%regex}' does not match '{%string}' end if end

The regex matches the input string; the example result is:

'\*bc?[5-8]' matches 'a*b6'

This regex demonstrates the following:

To match a string, a regex pattern must merely "fit" a substring of the string.
Metacharacters, in this case star ('*'), must be escaped.
An optional character ('c?') may fail to find a match, but this does not prevent the success of the overall match.
The character class range ('[5-8]') matches the '6' in the input string.

Float class String class Unicode class	List of Float methods List of String methods List of Unicode methods List of Intrinsic methods	Float methods syntax String methods syntax Unicode methods syntax
Notation conventions for methods