Regular Expressions
The regular expression syntax used within TextConverter, and other SiMX Target components, is taken from the documentation provided by Dr. John Maddock in his Regex++ library. The actual syntax that is valid in the Expression property depends on the options chosen in the ExpressionOptions property.
Literals
All characters are literals except: ".", "*", "?", "+", "(", ")", "{", "}", "[", "]", "^", "$" and "\". These characters are literals when preceded by a "\". A literal is a character that matches itself.
Wildcard
The dot character "." matches any single character except when MatchOptions :
includes MatchNotDotNullCharacter, the dot does not match a null character;
includes MatchNotDotNewline, then the dot does not match a newline character.
Repeats
A repeat is an expression that is repeated an arbitrary number of times.
An expression followed by "*" can be repeated any number of times including zero.
An expression followed by "+" can be repeated any number of times, but at least once. If the ExpressionOptions includes QuestionmarkPlusNotOperators then "+" is an
ordinary character and "\+" represents a repeat of once or more.
An expression followed by "?" may be repeated zero or one times only. If the ExpressionOptions property includes QuestionmarkPlusNotOperators then "?" is an ordinary character and "\?" represents the repeat zero or once operator.
When it is necessary to specify the minimum and maximum number of repeats explicitly, the bounds operator "{}" may be used. Thus "a{2}" is the letter "a" repeated exactly twice, "a{2,4}" represents the letter "a" repeated between 2 and 4 times, and "a{2,}" represents the letter "a" repeated at least twice with no upper limit. These are all called repetition intervals. Note that there must be no white-space inside the {}, and there is no upper limit on the values of the lower and upper bounds. If the ExpressionOptions property includes BracesNotOperators then "{" and "}" are ordinary characters and "\{" and "\}" are used to delimit bounds instead.
All repeat expressions refer to the shortest possible previous sub-expression: a single character; a character set, or a sub-expression grouped with "()" for example.
Examples:
"ba*" will match all of "b", "ba", "baaa" etc.
"ba+" will match "ba" or "baaaa" for example but not "b".
"ba?" will match "b" or "ba".
"ba{2,4}" will match "baa", "baaa" and "baaaa".
Non-greedy repeats
Whenever ExpressionOptions is set to Extended then non-greedy repeats are possible by appending a '?' after the repeat; a non-greedy repeat is one which will match the shortest possible string.
For example to match html tag pairs one could use something like:
"<\s*tagname[^>]*>(.*?)<\s*/tagname\s*>"
In this case the first matched sub-expression will contain the text between the tag pairs, and will be the shortest possible matching string.
Parenthesis
Parentheses serve two purposes, to group items together into a sub-expression, and to mark what generated the match. For example the expression "(ab)*" would match all of the string "ababab". The matching events contain information both on what the whole expression matched and on what each sub-expression matched. It is permissible for sub-expressions to match null strings. If a sub-expression takes no part in a match - for example if it is part of an alternative that is not taken - then the string that is returned for that sub-expression is empty.
Non-Marking Parenthesis
Sometimes you need to group sub-expressions with parenthesis, but don't want the parenthesis to spit out another marked sub-expression, in this case a non-marking parenthesis (?:expression) can be used. For example the following expression creates no sub-expressions:
"(?:abc)*"
Forward Lookahead Asserts
There are two forms of these; one for positive forward lookahead asserts, and one for negative lookahead asserts:
"(?=abc)" matches zero characters only if they are followed by the expression "abc".
"(?!abc)" matches zero characters only if they are not followed by the expression "abc".
Alternatives: Alternatives occur when the expression can match either one sub-expression or another.
Each alternative is separated by a "|", or a "\|" if ExpressionOptions includes VerticalbarNotOperator, or by a newline character if ExpressionOptions includes NewlineAsAlternationOperator. Each alternative is the largest possible previous sub-expression; this is the opposite behaviour from repetition operators.
Examples:
"a(b|c)" could match "ab" or "ac".
"abc|def" could match "abc" or "def".
Sets
A set is a set of characters that can match any single character that is a member of the set. Sets are delimited by "[" and "]" and can contain literals, character ranges, character classes, collating elements and equivalence classes. Set declarations that start with "^" contain the compliment of the elements that follow.
Character literals
"[abc]" will match either of "a", "b", or "c".
"[^abc] will match any character other than "a", "b", or "c".
Character ranges
"[a-z]" will match any character in the range "a" to "z".
"[^A-Z]" will match any character other than those in the range "A" to "Z".
Note that character ranges are highly locale dependent: they match any character that collates between the endpoints of the range, and ranges will only behave according to ASCII rules when the default "C" locale is in effect. You can set a different locale by setting the public property Locale. For example if you set the Win32 localisation model, then [a-z] will match the ASCII characters a-z, and also 'A', 'B' etc, but not 'Z' which collates just after 'z'. This locale specific behaviour can be disabled by including NoLocaleSpecificCollation in the ExpressionOptions property. This is the default behaviour when specifying Normal in the ExpressionOptions property, and forces ranges to collate according to ASCII character code.
Character classes
They are denoted using the syntax "[:classname:]", for example "[[:space:]]" is the set of all whitespace characters. Character classes are only available if the ExpressionOptions property includes CharacterClasses.
The available character classes are:
There are some shortcuts that can be used in place of the character classes, provided that ExpressionOptions includes EscapeInCharacterSets. Then you can use:
\w in place of [:word:]
\s in place of [:space:]
\d in place of [:digit:]
\l in place of [:lower:]
\u in place of [:upper:]
Collating elements take the general form [.tagname.] inside a set declaration, where tagname is either a single character, or a name of a collating element, for example [[.a.]] is equivalent to [a], and [[.comma.]] is equivalent to [,]. The library supports all the standard POSIX collating element names, and in addition the following digraphs: "ae", "ch", "ll", "ss", "nj", "dz", "lj", each in lower, upper and title case variations. Multi-character collating elements can result in the set matching more than one character, for example [[.ae.]] would match two characters, but note that [^[.ae.]] would only match one character.
Equivalence classes take the general form [=tagname=] inside a set declaration, where tagname is either a single character, or a name of a collating element, and matches any character that is a member of the same primary equivalence class as the collating element [.tagname.]. An equivalence class is a set of characters that collate the same, a primary equivalence class is a set of characters whose primary sort key are all the same (for example strings are typically collated by character, then by accent, and then by case; the primary sort key then relates to the character, the secondary to the accentation, and the tertiary to the case). If there is no equivalence class corresponding to tagname, then [=tagname=] is exactly the same as [.tagname.].
To include a literal "-" in a set declaration then: make it the first character after the opening "[" or "[^", the endpoint of a range, a collating element, or, provided that ExpressionOptions includes EscapeInCharacterSets, then precede with an escape character as in "[\-]". To include a literal "[" or "]" or "^" in a set then make them the endpoint of a range, a collating element, or precede with an escape character if ExpressionOptions includes EscapeInCharacterSets.
Line anchors
An anchor is something that matches the null string at the start or end of a line: "^" matches the null string at the start of a line, "$" matches the null string at the end of a line.
Back references
A back reference is a reference to a previous sub-expression that has already been matched. The reference is to what the sub-expression matched, not to the expression itself. A back reference consists of the escape character "\" followed by a digit "1" to "9", "\1" refers to the first sub-expression, "\2" to the second etc. For example the expression "(.*)\1" matches any string that is repeated about its mid-point for example "abcabc" or "xyzxyz". A back reference to a sub-expression that did not participate in any match, matches the null string: NB this is different to some other regular expression matchers. Back references are only available if ExpressionOptions includes BackReferences.
Characters by code
Characters by code consists of the escape character followed by the digit "0" followed by the octal character code. For example "\023" represents the character whose octal code is 23. Where ambiguity could occur use parentheses to break the expression up: "\0103" represents the character whose code is 103, "(\010)3 represents the character 10 followed by "3". To match characters by their hexadecimal code, use \x followed by a string of hexadecimal digits, optionally enclosed inside {}, for example \xf0 or \x{aff}, notice the latter example is a Unicode character.
Word operators
The following operators are provided for compatibility with the GNU regular expression library.
"\w" matches any single character that is a member of the "word" character class, this is identical to the expression "[[:word:]]".
"\W" matches any single character that is not a member of the "word" character class, this is identical to the expression "[^[:word:]]".
"\<" matches the null string at the start of a word.
"\>" matches the null string at the end of the word.
"\b" matches the null string at either the start or the end of a word.
"\B" matches a null string within a word.
The beginning of the string passed to the matching methods is considered to be a potential start of a word unless MatchOptions includes MatchNotBeginningOfWord.
The end of the string passed to the matching methods is considered to be a potential end of a word unless MatchOptions includes MatchNotEndOfWord.
Buffer operators
The following operators are provide for compatibility with the GNU regular expression library, and Perl regular expressions:
"\`" matches the start of a buffer.
"\A" matches the start of the buffer.
"\'" matches the end of a buffer.
"\z" matches the end of a buffer.
"\Z" matches the end of a buffer, or possibly one or more new line characters followed by the end of the buffer
The beginning of the string passed to the matching methods is considered to be a potential start of a buffer unless MatchOptions includes MatchNotBeginningOfBuffer.
The end of the string passed to the matching methods is considered to be a potential end of a buffer unless MatchOptions includes MatchNotEndOfBuffer.
Escape operator
The escape character "\" has several meanings.
Inside a set declaration the escape character is a normal character unless ExpressionOptions includes EscapeInCharacterSets in which case whatever follows the escape is a literal character regardless of its normal meaning.
The escape operator may introduce an operator for example: back references, or a word operator.
The escape operator may make the following character normal, for example "\*" represents a literal "*" rather than the repeat operator.
Single character escape sequences
The following escape sequences are aliases for single characters:
Miscellaneous escape sequences
The following are provided mostly for perl compatibility, but note that there are some differences in the meanings of \l \L \u and \U:
What gets matched?
The regular expression cpmponent will match the first possible matching string. If more than one string starting at a given location can match then it matches the longest possible string, unless MatchOptions includes MatchShortest, in which case the first match encountered is returned. Setting MatchOptions to include MatchShortest can reduce the time taken to find the match - but is only useful if the user is less concerned about what matched - for example it would not be suitable for search and replace operations. In cases where their are multiple possible matches all starting at the same location, and all of the same length, then the match chosen is the one with the longest first sub-expression. If that is the same for two or more matches, then the second sub-expression will be examined and so on.