|
|
Introduction
This section covers the regular expression syntax used by
eValid's SiteMap text searches.
All regular expresssion searches are case sensitive so it is
important to specify the search string carefully.
Literals
All characters are literals except: ".",
"*", "?", "+", "(",
")", "{", "}", "[",
"]", "^" and "$". These characters
are literals when preceded by a "\". A literal is a
character that matches itself.
Wildcards
The dot character "." -- the so-called wildcard -- matches any single 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.
An expression followed by "?" may be repeated zero or one times only. 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.
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. 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", but not "baa"
"ba{2,4}" will match "baa", "baaa" and "baaaa", but not "ba" or "baaaaaa"
Non-greedy repeats
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 text between the tag pairs will be the shortest possible matching string, i.e. the tag that closes the opening one.
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".
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)*"
Alternatives
Alternatives occur when the expression can match either one
sub-expression or another, each alternative is separated by a
"|". Each alternative is the largest possible previous sub-expression;
this is the opposite behavior 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 Examples:
"[abc]" will match either of "a", "b", or "c".
"[^abc] will match any character other than "a", "b", or "c".
Character Range Examples
"[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, ranges will only behave according to ASCII rules.
Character Classes
Character classes are denoted using the syntax "[:classname:]"
within a set declaration, for example "[[:space:]]" is
the set of all whitespace characters.
The available character classes are:
| alnum | Any alphanumeric character. | ||
| alpha | Any alphabetical character a-z and A-Z. Other characters may also be included depending upon the locale. | ||
| blank | Any blank character, either a space or a tab. | ||
| cntrl | Any control character. | ||
| digit | Any digit 0-9. | ||
| graph | Any graphical character. | ||
| lower | Any lower case character a-z. Other characters may also be included depending upon the locale. | ||
| Any printable character. | |||
| punct | Any punctuation character. | ||
| space | Any whitespace character. | ||
| upper | Any upper case character A-Z. Other characters may also be included depending upon the locale. | ||
| xdigit | Any hexadecimal digit character, 0-9, a-f and A-F. | ||
| word | Any word character - all alphanumeric characters plus the underscore. | ||
| unicode | Any character whose code is greater than 255, this applies to the wide character traits classes only. |
Shortcuts
There are some shortcuts that can be used in place of the character classes:
\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:]
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.
Characters By Code
This is an extension to the algorithm that is not available in
other libraries, it 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. |
Escape Operator
The escape character "\" has several meanings.
Inside a set declaration the escape character is a normal character unless the flag regbase::escape_in_lists is set 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: 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:
| Escape Sequence | Character Code | Meaning | ||
| \a | 0x07 | Bell character. | ||
| \f | 0x0C | Form feed. | ||
| \n | 0x0A | Newline character. | ||
| \r | 0x0D | Carriage return. | ||
| \t | 0x09 | Tab character. | ||
| \v | 0x0B | Vertical tab. | ||
| \e | 0x1B | ASCII Escape character. | ||
| \0dd | 0dd | An octal character code, where dd is one or more octal digits. | ||
| \xXX | 0xXX | A hexadecimal character code, where XX is one or more hexadecimal digits. | ||
| \x{XX} | 0xXX | A hexadecimal character code, where XX is one or more hexadecimal digits, optionally a unicode character. | ||
| \cZ | z-@ | An ASCII escape sequence control-Z, where Z is any ASCII character greater than or equal to the character code for '@'. |
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:
| \w | Equivalent to [[:word:]]. | ||
| \W | Equivalent to [^[:word:]]. | ||
| \s | Equivalent to [[:space:]]. | ||
| \S | Equivalent to [^[:space:]]. | ||
| \d | Equivalent to [[:digit:]]. | ||
| \D | Equivalent to [^[:digit:]]. | ||
| \l | Equivalent to [[:lower:]]. | ||
| \L | Equivalent to [^[:lower:]]. | ||
| \u | Equivalent to [[:upper:]]. | ||
| \U | Equivalent to [^[:upper:]]. | ||
| \C | Any single character, equivalent to '.'. | ||
| \X | Match any Unicode combining character sequence, for example "a\x 0301" (a letter a with an acute). | ||
| \Q | The begin quote operator, everything that follows is treated as a literal character until a \E end quote operator is found. | ||
| \E | The end quote operator, terminates a sequence begun with \Q. |
What Gets Matched?
The regular expression library 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.
In cases where there 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.
Note: Use of the Regex++ system, on which this eValid product feature and its documentation is based, is gratefully acknowledged: © Copyright Dr. John Maddock (John_Maddock@compuserve.com) 1998-2007 All Rights Reserved.
