The Pattern class supports the use of the following (Perl-like)
special escape sequences:
\b - indicating a word-boundary
\d - indicating a digit ([[:digit:]]) character
\s - indicating a white-space ([:space:]) character
\w - indicating a word ([:alnum:]) character
The corresponding capitals (e.g., \W) define the complementary character sets. The capitalized character set shorthands are not expanded inside explicit character-classes (i.e., [ ... ] constructions). So [\W] represents a set of two characters: \ and W.
As the backslash (\) is treated as a special character it should be handled carefully. Pattern converts the escape sequences \d \s \w (and outside of explicit character classes the sequences \D \S \W) to their respective character classes. All other escape sequences are kept as is, and the resulting regular expression is offered to the pattern matching compilation function regcomp(3). This function will again interpret escape sequences. Consequently some care should be exercised when defining patterns containing escape sequences. Here are the rules:
---------------------------------------------------------
Specify: Converts to: regcomp uses: Matches:
---------------------------------------------------------
\d [[:digit:]] [[:digit:]] 3
---------------------------------------------------------
---------------------------------------------------------
Specify: Converts to: regcomp uses: Matches:
---------------------------------------------------------
\x \x x x
---------------------------------------------------------
---------------------------------------------------------
Specify: Converts to: regcomp uses: Matches:
---------------------------------------------------------
\\x \\x \x \x
---------------------------------------------------------
REG_EXTENDED:
Use POSIX Extended Regular Expression syntax when
interpreting regex. If not set, POSIX Basic Regular
Expression syntax is used.
REG_NOSUB:
Support for substring addressing of matches is not
required. The nmatch and pmatch parameters to
regexec are ignored if the pattern buffer supplied
was compiled with this flag set.
REG_NEWLINE:
Match-any-character operators don't match a newline.
A non-matching list ([^...]) not containing a newline does not match a newline.
Match-beginning-of-line operator (^) matches the empty string immediately after a newline, regardless of whether eflags, the execution flags of regexec, contains REG_NOTBOL.
Match-end-of-line operator ($) matches the empty string immediately before a newline, regardless of whether eflags contains REG_NOTEOL.
Pattern offers copy and move constructors.
Options may be:
REG_NOTBOL:
The match-beginning-of-line operator always fails to match
(but see the compilation flag REG_NEWLINE above) This flag
may be used when different portions of a string are passed
to regexec and the beginning of the string should not be
interpreted as the beginning of the line.
REG_NOTEOL:
The match-end-of-line operator always fails to
match (but see the compilation flag REG_NEWLINE)
/*
driver.cc
*/
#include "driver.h"
//#include <bobcat/pattern>
#include "../pattern.ih"
using namespace std;
using namespace FBB;
#include <algorithm>
#include <cstring>
void Pattern::swap(Pattern &other)
{
fswap(*this, other);
fswap(d_text, other.d_text);
d_text.swap(other.d_text);
}
void showSubstr(string const &str)
{
static int
count = 1;
cout << "String " << count++ << " is '" << str << "'\n";
}
int main(int argc, char **argv)
{
// {
// Pattern one("one");
//// Pattern two(one);
// Pattern three("a");
// Pattern four;
// three = three;
// }
// try
// {
// Pattern pattern("aap|noot|mies");
//
// {
// Pattern extra(Pattern(pattern));
// }
//
// if (pattern << "noot")
// cout << "noot matches\n";
// else
// cout << ": noot doesn't match\n";
// }
// catch (exception const &e)
// {
// cout << e.what() << ": compilation failed" << endl;
// }
//
string pat = "\\d+";
while (true)
{
cout << "Pattern: '" << pat << "'\n";
try
{
Pattern patt(pat, argc == 1); // case sensitive by default,
// any arg for case insensitive
cout << "Compiled pattern: " << patt.pattern() << endl;
Pattern pattern;
pattern = patt; // assignment operator
while (true)
{
cout << "string to match : ";
string st;
getline(cin, st);
if (st == "")
break;
cout << "String: '" << st << "'\n";
try
{
pattern.match(st);
Pattern p3(pattern);
cout << "before: " << p3.before() << "\n"
"matched: " << p3.matched() << "\n"
"beyond: " << pattern.beyond() << "\n"
"end() = " << pattern.end() << endl;
for (size_t idx = 0; idx < pattern.end(); ++idx)
{
string str = pattern[idx];
if (str == "")
cout << "part " << idx << " not present\n";
else
{
Pattern::Position pos = pattern.position(idx);
cout << "part " << idx << ": '" << str << "' (" <<
pos.first << "-" << pos.second << ")\n";
}
}
}
catch (exception const &e)
{
cout << e.what() << ": " << st << " doesn't match" << endl;
continue;
}
}
}
catch (exception const &e)
{
cout << e.what() << ": compilation failed" << endl;
}
cout << "New pattern: ";
if (!getline(cin, pat) || !pat.length())
return 0;
}
}