RegexOptions constexpr

Added constexpr to several of the RegexOptions-related functions/overloads.
RegexOptions Style Fix

Fixed the style of several RegexOptions-related functions, removing an extraneous line and thus making the functions more readable.
RegexCompilerState Change

Due to the fact that many Unicode operations are context-sensitive, it is often necessary to be able to look backward as well as forward within a string.

Accordingly, changed the RegexCompilerState class so that it holds not just a begin (i.e. current position) and end iterator, but a begin, current, and end iterator, which allows parsers to look forward and backward in the pattern for context-sensitive Unicode operations.
Regular Expression Compiler Fix

Fixed a bug which would cause the internal pointer used to track which parser was used to parse the last pattern element to be erroneously set if a pattern element unset the Fail flag on the RegexCompilerState.
RegexLiteral IgnorePatternWhiteSpace

The RegexLiteral parser will now ignore unescaped pattern white space when RegexOptions::IgnorePatternWhiteSpace is set.
RegexCompilerState::Raise

Added the Raise method to the RegexCompilerState class, which throws a RegexError with a provided message at the current point within the regular expression pattern.
RegexComment

Added a parser which skips comments in regular expression patterns.
RegexLiteral const Correctness

The installer for RegexLiteralParser should have been const, but wasn't.
RegexPatternElement::Check

Added the protected member function Check to the RegexPatternElement class, which takes a RegexOptions as an argument, and checks that against the RegexOptions stored within the RegexPatternElement.

This has the effect of eliminating an argument to Check whenever used within a RegexPatternElement (see changes to regexliteral.cpp for example).
RegexWildcard

Added a parser and pattern element for the wildcard.
Regular Expression Compiler Changes

Modified the RegexCompiler class so that its operator () overload -- which compiles a pattern -- doesn't take individual arguments, but rather an entire RegexCompilerState.

Added a virtual Done method to the RegexCompilerState class, which returns true if the current point in the underlying pattern is where the RegexCompiler should stop compiling.

This will enable an important use case -- compiling only part of a pattern.  This will be necessary for implementing pattern elements which logically contain many other pattern elements -- grouping constructs for example.
Regular Expression Compiler Character Class Support

Modified the RegexCompiler and supporting classes/etc. to support character class compilation.
Regular Expression Compiler Cleanup/STL Algorithm Use

Changed the implementation of the static add_impl method in regexcompiler.cpp so that it uses an STL algorithm -- std::find_if -- to find the insertion point for parsers, rather than providing its own implementation of this algorithm.
Regular Expression Compiler Error Implementation

Provided the code to throw an exception when the regular expression compiler cannot advance past a particular point in the pattern.
Regex::Escape

Added the Regex::Escape static method, which escapes a Unicode string making it safe for insertion into a regular expression pattern (i.e. it will thereafter be interpreted literally, i.e. none of the code points therein will be interpreted as metacharacters).