Sample image

Introduction

I think most people will think of Boost::Regex or PCRE when they want to use Regular Expressions in a C++ project. However, in fact, Microsoft has its own regular expression implementation as part of the ATL server, and it is called CAtlRegExp. And as a bonus, CAtlRegExp supports not only ASCII and Unicode, but also MBCS.

Supported Regular Expression Syntax

The following tables are copied from MSDN. You can note that the syntax is not exactly the same as in Perl. For example, the grouping operator is {}, while in Perl it is (), and it doesn't have the {n} (match exactly n times) as in the Perl syntax<.

Metacharacter	Meaning
.	Matches any single character.
[ ]	Indicates a character class. Matches any character inside the brackets (for example, `[abc]` matches "a", "b", and "c").
^	If this metacharacter occurs at the start of a character class, it negates the character class. A negated character class matches any character except those inside the brackets (for example, `[^abc]` matches all characters except "a", "b", and "c"). If `^` is at the beginning of the regular expression, it matches the beginning of the input (for example, `^[abc]` will only match input that begins with "a", "b", or "c").
-	In a character class, indicates a range of characters (for example, `[0-9]` matches any of the digits "0" through "9").
?	Indicates that the preceding expression is optional: it matches once or not at all (for example, `[0-9][0-9]?` matches "2" and "12").
+	Indicates that the preceding expression matches one or more times (for example, `[0-9]+` matches "1", "13", "666", and so on).
*	Indicates that the preceding expression matches zero or more times.
??, +?, *?	Non-greedy versions of `?`, `+`, and ``. These match as little as possible, unlike the greedy versions which match as much as possible. Example: given the input "<abc><def>", `<.?>` matches "<abc>" while `<.*>` matches "<abc><def>".
( )	Grouping operator. Example: `(\d+,)*\d+` matches a list of numbers separated by commas (such as "1" or "1,23,456").
{ }	Indicates a match group. The actual text in the input that matches the expression inside the braces can be retrieved through the CAtlREMatchContext object.
\	Escape character: interpret the next character literally (for example, `[0-9]+` matches one or more digits, but `[0-9]\+` matches a digit followed by a plus character). Also used for abbreviations (such as `\a` for any alphanumeric character; see table below). If `\` is followed by a number n, it matches the nth match group (starting from 0). Example: `<{.?}>.?</\0>` matches "<head>Contents</head>". Note that in C++ string literals, two backslashes must be used: `"\\+"`, `"\\a"`, `"<{.?}>.?</\\0>"`.
$	At the end of a regular expression, this character matches the end of the input. Example: `[0-9]$` matches a digit at the end of the input.
\|	Alternation operator: separates two expressions, exactly one of which matches (for example, `T\|the` matches "The" or "the").
!	Negation operator: the expression following `!` does not match the input. Example: `a!b` matches "a" not followed by "b".

CAtlRegExp can handle abbreviations, such as \d instead of [0-9]. The abbreviations are provided by the character traits class passed in the CharTraits parameter. The predefined character traits classes provide the following abbreviations:

Abbreviation	Matches
\a	Any alphanumeric character: ([a-zA-Z0-9])
\b	White space (blank): ([ \\t])
\c	Any alphabetic character: ([a-zA-Z])
\d	Any decimal digit: ([0-9])
\h	Any hexadecimal digit: ([0-9a-fA-F])
\n	Newline: (\r\|(\r?\n))
\q	A quoted string: (\"[^\"]\")\|(\'[^\']\')
\w	A simple word: ([a-zA-Z]+)
\z	An integer: ([0-9]+)

Using the code

Although CAtlRegExp is part of the ATL server classes, you don't have to be an ATL project in order to use this class, simply #include "atlrx.h" is enough.

I have written a simple Dialog based program to test/demo the CAtlRegExp. The core of the program is listed as follows:

// create regular expression content
CAtlRegExp<> regex;
REParseError status = regex.Parse(m_szRegex, m_bCaseSensitive);

if (REPARSE_ERROR_OK != status) {
  // invalid pattern, show error
  m_szStatus = TEXT("Parser Error: ");
  m_szStatus += REError2String(status);
} else {
  // valid regex pattern, now try to match the content
  CAtlREMatchContext<> mc;
  if (!regex.Match(m_szInput, &mc)) {
    // content not match
    m_szStatus = TEXT("No match");
  } else {
    // content match, show match-group
    m_szStatus = TEXT("Success match");
    for (UINT nGroupIndex = 0; nGroupIndex < mc.m_uNumGroups; 
         ++nGroupIndex) {
      const CAtlREMatchContext<>::RECHAR* szStart = 0;
      const CAtlREMatchContext<>::RECHAR* szEnd = 0;
      mc.GetMatch(nGroupIndex, &szStart, &szEnd);
      ptrdiff_t nLength = szEnd - szStart;
      CString text(szStart, nLength);
      m_ctrlListBox.AddString(text);
    }
  }
}

And the function REError2String is listed as follows:

// refer to REParseError for more information
CString CMfcRegexDlg::REError2String(REParseError status)
{
  switch (status) {
    case REPARSE_ERROR_OK:
         return TEXT("No error occurred");
    case REPARSE_ERROR_OUTOFMEMORY:
         return TEXT("Out of memory");
    case REPARSE_ERROR_BRACE_EXPECTED:
         return TEXT("A closing brace was expected");
    case REPARSE_ERROR_PAREN_EXPECTED:
         return TEXT("A closing parenthesis was expected");
    case REPARSE_ERROR_BRACKET_EXPECTED:
         return TEXT("A closing bracket was expected");
    case REPARSE_ERROR_UNEXPECTED:
         return TEXT("An unspecified fatal error occurred");
    case REPARSE_ERROR_EMPTY_RANGE:
         return TEXT("A range expression was empty");
    case REPARSE_ERROR_INVALID_GROUP:
         return TEXT("A back reference was made to a group" 
                     " that did not exist");
    case REPARSE_ERROR_INVALID_RANGE:
         return TEXT("An invalid range was specified");
    case REPARSE_ERROR_EMPTY_REPEATOP:
         return TEXT("A repeat operator (* or +) was applied" 
                     " to an expression that could be empty");
    case REPARSE_ERROR_INVALID_INPUT:
         return TEXT("The input string was invalid");
    default: return TEXT("Unknown error");
  }
}

Special note about MBCS

By default, CAtlRegExp uses CAtlRECharTraits, which is CAtlRECharTraitsA for non-Unicode version. However, unless you are using strict and pure ASCII, you should use CAtlRECharTraitsMB; otherwise, you may encounter some un-expected results in non-ASCII text. For example, the Chinese character for ("word") in Big5 encoding is the two byte word "\0xA6 r", which has a 'r' in as the second byte.

References

History

6^th March 2006: Initial version uploaded.

Using Regular Expressions in MFC