Helicon Ape

Regular expression syntax

Literals

All characters are literals except: ".", "*", "?", "+", "(", ")", "{", "}", "[", "]", "^" and "$". These characters are literals when preceded by "\". A literal is a character that matches itself.

Wildcard

The dot character "." matches any single character except null character and 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. 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.

Example

"ba*" #will match all of "b", "ba", "baaa" etc    
"ba+" #will match "ba" or "baaaa" but not "b"
"ba?" #will match "b" or "ba"
"ba{2,4}" #will match "baa", "baaa" and "baaaa"

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.

Example

#this will match html tag pairs
"<\s*tagname[^>]*>(.*?)<\s*/tagname\s*>"

In this case $1 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.

Example:

"(ab)*" #would match all of the string "ababab"

All sub matches marked by parenthesis can be back referenced using \N or $N syntax. It is permissible for sub-expressions to match null strings. Sub-expressions are indexed from left to right starting from 1, sub-expression 0 is the whole expression.

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.

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.

Example:

"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.

Example:

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 from "a" to "z"
"[^A-Z]" #will match any character except those in the range from "A" to "Z"

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 alpha numeric 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.
print 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.

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:] 

Collating elements

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 [,]. Helicon Ape 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

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 precede it 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. 

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. In ISAPI_Rewrite all back references are global for entire RewriteRule and corresponding RewriteCond directives. Sub matches are numbered up to down and left to right beginning from the first RewriteCond directive of the corresponding RewriteRule directive, if there is one.

Forward Lookahead Asserts

There are two types: positive and negative forward lookahead asserts:

Example:

"(?=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"

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.

  • 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:

Miscellaneous escape sequences:

What gets matched?

The regular expression will match against the first possible matching string, if more than one string starting from the given position can be matched, the longest possible string will get matched. When there are multiple possible matches all starting from the same position and all of the same length, the one with the longest first sub-expression will get matched; if is is the same for two or more matches, the second sub-expression will be examined and so on. Note that Helicon Ape uses MATCH algorithm. The result is matched only if the expression matches against the whole input sequence. For example:

Example:

RewriteCond URL ^/somedir/.* #will match any request to somedir directory and subdirectories, while
RewriteCond URL ^/somedir/ #will match only request to the root of the somedir

Special note about "pathological" regular expressions

Helicon Ape uses highly powerful regular expressions engine Regex++ from Boost library. However it has some limitations: There are some "pathological" expressions which may require exponential time for matching; these all involve nested repetition operators, for example attempting to match the expression "(a*a)*b" against N letters "a" requires time proportional to 2N. These expressions may (almost) always be rewritten another way to avoid the problem, for example "(a*a)*b" may be rewritten as "a*b" which requires time only linearly proportional to N to solve. In the general case, non-nested repeat expressions require time proportional to N2, however, if the clauses are mutually exclusive, they can be matched in linear time - this is the case with "a*b", for each character the matcher will either match an "a" or a "b" or fail, whereas with "a*a" the matcher can't tell which branch to take (the first "a" or the second) and so has to try both.

Regex++ can detect such "pathological" regular expressions and terminate their processing. This will cause Helicon Ape mod_rewrite rule to fail. When a rule fails, Helicon Ape sends "500 Internal Server error - Rule Failed" status to a client to indicate configuration error.