From 8d1e74202626993f8966ec09731f521f24024a7c Mon Sep 17 00:00:00 2001 From: George Hazan Date: Sun, 10 Nov 2013 10:05:24 +0000 Subject: - custom bkstring class removed - code cleaning git-svn-id: http://svn.miranda-ng.org/main/trunk@6852 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- plugins/SmileyAdd/src/regexp/WCMatcher.cpp | 253 ++- plugins/SmileyAdd/src/regexp/WCMatcher.h | 20 +- plugins/SmileyAdd/src/regexp/WCPattern.cpp | 2744 ++++++++++++++-------------- plugins/SmileyAdd/src/regexp/WCPattern.h | 1196 ++++++------ 4 files changed, 2078 insertions(+), 2135 deletions(-) (limited to 'plugins/SmileyAdd/src/regexp') diff --git a/plugins/SmileyAdd/src/regexp/WCMatcher.cpp b/plugins/SmileyAdd/src/regexp/WCMatcher.cpp index d74fc9f9b5..354c474bdd 100644 --- a/plugins/SmileyAdd/src/regexp/WCMatcher.cpp +++ b/plugins/SmileyAdd/src/regexp/WCMatcher.cpp @@ -8,173 +8,172 @@ const int WCMatcher::MATCH_ENTIRE_STRING = 0x01; @author Jeffery Stuart @since November 2004 @version 1.07.00 -*/ + */ -WCMatcher::WCMatcher(WCPattern * pattern, const bkstring & text) +WCMatcher::WCMatcher(WCPattern * pattern, const CMString & text) { - pat = pattern; - str = &text; - gc = pattern->groupCount; - ncgc = -pattern->nonCapGroupCount; - flags = 0; - matchedSomething = false; - starts = new int[gc + ncgc]; - ends = new int[gc + ncgc]; - groups = new int[gc + ncgc]; - groupPos = new int[gc + ncgc]; - groupIndeces = new int[gc + ncgc]; - starts = starts + ncgc; - ends = ends + ncgc; - groups = groups + ncgc; - groupPos = groupPos + ncgc; - groupIndeces = groupIndeces + ncgc; - for (int i = 0; i < gc; ++i) starts[i] = ends[i] = 0; + pat = pattern; + str = &text; + gc = pattern->groupCount; + ncgc = -pattern->nonCapGroupCount; + flags = 0; + matchedSomething = false; + starts = new int[gc + ncgc]; + ends = new int[gc + ncgc]; + groups = new int[gc + ncgc]; + groupPos = new int[gc + ncgc]; + groupIndeces = new int[gc + ncgc]; + starts = starts + ncgc; + ends = ends + ncgc; + groups = groups + ncgc; + groupPos = groupPos + ncgc; + groupIndeces = groupIndeces + ncgc; + for (int i = 0; i < gc; ++i) starts[i] = ends[i] = 0; } WCMatcher::~WCMatcher() { - delete [] (starts - ncgc); - delete [] (ends - ncgc); - delete [] (groups - ncgc); - delete [] (groupIndeces - ncgc); - delete [] (groupPos - ncgc); + delete[](starts - ncgc); + delete[](ends - ncgc); + delete[](groups - ncgc); + delete[](groupIndeces - ncgc); + delete[](groupPos - ncgc); } void WCMatcher::clearGroups() { - int i; - lm = 0; - for (i = 0; i < gc; ++i) groups[i] = starts[i] = ends[i] = -1; - for (i = 1; i <= ncgc; ++i) groups[0 - i] = starts[0 - i] = ends[0 - i] = -1; + int i; + lm = 0; + for (i = 0; i < gc; ++i) groups[i] = starts[i] = ends[i] = -1; + for (i = 1; i <= ncgc; ++i) groups[0 - i] = starts[0 - i] = ends[0 - i] = -1; } -bkstring WCMatcher::replaceWithGroups(const bkstring & str) +CMString WCMatcher::replaceWithGroups(const CMString & str) { - bkstring ret = L""; - - bkstring t = str; - while (t.size() > 0) - { - if (t[0] == (wchar_t)'\\') - { - t.erase(0, 1); - if (t.size() == 0) - { - ret += L"\\"; - } - else if (t[0] < (wchar_t)'0' || t[0] > (wchar_t)'9') - { - ret += t[0]; - t.erase(0, 1); - } - else - { - int gn = 0; - while (t.size() > 0 && t[0] >= (wchar_t)'0' && t[0] <= (wchar_t)'9') - { - gn = gn * 10 + (t[0] - (wchar_t)'0'); - t.erase(0, 1); - } - ret += getGroup(gn); - } - } - else - { - ret += t[0]; - t.erase(0, 1); - } - } - - return ret; + CMString ret = L""; + + CMString t = str; + while (t.GetLength() > 0) + { + if (t[0] == '\\') + { + t.Delete(0); + if (t.GetLength() == 0) + ret += L"\\"; + else if (t[0] < '0' || t[0] > '9') { + ret += t[0]; + t.Delete(0); + } + else { + int gn = 0; + while (t.GetLength() > 0 && t[0] >= '0' && t[0] <= '9') + { + gn = gn * 10 + (t[0] - '0'); + t.Delete(0); + } + ret += getGroup(gn); + } + } + else { + ret += t[0]; + t.Delete(0); + } + } + + return ret; } unsigned long WCMatcher::getFlags() const { - return flags; + return flags; } -const bkstring& WCMatcher::getText() const +const CMString& WCMatcher::getText() const { - return *str; + return *str; } bool WCMatcher::matches() { - flags = MATCH_ENTIRE_STRING; - matchedSomething = false; - clearGroups(); - lm = 0; - return pat->head->match(*str, this, 0) == (int)str->size(); + flags = MATCH_ENTIRE_STRING; + matchedSomething = false; + clearGroups(); + lm = 0; + return pat->head->match(*str, this, 0) == (int)str->GetLength(); } + bool WCMatcher::findFirstMatch() { - starts[0] = 0; - flags = 0; - clearGroups(); - start = 0; - lm = 0; - ends[0] = pat->head->match(*str, this, 0); - if (ends[0] >= 0) - { - matchedSomething = true; - return 1; - } - return 0; + starts[0] = 0; + flags = 0; + clearGroups(); + start = 0; + lm = 0; + ends[0] = pat->head->match(*str, this, 0); + if (ends[0] >= 0) + { + matchedSomething = true; + return 1; + } + return 0; } + bool WCMatcher::findNextMatch() { - int s = starts[0], e = ends[0]; - - if (!matchedSomething) return findFirstMatch(); - if (s == e) ++e; - flags = 0; - clearGroups(); - - starts[0] = e; - if (e >= (int)str->size()) return 0; - start = e; - lm = e; - ends[0] = pat->head->match(*str, this, e); - return ends[0] >= 0; + int s = starts[0], e = ends[0]; + + if (!matchedSomething) return findFirstMatch(); + if (s == e) ++e; + flags = 0; + clearGroups(); + + starts[0] = e; + if (e >= (int)str->GetLength()) return 0; + start = e; + lm = e; + ends[0] = pat->head->match(*str, this, e); + return ends[0] >= 0; } -std::vector WCMatcher::findAll() + +std::vector WCMatcher::findAll() { - std::vector ret; - reset(); - while (findNextMatch()) - { - ret.push_back(getGroup()); - } - return ret; + std::vector ret; + reset(); + while (findNextMatch()) + { + ret.push_back(getGroup()); + } + return ret; } void WCMatcher::reset() { - lm = 0; - clearGroups(); - matchedSomething = false; + lm = 0; + clearGroups(); + matchedSomething = false; } int WCMatcher::getStartingIndex(const int groupNum) const { - if (groupNum < 0 || groupNum >= gc) return -1; - return starts[groupNum]; + if (groupNum < 0 || groupNum >= gc) return -1; + return starts[groupNum]; } + int WCMatcher::getEndingIndex(const int groupNum) const { - if (groupNum < 0 || groupNum >= gc) return -1; - return ends[groupNum]; + if (groupNum < 0 || groupNum >= gc) return -1; + return ends[groupNum]; } -bkstring WCMatcher::getGroup(const int groupNum) const + +CMString WCMatcher::getGroup(const int groupNum) const { - if (groupNum < 0 || groupNum >= gc) return L""; - if (starts[groupNum] < 0 || ends[groupNum] < 0) return L""; - return str->substr(starts[groupNum], ends[groupNum] - starts[groupNum]); + if (groupNum < 0 || groupNum >= gc) return L""; + if (starts[groupNum] < 0 || ends[groupNum] < 0) return L""; + return str->Mid(starts[groupNum], ends[groupNum] - starts[groupNum]); } -std::vector WCMatcher::getGroups(const bool includeGroupZero) const + +std::vector WCMatcher::getGroups(const bool includeGroupZero) const { - int i, start = (includeGroupZero ? 0 : 1); - std::vector ret; - - for (i = start; i < gc; ++i) - { - ret.push_back(getGroup(i)); - } - return ret; -} + int i, start = (includeGroupZero ? 0 : 1); + std::vector ret; + + for (i = start; i < gc; ++i) + ret.push_back(getGroup(i)); + return ret; +} diff --git a/plugins/SmileyAdd/src/regexp/WCMatcher.h b/plugins/SmileyAdd/src/regexp/WCMatcher.h index 45610690ba..3c5df018d7 100644 --- a/plugins/SmileyAdd/src/regexp/WCMatcher.h +++ b/plugins/SmileyAdd/src/regexp/WCMatcher.h @@ -23,7 +23,7 @@ invocation looks like: 
   wchar_t buf[10000];
-  bkstring str = "\\5 (user name \\1) uses \\7 for his/her shell and \\6 is their home directory";
+  CMString str = "\\5 (user name \\1) uses \\7 for his/her shell and \\6 is their home directory";
   FILE * fp = fopen("/etc/passwd", "r");
   WCPattern::registerWCPattern("entry", "[^:]+");
   WCPattern * p = WCPattern::compile("^({entry}):({entry}):({entry}):({entry}):({entry}):({entry}):({entry})$",
@@ -92,12 +92,12 @@ class WCMatcher
       @param pattern  The pattern with which to search
       @param text     The text in which to search
      */
-    WCMatcher(WCPattern * pattern, const bkstring & text);
+    WCMatcher(WCPattern * pattern, const CMString & text);
   protected:
     /// The pattern we use to match
     WCPattern * pat;
     /// The string in which we are matching
-    const bkstring * str;
+    const CMString * str;
     /// The starting point of our match
     int start;
     /// An array of the starting positions for each group
@@ -135,7 +135,7 @@ class WCMatcher
       @param str The string in which to replace text
       @return A string with all backreferences appropriately replaced
      */
-    bkstring replaceWithGroups(const bkstring & str);
+    CMString replaceWithGroups(const CMString & str);
     /**
       The flags currently being used by the matcher.
       @return Zero
@@ -145,7 +145,7 @@ class WCMatcher
       The text being searched by the matcher.
       @return the text being searched by the matcher.
      */
-    const bkstring& getText() const;
+    const CMString& getText() const;
 
     /**
       Scans the string from start to finish for a match. The entire string must
@@ -179,7 +179,7 @@ class WCMatcher
 
       @return Every substring in order which matches the given pattern
      */
-    std::vector findAll();
+    std::vector findAll();
     /**
       Resets the internal state of the matcher
      */
@@ -188,12 +188,12 @@ class WCMatcher
       Same as getText. Left n for backwards compatibilty with old source code
       @return Returns the string that is currently being used for matching
      */
-    inline const bkstring&  getString()                           const { return *str; }
+    inline const CMString&  getString()                           const { return *str; }
     /**
       Sets the string to scan
       @param newStr The string to scan for subsequent matches
      */
-    inline void         setString(const bkstring & newStr)       { str = &newStr; reset(); }
+    inline void         setString(const CMString & newStr)       { str = &newStr; reset(); }
 
     /**
       Returns the starting index of the specified group.
@@ -217,14 +217,14 @@ class WCMatcher
       @param groupNum The group to query
       @return The text of the group
      */
-    bkstring getGroup(const int groupNum = 0) const;
+    CMString getGroup(const int groupNum = 0) const;
     /**
       Returns every capture group in a vector
 
       @param includeGroupZero Whether or not include capture group zero
       @return Every capture group
      */
-    std::vector getGroups(const bool includeGroupZero = 0) const;
+    std::vector getGroups(const bool includeGroupZero = 0) const;
 };
 
 #endif
diff --git a/plugins/SmileyAdd/src/regexp/WCPattern.cpp b/plugins/SmileyAdd/src/regexp/WCPattern.cpp
index e44c835b39..c6d3d500f9 100644
--- a/plugins/SmileyAdd/src/regexp/WCPattern.cpp
+++ b/plugins/SmileyAdd/src/regexp/WCPattern.cpp
@@ -13,7 +13,7 @@
   I tend to delete email if I don't recognize the name and the subject is
   something like "I Need Your Help" or "Got A Second" or "I Found It".
   "
- */
+  */
 
 /*
   Detailed documentation is provided in this class' header file
@@ -21,1173 +21,1110 @@
   @author   Jeffery Stuart
   @since    November 2004
   @version  1.07.00
-*/
+  */
 
 #include "..\general.h"
 
-std::map WCPattern::compiledWCPatterns;
-std::map > WCPattern::registeredWCPatterns;
+std::map WCPattern::compiledWCPatterns;
+std::map > WCPattern::registeredWCPatterns;
 
 const int WCPattern::MIN_QMATCH = 0x00000000;
 const int WCPattern::MAX_QMATCH = 0x7FFFFFFF;
 
-const unsigned long WCPattern::CASE_INSENSITIVE       = 0x01;
-const unsigned long WCPattern::LITERAL                = 0x02;
-const unsigned long WCPattern::DOT_MATCHES_ALL        = 0x04;
-const unsigned long WCPattern::MULTILINE_MATCHING     = 0x08;
-const unsigned long WCPattern::UNIX_LINE_MODE         = 0x10;
+const unsigned long WCPattern::CASE_INSENSITIVE = 0x01;
+const unsigned long WCPattern::LITERAL = 0x02;
+const unsigned long WCPattern::DOT_MATCHES_ALL = 0x04;
+const unsigned long WCPattern::MULTILINE_MATCHING = 0x08;
+const unsigned long WCPattern::UNIX_LINE_MODE = 0x10;
 
 #define to_lower(a) (wchar_t)(UINT_PTR)CharLowerW((LPWSTR)(unsigned)a)
 #define is_alpha IsCharAlphaW
 
 #if defined(_WIN32)
-  #define str_icmp lstrcmpiW
+#define str_icmp lstrcmpiW
 #elif defined(__CYGWIN__) || defined(__APPLE__)
-  #include 
-  static inline int str_icmp(const wchar_t * a, const wchar_t * b)
-  {
-    while (*a && *b)
-    {
-      const int t = (int)towlower(*a) - (int)tolower(*b);
-      if (t) return t;
-      ++a; ++b;
-    }
-    if (*a)
-    {
-      if (*b) return (int)towlower(*a) - (int)tolower(*b);
-      return 1;
-    }
-    else if (*b) return 1;
-    return 0;
-  }
+#include 
+static inline int str_icmp(const wchar_t * a, const wchar_t * b)
+{
+	while (*a && *b)
+	{
+		const int t = (int)towlower(*a) - (int)tolower(*b);
+		if (t) return t;
+		++a; ++b;
+	}
+	if (*a)
+	{
+		if (*b) return (int)towlower(*a) - (int)tolower(*b);
+		return 1;
+	}
+	else if (*b) return 1;
+	return 0;
+}
 #else
-  #define str_icmp wcscasecmp
+#define str_icmp wcscasecmp
 #endif
 
-WCPattern::WCPattern(const bkstring & rhs)
+WCPattern::WCPattern(const CMString & rhs)
 {
-  matcher = NULL;
-  pattern = rhs;
-  curInd = 0;
-  groupCount = 0;
-  nonCapGroupCount = 0;
-  error = 0;
-  head = NULL;
+	matcher = NULL;
+	pattern = rhs;
+	curInd = 0;
+	groupCount = 0;
+	nonCapGroupCount = 0;
+	error = 0;
+	head = NULL;
 }
 // convenience function in case we want to add any extra debugging output
 void WCPattern::raiseError()
 {
-/*  switch (pattern[curInd - 1])
-  {
-  case '*':
-  case ')':
-  case '+':
-  case '?':
-  case ']':
-  case '}':
-    fwprintf(stderr, L"%s\n%*c^\n", pattern.c_str(), curInd - 1, ' ');
-    fwprintf(stderr, L"Syntax Error near here. Possible unescaped meta character.\n");
-    break;
-  default:
-    fwprintf(stderr, L"%s\n%*c^\n", pattern.c_str(), curInd - 1, ' ');
-    fwprintf(stderr, L"Syntax Error near here. \n");
-    break;
-  }*/
-  error = 1;
+	/*  switch (pattern[curInd - 1])
+	  {
+	  case '*':
+	  case ')':
+	  case '+':
+	  case '?':
+	  case ']':
+	  case '}':
+	  fwprintf(stderr, L"%s\n%*c^\n", pattern.c_str(), curInd - 1, ' ');
+	  fwprintf(stderr, L"Syntax Error near here. Possible unescaped meta character.\n");
+	  break;
+	  default:
+	  fwprintf(stderr, L"%s\n%*c^\n", pattern.c_str(), curInd - 1, ' ');
+	  fwprintf(stderr, L"Syntax Error near here. \n");
+	  break;
+	  }*/
+	error = 1;
 }
 NFAUNode * WCPattern::registerNode(NFAUNode * node)
 {
-  nodes[node] = 1;
-  return node;
+	nodes[node] = 1;
+	return node;
 }
 
-bkstring WCPattern::classUnion      (bkstring s1, bkstring s2)  const
+CMString WCPattern::classUnion(CMString s1, CMString s2) const
 {
-  wchar_t * out = new wchar_t[66000];
-  std::sort(s1.begin(), s1.end());
-  std::sort(s2.begin(), s2.end());
-  wchar_t* p = std::set_union(s1.begin(), s1.end(), s2.begin(), s2.end(), out); *p = 0;
-  bkstring ret = out;
-  delete [] out;
-  return ret;
+	wchar_t * out = new wchar_t[66000];
+	std::sort((LPTSTR)s1.GetString(), (LPTSTR)s1.GetTail());
+	std::sort((LPTSTR)s2.GetString(), (LPTSTR)s2.GetTail());
+	wchar_t* p = std::set_union(s1.GetString(), s1.GetTail(), s2.GetString(), s2.GetTail(), out); *p = 0;
+	CMString ret = out;
+	delete[] out;
+	return ret;
 }
-bkstring WCPattern::classIntersect  (bkstring s1, bkstring s2)  const
+
+CMString WCPattern::classIntersect(CMString s1, CMString s2) const
 {
-  wchar_t * out = new wchar_t[66000];
-  std::sort(s1.begin(), s1.end());
-  std::sort(s2.begin(), s2.end());
-  *std::set_intersection(s1.begin(), s1.end(), s2.begin(), s2.end(), out) = 0;
-  bkstring ret = out;
-  delete [] out;
-  return ret;
+	wchar_t * out = new wchar_t[66000];
+	std::sort((LPTSTR)s1.GetString(), (LPTSTR)s1.GetTail());
+	std::sort((LPTSTR)s2.GetString(), (LPTSTR)s2.GetTail());
+	*std::set_intersection(s1.GetString(), s1.GetTail(), s2.GetString(), s2.GetTail(), out) = 0;
+	CMString ret = out;
+	delete[] out;
+	return ret;
 }
-bkstring WCPattern::classNegate     (bkstring s1)                  const
+
+CMString WCPattern::classNegate(CMString s1) const
 {
-  wchar_t * out = new wchar_t[66000];
-  int i, ind = 0;
-  std::map m;
+	wchar_t * out = new wchar_t[66000];
+	int i, ind = 0;
+	std::map m;
 
-  for (i = 0; i < (int)s1.size(); ++i) m[s1[i]] = 1;
-  for (i = 0xFF; i >= 0; --i) if (m.find((wchar_t)i) == m.end()) out[ind++] = (wchar_t)i;
-  out[ind] = 0;
-  bkstring ret(out, ind);
-  delete [] out;
-  return ret;
+	for (i = 0; i < s1.GetLength(); ++i) m[s1[i]] = 1;
+	for (i = 0xFF; i >= 0; --i) if (m.find((wchar_t)i) == m.end()) out[ind++] = (wchar_t)i;
+	out[ind] = 0;
+	CMString ret(out, ind);
+	delete[] out;
+	return ret;
 }
-bkstring WCPattern::classCreateRange(wchar_t low, wchar_t hi)    const
+
+CMString WCPattern::classCreateRange(wchar_t low, wchar_t hi)    const
 {
-  wchar_t out[300];
-  int ind = 0;
-  while (low != hi) out[ind++] = low++;
-  out[ind++] = low;
-  return bkstring(out, ind);
+	wchar_t out[300];
+	int ind = 0;
+	while (low != hi) out[ind++] = low++;
+	out[ind++] = low;
+	return CMString(out, ind);
 }
 
 int WCPattern::getInt(int start, int end)
 {
-  int ret = 0;
-  for (; start <= end; ++start) ret = ret * 10 + (pattern[start] - (wchar_t)'0');
-  return ret;
+	int ret = 0;
+	for (; start <= end; ++start) ret = ret * 10 + (pattern[start] - '0');
+	return ret;
 }
+
 bool WCPattern::quantifyCurly(int & sNum, int & eNum)
 {
-  bool good = 1;
-  int i, ci = curInd + 1;
-  int commaInd = ci, endInd = ci, len = (int)pattern.size();
-  sNum = eNum = 0;
-
-  while (endInd   < len     && pattern[endInd  ] != (wchar_t)'}') ++endInd;
-  while (commaInd < endInd  && pattern[commaInd] != (wchar_t)',') ++commaInd;
-  if (endInd >= len) { raiseError(); return 0; }
-  for (i = ci; good && i < endInd; ++i) if (i != commaInd && !isdigit(pattern[i])) good = 0;
-  if (!good && commaInd < endInd) { raiseError(); return 0; }
-  if (!good) return 0;
-  /* so now everything in here is either a comma (and there is at most one comma) or a digit */
-  if (commaInd == ci) // {,*}
-  {
-    if (endInd == commaInd + 1)    { sNum = MIN_QMATCH;               eNum = MAX_QMATCH;                        } // {,} = *
-    else                           { sNum = MIN_QMATCH;               eNum = getInt(commaInd + 1, endInd - 1);  } // {,+}
-  }
-  else if (commaInd == endInd - 1) { sNum = getInt(ci, commaInd - 1); eNum = MAX_QMATCH;                        } // {+,}
-  else if (commaInd == endInd)     { sNum = getInt(ci, endInd - 1);   eNum = sNum;                              } // {+}
-  else                             { sNum = getInt(ci, commaInd - 1); eNum = getInt(commaInd + 1, endInd - 1);  } // {+,+}
-  curInd = endInd + 1;
-  return 1;
+	bool good = 1;
+	int i, ci = curInd + 1;
+	int commaInd = ci, endInd = ci, len = pattern.GetLength();
+	sNum = eNum = 0;
+
+	while (endInd < len     && pattern[endInd] != '}') ++endInd;
+	while (commaInd < endInd  && pattern[commaInd] != ',') ++commaInd;
+	if (endInd >= len) { raiseError(); return 0; }
+	for (i = ci; good && i < endInd; ++i) if (i != commaInd && !isdigit(pattern[i])) good = 0;
+	if (!good && commaInd < endInd) { raiseError(); return 0; }
+	if (!good) return 0;
+	/* so now everything in here is either a comma (and there is at most one comma) or a digit */
+	if (commaInd == ci) // {,*}
+	{
+		if (endInd == commaInd + 1)    { sNum = MIN_QMATCH;               eNum = MAX_QMATCH; } // {,} = *
+		else                           { sNum = MIN_QMATCH;               eNum = getInt(commaInd + 1, endInd - 1); } // {,+}
+	}
+	else if (commaInd == endInd - 1) { sNum = getInt(ci, commaInd - 1); eNum = MAX_QMATCH; } // {+,}
+	else if (commaInd == endInd)     { sNum = getInt(ci, endInd - 1);   eNum = sNum; } // {+}
+	else                             { sNum = getInt(ci, commaInd - 1); eNum = getInt(commaInd + 1, endInd - 1); } // {+,+}
+	curInd = endInd + 1;
+	return 1;
 }
+
 NFAUNode * WCPattern::quantifyGroup(NFAUNode * start, NFAUNode * stop, const int gn)
 {
-  NFAUNode * newNode = NULL;
-  int type = 0;
-
-  if (curInd < (int)pattern.size())
-  {
-    wchar_t ch = (curInd + 1 >= (int)pattern.size()) ? USHRT_MAX : pattern[curInd + 1];
-    switch (pattern[curInd])
-    {
-    case (wchar_t)'*':
-      ++curInd;
-      switch (ch)
-      {
-      case (wchar_t)'?': ++curInd; type = 1; break;
-      case (wchar_t)'+': ++curInd; type = 2; break;
-      }
-      newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
-      newNode->next = registerNode(new NFAGroupLoopUNode(start, MIN_QMATCH, MAX_QMATCH, gn, type));
-      stop->next = newNode->next;
-      return newNode;
-    case (wchar_t)'?':
-      ++curInd;
-      switch (ch)
-      {
-      case (wchar_t)'?': ++curInd; type = 1; break;
-      case (wchar_t)'+': ++curInd; type = 2; break;
-      }
-      newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
-      newNode->next = registerNode(new NFAGroupLoopUNode(start, MIN_QMATCH, 1, gn, type));
-      stop->next = newNode->next;
-      return newNode;
-    case (wchar_t)'+':
-      ++curInd;
-      switch (ch)
-      {
-      case (wchar_t)'?': ++curInd; type = 1; break;
-      case (wchar_t)'+': ++curInd; type = 2; break;
-      }
-      newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
-      newNode->next = registerNode(new NFAGroupLoopUNode(start, 1, MAX_QMATCH, gn, type));
-      stop->next = newNode->next;
-      return newNode;
-    case (wchar_t)'{':
-      {
-        int s, e;
-        if (quantifyCurly(s, e))
-        {
-          ch = (curInd < (int)pattern.size()) ? pattern[curInd] : USHRT_MAX;
-          switch (ch)
-          {
-          case (wchar_t)'?': ++curInd; type = 1; break;
-          case (wchar_t)'+': ++curInd; type = 2; break;
-          }
-          newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
-          newNode->next = registerNode(new NFAGroupLoopUNode(start, s, e, gn, type));
-          stop->next = newNode->next;
-          return newNode;
-        }
-      }
-    default:
-      break;
-    }
-  }
-  return NULL;
+	NFAUNode * newNode = NULL;
+	int type = 0;
+
+	if (curInd < pattern.GetLength()) {
+		wchar_t ch = (curInd + 1 >= pattern.GetLength()) ? USHRT_MAX : pattern[curInd + 1];
+		switch (pattern[curInd]) {
+		case '*':
+			++curInd;
+			switch (ch) {
+				case '?': ++curInd; type = 1; break;
+				case '+': ++curInd; type = 2; break;
+			}
+			newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
+			newNode->next = registerNode(new NFAGroupLoopUNode(start, MIN_QMATCH, MAX_QMATCH, gn, type));
+			stop->next = newNode->next;
+			return newNode;
+		case '?':
+			++curInd;
+			switch (ch) {
+				case '?': ++curInd; type = 1; break;
+				case '+': ++curInd; type = 2; break;
+			}
+			newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
+			newNode->next = registerNode(new NFAGroupLoopUNode(start, MIN_QMATCH, 1, gn, type));
+			stop->next = newNode->next;
+			return newNode;
+		case '+':
+			++curInd;
+			switch (ch) {
+				case '?': ++curInd; type = 1; break;
+				case '+': ++curInd; type = 2; break;
+			}
+			newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
+			newNode->next = registerNode(new NFAGroupLoopUNode(start, 1, MAX_QMATCH, gn, type));
+			stop->next = newNode->next;
+			return newNode;
+		case '{':
+			{
+				int s, e;
+				if (quantifyCurly(s, e)) {
+					ch = (curInd < pattern.GetLength()) ? pattern[curInd] : USHRT_MAX;
+					switch (ch) {
+						case '?': ++curInd; type = 1; break;
+						case '+': ++curInd; type = 2; break;
+					}
+					newNode = registerNode(new NFAGroupLoopPrologueUNode(gn));
+					newNode->next = registerNode(new NFAGroupLoopUNode(start, s, e, gn, type));
+					stop->next = newNode->next;
+					return newNode;
+				}
+			}
+		}
+	}
+	return NULL;
 }
 
 NFAUNode * WCPattern::quantify(NFAUNode * newNode)
 {
-  if (curInd < (int)pattern.size())
-  {
-    wchar_t ch = (curInd + 1 >= (int)pattern.size()) ? USHRT_MAX : pattern[curInd + 1];
-    switch (pattern[curInd])
-    {
-    case (wchar_t)'*':
-      ++curInd;
-      switch (ch)
-      {
-      case (wchar_t)'?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode      (this, newNode, MIN_QMATCH, MAX_QMATCH)); break;
-      case (wchar_t)'+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, MIN_QMATCH, MAX_QMATCH)); break;
-      default:            newNode = registerNode(new NFAGreedyQuantifierUNode    (this, newNode, MIN_QMATCH, MAX_QMATCH)); break;
-      }
-      break;
-    case (wchar_t)'?':
-      ++curInd;
-      switch (ch)
-      {
-      case (wchar_t)'?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode      (this, newNode, MIN_QMATCH, 1)); break;
-      case (wchar_t)'+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, MIN_QMATCH, 1)); break;
-      default:            newNode = registerNode(new NFAGreedyQuantifierUNode    (this, newNode, MIN_QMATCH, 1)); break;
-      }
-      break;
-    case (wchar_t)'+':
-      ++curInd;
-      switch (ch)
-      {
-      case (wchar_t)'?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode      (this, newNode, 1, MAX_QMATCH)); break;
-      case (wchar_t)'+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, 1, MAX_QMATCH)); break;
-      default:            newNode = registerNode(new NFAGreedyQuantifierUNode    (this, newNode, 1, MAX_QMATCH)); break;
-      }
-      break;
-    case (wchar_t)'{':
-      {
-        int s, e;
-        if (quantifyCurly(s, e))
-        {
-          ch = (curInd < (int)pattern.size()) ? pattern[curInd] : USHRT_MAX;
-          switch (ch)
-          {
-          case (wchar_t)'?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode      (this, newNode, s, e)); break;
-          case (wchar_t)'+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, s, e)); break;
-          default:            newNode = registerNode(new NFAGreedyQuantifierUNode    (this, newNode, s, e)); break;
-          }
-        }
-      }
-      break;
-    default:
-      break;
-    }
-  }
-  return newNode;
-}
-bkstring WCPattern::parseClass()
-{
-  bkstring t, ret = L"";
-  wchar_t ch, c1, c2;
-  bool inv = 0, neg = 0, quo = 0;
-
-  if (curInd < (int)pattern.size() && pattern[curInd] == (wchar_t)'^')
-  {
-    ++curInd;
-    neg = 1;
-  }
-  while (curInd < (int)pattern.size() && pattern[curInd] != (wchar_t)']')
-  {
-    ch = pattern[curInd++];
-    if (ch == (wchar_t)'[')
-    {
-      t = parseClass();
-      ret = classUnion(ret, t);
-    }
-    /*else if (ch == (wchar_t)'-')
-    {
-      raiseError();
-      curInd = pattern.size();
-    }*/
-    else if (ch == (wchar_t)'&' && curInd < (int)pattern.size() && pattern[curInd] == (wchar_t)'&')
-    {
-      if (pattern[++curInd] != (wchar_t)'[')
-      {
-        raiseError();
-        curInd = (int)pattern.size();
-      }
-      else
-      {
-        ++curInd;
-        t = parseClass();
-        ret = classIntersect(ret, t);
-      }
-    }
-    else if (ch == (wchar_t)'\\')
-    {
-      t = parseEscape(inv, quo);
-      if (quo)
-      {
-        raiseError();
-        curInd = (int)pattern.size();
-      }
-      else if (inv || t.size() > 1) // cant be part of a range (a-z)
-      {
-        if (inv) t = classNegate(t);
-        ret = classUnion(ret, t);
-      }
-      else if (curInd < (int)pattern.size() && pattern[curInd] == (wchar_t)'-') // part of a range (a-z)
-      {
-        c1 = t[0];
-        ++curInd;
-        if (curInd >= (int)pattern.size()) raiseError();
-        else
-        {
-          c2 = pattern[curInd++];
-          if (c2 == (wchar_t)'\\')
-          {
-            t = parseEscape(inv, quo);
-            if (quo)
-            {
-              raiseError();
-              curInd = (int)pattern.size();
-            }
-            else if (inv || t.size() > 1) raiseError();
-            else ret = classUnion(ret, classCreateRange(c1, c2));
-          }
-          else if (c2 == (wchar_t)'[' || c2 == (wchar_t)']' || c2 == (wchar_t)'-' || c2 == (wchar_t)'&')
-          {
-            raiseError();
-            curInd = (int)pattern.size();
-          }
-          else ret = classUnion(ret, classCreateRange(c1, c2));
-        }
-      }
-      else
-      {
-        ret = classUnion(ret, t);
-      }
-    }
-    else if (curInd < (int)pattern.size() && pattern[curInd] == (wchar_t)'-')
-    {
-      c1 = ch;
-      ++curInd;
-      if (curInd >= (int)pattern.size()) raiseError();
-      else
-      {
-        c2 = pattern[curInd++];
-        if (c2 == (wchar_t)'\\')
-        {
-          t = parseEscape(inv, quo);
-          if (quo)
-          {
-            raiseError();
-            curInd = (int)pattern.size();
-          }
-          else if (inv || t.size() > 1) raiseError();
-          else ret = classUnion(ret, classCreateRange(c1, c2));
-        }
-        else if (c2 == (wchar_t)'[' || c2 == (wchar_t)']' || c2 == (wchar_t)'-' || c2 == (wchar_t)'&')
-        {
-          raiseError();
-          curInd = (int)pattern.size();
-        }
-        else
-        {
-          ret = classUnion(ret, classCreateRange(c1, c2));
-        }
-      }
-    }
-    else
-    {
-      ret += L" ";
-      ret[ret.size() - 1] = ch;
-    }
-  }
-  if (curInd >= (int)pattern.size() || pattern[curInd] != (wchar_t)']')
-  {
-    raiseError();
-    ret = L"";
-  }
-  else
-  {
-    ++curInd;
-    if (neg) ret = classNegate(ret);
-  }
-  return ret;
-}
-bkstring WCPattern::parsePosix()
-{
-  bkstring s7 = pattern.substr(curInd, 7);
-  if (s7 == L"{Lower}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyz";                                                                       }
-  if (s7 == L"{Upper}") { curInd += 7; return L"ABCDEFGHIJKLMNOPQRSTUVWXYZ";                                                                       }
-  if (s7 == L"{Alpha}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";                                             }
-  if (s7 == L"{Digit}") { curInd += 7; return L"0123456789";                                                                                       }
-  if (s7 == L"{Alnum}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";                                   }
-  if (s7 == L"{Punct}") { curInd += 7; return L"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";                                                               }
-  if (s7 == L"{Graph}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
-  if (s7 == L"{Print}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
-  if (s7 == L"{Blank}") { curInd += 7; return L" \t";                                                                                              }
-  if (s7 == L"{Space}") { curInd += 7; return L" \t\n\x0B\f\r";                                                                                    }
-  if (s7 == L"{Cntrl}")
-  {
-	bkstring::value_type i;
-    bkstring s = L" ";
-
-    for (i = 0; i < 5; ++i) s += s;
-    s += L" ";
-    for (i = 0; i <= 0x1F; ++i) s[i] = i;
-    s[0x20] = 0x7F;
-    curInd += 7;
-    return s;
-  }
-  if (s7 == L"{ASCII}")
-  {
-    bkstring s(0x80, (wchar_t)' ');
-    for (bkstring::value_type i = 0; i <= 0x7f; ++i) s[i] = i;
-    curInd += 7;
-    return s;
-  }
-  if (pattern.substr(curInd, 8) == L"{XDigit}") { curInd += 8; return L"abcdefABCDEF0123456789"; }
-  raiseError();
-  return L"";
+	if (curInd < pattern.GetLength()) {
+		wchar_t ch = (curInd + 1 >= pattern.GetLength()) ? USHRT_MAX : pattern[curInd + 1];
+		switch (pattern[curInd]) {
+		case '*':
+			++curInd;
+			switch (ch) {
+				case '?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode(this, newNode, MIN_QMATCH, MAX_QMATCH)); break;
+				case '+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, MIN_QMATCH, MAX_QMATCH)); break;
+				default:            newNode = registerNode(new NFAGreedyQuantifierUNode(this, newNode, MIN_QMATCH, MAX_QMATCH)); break;
+			}
+			break;
+		case '?':
+			++curInd;
+			switch (ch) {
+				case '?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode(this, newNode, MIN_QMATCH, 1)); break;
+				case '+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, MIN_QMATCH, 1)); break;
+				default:            newNode = registerNode(new NFAGreedyQuantifierUNode(this, newNode, MIN_QMATCH, 1)); break;
+			}
+			break;
+		case '+':
+			++curInd;
+			switch (ch) {
+				case '?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode(this, newNode, 1, MAX_QMATCH)); break;
+				case '+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, 1, MAX_QMATCH)); break;
+				default:            newNode = registerNode(new NFAGreedyQuantifierUNode(this, newNode, 1, MAX_QMATCH)); break;
+			}
+			break;
+		case '{':
+			int s, e;
+			if (quantifyCurly(s, e)) {
+				ch = (curInd < pattern.GetLength()) ? pattern[curInd] : USHRT_MAX;
+				switch (ch) {
+					case '?': ++curInd; newNode = registerNode(new NFALazyQuantifierUNode(this, newNode, s, e)); break;
+					case '+': ++curInd; newNode = registerNode(new NFAPossessiveQuantifierUNode(this, newNode, s, e)); break;
+					default:            newNode = registerNode(new NFAGreedyQuantifierUNode(this, newNode, s, e)); break;
+				}
+			}
+			break;
+		}
+	}
+	return newNode;
+}
+CMString WCPattern::parseClass()
+{
+	CMString t, ret = L"";
+	wchar_t ch, c1, c2;
+	bool inv = 0, neg = 0, quo = 0;
+
+	if (curInd < pattern.GetLength() && pattern[curInd] == '^')
+	{
+		++curInd;
+		neg = 1;
+	}
+	while (curInd < pattern.GetLength() && pattern[curInd] != ']')
+	{
+		ch = pattern[curInd++];
+		if (ch == '[')
+		{
+			t = parseClass();
+			ret = classUnion(ret, t);
+		}
+		/*else if (ch == '-')
+		{
+		raiseError();
+		curInd = pattern.GetLength();
+		}*/
+		else if (ch == '&' && curInd < pattern.GetLength() && pattern[curInd] == '&') {
+			if (pattern[++curInd] != '[') {
+				raiseError();
+				curInd = pattern.GetLength();
+			}
+			else {
+				++curInd;
+				t = parseClass();
+				ret = classIntersect(ret, t);
+			}
+		}
+		else if (ch == '\\')
+		{
+			t = parseEscape(inv, quo);
+			if (quo) {
+				raiseError();
+				curInd = pattern.GetLength();
+			}
+			else if (inv || t.GetLength() > 1) { // cant be part of a range (a-z)
+				if (inv) t = classNegate(t);
+				ret = classUnion(ret, t);
+			}
+			else if (curInd < pattern.GetLength() && pattern[curInd] == '-') { // part of a range (a-z) 
+				c1 = t[0];
+				++curInd;
+				if (curInd >= pattern.GetLength()) raiseError();
+				else {
+					c2 = pattern[curInd++];
+					if (c2 == '\\')
+					{
+						t = parseEscape(inv, quo);
+						if (quo)
+						{
+							raiseError();
+							curInd = pattern.GetLength();
+						}
+						else if (inv || t.GetLength() > 1) raiseError();
+						else ret = classUnion(ret, classCreateRange(c1, c2));
+					}
+					else if (c2 == '[' || c2 == ']' || c2 == '-' || c2 == '&')
+					{
+						raiseError();
+						curInd = pattern.GetLength();
+					}
+					else ret = classUnion(ret, classCreateRange(c1, c2));
+				}
+			}
+			else
+			{
+				ret = classUnion(ret, t);
+			}
+		}
+		else if (curInd < pattern.GetLength() && pattern[curInd] == '-')
+		{
+			c1 = ch;
+			++curInd;
+			if (curInd >= pattern.GetLength()) raiseError();
+			else
+			{
+				c2 = pattern[curInd++];
+				if (c2 == '\\')
+				{
+					t = parseEscape(inv, quo);
+					if (quo)
+					{
+						raiseError();
+						curInd = pattern.GetLength();
+					}
+					else if (inv || t.GetLength() > 1) raiseError();
+					else ret = classUnion(ret, classCreateRange(c1, c2));
+				}
+				else if (c2 == '[' || c2 == ']' || c2 == '-' || c2 == '&')
+				{
+					raiseError();
+					curInd = pattern.GetLength();
+				}
+				else
+				{
+					ret = classUnion(ret, classCreateRange(c1, c2));
+				}
+			}
+		}
+		else ret.AppendChar(ch);
+	}
+	if (curInd >= pattern.GetLength() || pattern[curInd] != ']')
+	{
+		raiseError();
+		ret = L"";
+	}
+	else
+	{
+		++curInd;
+		if (neg) ret = classNegate(ret);
+	}
+	return ret;
+}
+CMString WCPattern::parsePosix()
+{
+	CMString s7 = pattern.Mid(curInd, 7);
+	if (s7 == L"{Lower}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyz"; }
+	if (s7 == L"{Upper}") { curInd += 7; return L"ABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
+	if (s7 == L"{Alpha}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"; }
+	if (s7 == L"{Digit}") { curInd += 7; return L"0123456789"; }
+	if (s7 == L"{Alnum}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; }
+	if (s7 == L"{Punct}") { curInd += 7; return L"!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
+	if (s7 == L"{Graph}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
+	if (s7 == L"{Print}") { curInd += 7; return L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"; }
+	if (s7 == L"{Blank}") { curInd += 7; return L" \t"; }
+	if (s7 == L"{Space}") { curInd += 7; return L" \t\n\x0B\f\r"; }
+	if (s7 == L"{Cntrl}")
+	{
+		TCHAR i;
+		CMString s = L" ";
+
+		for (i = 0; i < 5; ++i) s += s;
+		s += L" ";
+		for (i = 0; i <= 0x1F; ++i)
+			s.SetAt(i, i);
+		s.SetAt(0x20, 0x7F);
+		curInd += 7;
+		return s;
+	}
+	if (s7 == L"{ASCII}")
+	{
+		CMString s(' ', 0x80);
+		for (int i = 0; i <= 0x7f; ++i) s.SetAt(i, i);
+		curInd += 7;
+		return s;
+	}
+	if (pattern.Mid(curInd, 8) == L"{XDigit}") { curInd += 8; return L"abcdefABCDEF0123456789"; }
+	raiseError();
+	return L"";
 }
 NFAUNode * WCPattern::parseBackref()
 {
-  #define is_dig(x) ((x) >= (wchar_t)'0' && (x) <= (wchar_t)'9')
-  #define to_int(x) ((x) - (wchar_t)'0')
-  int ci = curInd;
-  int oldRef = 0, ref = 0;
-
-  while (ci < (int)pattern.size() && is_dig(pattern[ci]) && (ref < 10 || ref < groupCount))
-  {
-    oldRef = ref;
-    ref = ref * 10 + to_int(pattern[ci++]);
-  }
-  if (ci == (int)pattern.size())
-  {
-    oldRef = ref;
-    ++ci;
-  }
-  if (oldRef < 0 || ci <= curInd)
-  {
-    raiseError();
-    return registerNode(new NFAReferenceUNode(-1));
-  }
-  curInd = ci;
-  return registerNode(new NFAReferenceUNode(ref));
-
-  #undef is_dig
-  #undef to_int
-}
-bkstring WCPattern::parseOctal()
-{
-  #define islowoc(x)  ((x) >= (wchar_t)'0' && (x) <= (wchar_t)'3')
-  #define isoc(x)     ((x) >= (wchar_t)'0' && (x) <= (wchar_t)'7')
-  #define fromoc(x)   ((x) - (wchar_t)'0')
-  int ci = curInd;
-  wchar_t ch1 = (ci + 0 < (int)pattern.size()) ? pattern[ci + 0] : USHRT_MAX;
-  wchar_t ch2 = (ci + 1 < (int)pattern.size()) ? pattern[ci + 1] : USHRT_MAX;
-  wchar_t ch3 = (ci + 2 < (int)pattern.size()) ? pattern[ci + 2] : USHRT_MAX;
-  bkstring s = L" ";
-
-  if (islowoc(ch1) && isoc(ch2))
-  {
-    curInd += 2;
-    s[0] = fromoc(ch1) * 8 + fromoc(ch2);
-    if (isoc(ch3))
-    {
-      ++curInd;
-      s[0] = s[0] * 8 + fromoc(ch3);
-    }
-  }
-  else if (isoc(ch1) && isoc(ch2))
-  {
-    curInd += 2;
-    s[0] = fromoc(ch1) * 8 + fromoc(ch2);
-  }
-  else raiseError();
-
-  return s;
-  #undef islowoc
-  #undef isoc
-  #undef fromoc
-}
-bkstring WCPattern::parseHex()
-{
-  #define to_low(x)   (((x) >= (wchar_t)'A' && (x) <= (wchar_t)'Z') ? ((x) - (wchar_t)'A' + (wchar_t)'a') : (x))
-  #define is_dig(x)   ((x) >= (wchar_t)'0' && (x) <= (wchar_t)'9')
-  #define is_hex(x)   (is_dig(x) || (to_low(x) >= (wchar_t)'a' && to_low(x) <= (wchar_t)'f'))
-  #define to_int(x)   ((is_dig(x)) ? ((x) - (wchar_t)'0') : (to_low(x) - (wchar_t)'a' + 10))
-
-  int ci = curInd;
-  wchar_t ch1 = (ci + 0 < (int)pattern.size()) ? pattern[ci + 0] : USHRT_MAX;
-  wchar_t ch2 = (ci + 1 < (int)pattern.size()) ? pattern[ci + 1] : USHRT_MAX;
-  wchar_t ch3 = (ci + 2 < (int)pattern.size()) ? pattern[ci + 2] : USHRT_MAX;
-  wchar_t ch4 = (ci + 3 < (int)pattern.size()) ? pattern[ci + 3] : USHRT_MAX;
-  bkstring s = L" ";
-
-  if (is_hex(ch1) && is_hex(ch2) && is_hex(ch3) && is_hex(ch4))
-  {
-    curInd += 2;
-    s[0] = (to_int(ch1) << 12 & 0xF000) | (to_int(ch2) << 8 & 0x0F00) |
-           (to_int(ch3) <<  4 & 0x0F00) | (to_int(ch4)      & 0x000F);
-  }
-  else if (is_hex(ch1) && is_hex(ch2))
-  {
-    curInd += 2;
-    s[0] = (to_int(ch1) << 4 & 0xF0) | (to_int(ch2) & 0x0F);
-  }
-
-  return s;
-  #undef to_low
-  #undef is_dig
-  #undef is_hex
-  #undef to_int
-}
-bkstring WCPattern::parseEscape(bool & inv, bool & quo)
-{
-  wchar_t ch = pattern[curInd++];
-  bkstring classes = L"";
-
-  if (curInd > (int)pattern.size())
-  {
-    raiseError();
-    return NULL;
-  }
-
-  quo = 0;
-  inv = 0;
-  switch (ch)
-  {
-  case (wchar_t)'p': classes = parsePosix();                                                         break;
-  case (wchar_t)'P': classes = L"!!"; classes += parsePosix();                                        break;
-  case (wchar_t)'d': classes = L"0123456789";                                                         break;
-  case (wchar_t)'D': classes = L"!!0123456789";                                                       break;
-  case (wchar_t)'s': classes = L" \t\r\n\f";                                                          break;
-  case (wchar_t)'S': classes = L"!! \t\r\n\f";                                                        break;
-  case (wchar_t)'w': classes = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";    break;
-  case (wchar_t)'W': classes = L"!!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";  break;
-  case (wchar_t)'0': classes = parseOctal(); break;
-  case (wchar_t)'x': classes = parseHex();   break;
-
-  case (wchar_t)'Q': quo = 1;        break;
-  case (wchar_t)'t': classes = L"\t"; break;
-  case (wchar_t)'r': classes = L"\r"; break;
-  case (wchar_t)'n': classes = L"\n"; break;
-  case (wchar_t)'f': classes = L"\f"; break;
-  case (wchar_t)'a': classes = L"\a"; break;
-  case (wchar_t)'e': classes = L"\r"; break;
-  default:  classes = L" "; classes[0] = ch; break;
-  }
-  if (classes.substr(0, 2) == L"!!")
-  {
-    classes = classes.substr(2);
-    inv = 1;
-  }
-  return classes;
-}
-NFAUNode * WCPattern::parseRegisteredWCPattern(NFAUNode ** end)
-{
-  int i, j;
-  bkstring s;
-  NFAUNode * ret = NULL;
-  for (i = curInd; i < (int)pattern.size() && pattern[i] != (wchar_t)'}'; ++i) { }
-  if (pattern[i] != (wchar_t)'}') { raiseError(); return NULL; }
-  if (i == curInd + 1)   { raiseError(); return NULL; } // {}
-  if (
-      !(
-        (pattern[curInd] >= (wchar_t)'a' && pattern[curInd] <= (wchar_t)'z') ||
-        (pattern[curInd] >= (wchar_t)'A' && pattern[curInd] <= (wchar_t)'Z') ||
-        (pattern[curInd] == (wchar_t)'_')
-       )
-     )
-  {
-    raiseError();
-    return NULL;
-  }
-  for (j = curInd; !error && j < i; ++j)
-  {
-    if (
-        !(
-          (pattern[j] >= (wchar_t)'a' && pattern[j] <= (wchar_t)'z') ||
-          (pattern[j] >= (wchar_t)'A' && pattern[j] <= (wchar_t)'Z') ||
-          (pattern[j] >= (wchar_t)'0' && pattern[j] <= (wchar_t)'9') ||
-          (pattern[j] == (wchar_t)'_')))
-    {
-      raiseError();
-      return NULL;
-    }
-  }
-  s = pattern.substr(curInd, i - curInd);
-  if (registeredWCPatterns.find(s) == registeredWCPatterns.end()) raiseError();
-  else
-  {
-    unsigned long oflags = flags;
-    bkstring op = pattern;
-    int ci = i + 1;
-
-    pattern = registeredWCPatterns[s].first;
-    curInd = 0;
-    flags = registeredWCPatterns[s].second;
-
-    --groupCount;
-    ret = parse(0, 0, end);
-
-    pattern = op;
-    curInd = ci;
-    flags = oflags;
-  }
-  if (error) { *end = ret = NULL; }
-  return ret;
+#define is_dig(x) ((x) >= '0' && (x) <= '9')
+#define to_int(x) ((x) - '0')
+	int ci = curInd;
+	int oldRef = 0, ref = 0;
+
+	while (ci < pattern.GetLength() && is_dig(pattern[ci]) && (ref < 10 || ref < groupCount))
+	{
+		oldRef = ref;
+		ref = ref * 10 + to_int(pattern[ci++]);
+	}
+	if (ci == pattern.GetLength())
+	{
+		oldRef = ref;
+		++ci;
+	}
+	if (oldRef < 0 || ci <= curInd)
+	{
+		raiseError();
+		return registerNode(new NFAReferenceUNode(-1));
+	}
+	curInd = ci;
+	return registerNode(new NFAReferenceUNode(ref));
+
+#undef is_dig
+#undef to_int
+}
+CMString WCPattern::parseOctal()
+{
+#define islowoc(x)  ((x) >= '0' && (x) <= '3')
+#define isoc(x)     ((x) >= '0' && (x) <= '7')
+#define fromoc(x)   ((x) - '0')
+	int ci = curInd;
+	wchar_t ch1 = (ci + 0 < pattern.GetLength()) ? pattern[ci + 0] : USHRT_MAX;
+	wchar_t ch2 = (ci + 1 < pattern.GetLength()) ? pattern[ci + 1] : USHRT_MAX;
+	wchar_t ch3 = (ci + 2 < pattern.GetLength()) ? pattern[ci + 2] : USHRT_MAX;
+	CMString s = L" ";
+
+	if (islowoc(ch1) && isoc(ch2)) {
+		curInd += 2;
+		s.SetAt(0, fromoc(ch1) * 8 + fromoc(ch2));
+		if (isoc(ch3)) {
+			++curInd;
+			s.SetAt(0, s[0] * 8 + fromoc(ch3));
+		}
+	}
+	else if (isoc(ch1) && isoc(ch2)) {
+		curInd += 2;
+		s.SetAt(0, fromoc(ch1) * 8 + fromoc(ch2));
+	}
+	else raiseError();
+
+	return s;
+#undef islowoc
+#undef isoc
+#undef fromoc
+}
+CMString WCPattern::parseHex()
+{
+#define to_low(x)   (((x) >= 'A' && (x) <= 'Z') ? ((x) - 'A' + 'a') : (x))
+#define is_dig(x)   ((x) >= '0' && (x) <= '9')
+#define is_hex(x)   (is_dig(x) || (to_low(x) >= 'a' && to_low(x) <= 'f'))
+#define to_int(x)   ((is_dig(x)) ? ((x) - '0') : (to_low(x) - 'a' + 10))
+
+	int ci = curInd;
+	wchar_t ch1 = (ci + 0 < pattern.GetLength()) ? pattern[ci + 0] : USHRT_MAX;
+	wchar_t ch2 = (ci + 1 < pattern.GetLength()) ? pattern[ci + 1] : USHRT_MAX;
+	wchar_t ch3 = (ci + 2 < pattern.GetLength()) ? pattern[ci + 2] : USHRT_MAX;
+	wchar_t ch4 = (ci + 3 < pattern.GetLength()) ? pattern[ci + 3] : USHRT_MAX;
+	CMString s = L" ";
+
+	if (is_hex(ch1) && is_hex(ch2) && is_hex(ch3) && is_hex(ch4))
+	{
+		curInd += 2;
+		s.SetAt(0, (to_int(ch1) << 12 & 0xF000) | (to_int(ch2) << 8 & 0x0F00) |
+			(to_int(ch3) << 4 & 0x0F00) | (to_int(ch4) & 0x000F));
+	}
+	else if (is_hex(ch1) && is_hex(ch2))
+	{
+		curInd += 2;
+		s.SetAt(0, (to_int(ch1) << 4 & 0xF0) | (to_int(ch2) & 0x0F));
+	}
+
+	return s;
+#undef to_low
+#undef is_dig
+#undef is_hex
+#undef to_int
+}
+CMString WCPattern::parseEscape(bool & inv, bool & quo)
+{
+	wchar_t ch = pattern[curInd++];
+	CMString classes;
+
+	if (curInd > pattern.GetLength()) {
+		raiseError();
+		return "";
+	}
+
+	quo = 0;
+	inv = 0;
+	switch (ch) {
+		case 'p': classes = parsePosix();                                                         break;
+		case 'P': classes = L"!!"; classes += parsePosix();                                        break;
+		case 'd': classes = L"0123456789";                                                         break;
+		case 'D': classes = L"!!0123456789";                                                       break;
+		case 's': classes = L" \t\r\n\f";                                                          break;
+		case 'S': classes = L"!! \t\r\n\f";                                                        break;
+		case 'w': classes = L"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";    break;
+		case 'W': classes = L"!!abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_";  break;
+		case '0': classes = parseOctal(); break;
+		case 'x': classes = parseHex();   break;
+		  
+		case 'Q': quo = 1;        break;
+		case 't': classes = L"\t"; break;
+		case 'r': classes = L"\r"; break;
+		case 'n': classes = L"\n"; break;
+		case 'f': classes = L"\f"; break;
+		case 'a': classes = L"\a"; break;
+		case 'e': classes = L"\r"; break;
+		default:  classes.AppendChar(ch); break;
+	}
+
+	if (classes.Mid(0, 2) == L"!!") {
+		classes = classes.Mid(2);
+		inv = 1;
+	}
+	return classes;
+}
+NFAUNode * WCPattern::parseRegisteredWCPattern(NFAUNode **end)
+{
+	int i, j;
+	CMString s;
+	NFAUNode * ret = NULL;
+	for (i = curInd; i < pattern.GetLength() && pattern[i] != '}'; ++i) {}
+	if (pattern[i] != '}') { raiseError(); return NULL; }
+	if (i == curInd + 1)   { raiseError(); return NULL; } // {}
+	if (
+		!(
+		(pattern[curInd] >= 'a' && pattern[curInd] <= 'z') ||
+		(pattern[curInd] >= 'A' && pattern[curInd] <= 'Z') ||
+		(pattern[curInd] == '_')
+		)
+		)
+	{
+		raiseError();
+		return NULL;
+	}
+	for (j = curInd; !error && j < i; ++j)
+	{
+		if (
+			!(
+			(pattern[j] >= 'a' && pattern[j] <= 'z') ||
+			(pattern[j] >= 'A' && pattern[j] <= 'Z') ||
+			(pattern[j] >= '0' && pattern[j] <= '9') ||
+			(pattern[j] == '_')))
+		{
+			raiseError();
+			return NULL;
+		}
+	}
+	s = pattern.Mid(curInd, i - curInd);
+	if (registeredWCPatterns.find(s) == registeredWCPatterns.end()) raiseError();
+	else
+	{
+		unsigned long oflags = flags;
+		CMString op = pattern;
+		int ci = i + 1;
+
+		pattern = registeredWCPatterns[s].first;
+		curInd = 0;
+		flags = registeredWCPatterns[s].second;
+
+		--groupCount;
+		ret = parse(0, 0, end);
+
+		pattern = op;
+		curInd = ci;
+		flags = oflags;
+	}
+	if (error) { *end = ret = NULL; }
+	return ret;
 }
 
 // look behind should interpret everything as a literal (except \\) since the
 // pattern must have a concrete length
 NFAUNode * WCPattern::parseBehind(const bool pos, NFAUNode ** end)
 {
-  bkstring t = L"";
-  while (curInd < (int)pattern.size() && pattern[curInd] != (wchar_t)')')
-  {
-    wchar_t ch = pattern[curInd++];
-    t += L" ";
-    if (ch == (wchar_t)'\\')
-    {
-      if (curInd + 1 >= (int)pattern.size())
-      {
-        raiseError();
-        return *end = registerNode(new NFACharUNode((wchar_t)' '));
-      }
-      ch = pattern[curInd++];
-    }
-    t[t.size() - 1] = ch;
-  }
-  if (curInd >= (int)pattern.size() || pattern[curInd] != (wchar_t)')') raiseError();
-  else ++curInd;
-  return *end = registerNode(new NFALookBehindUNode(t, pos));
+	CMString t = L"";
+	while (curInd < pattern.GetLength() && pattern[curInd] != ')')
+	{
+		wchar_t ch = pattern[curInd++];
+		if (ch == '\\')
+		{
+			if (curInd + 1 >= pattern.GetLength())
+			{
+				raiseError();
+				return *end = registerNode(new NFACharUNode(' '));
+			}
+			ch = pattern[curInd++];
+		}
+		t.AppendChar(ch);
+	}
+	if (curInd >= pattern.GetLength() || pattern[curInd] != ')') raiseError();
+	else ++curInd;
+	return *end = registerNode(new NFALookBehindUNode(t, pos));
 }
 NFAUNode * WCPattern::parseQuote()
 {
-  bool done = 0;
-  bkstring s = L"";
-
-  while (!done)
-  {
-    if      (curInd >= (int)pattern.size())
-    {
-      raiseError();
-      done = 1;
-    }
-    else if (pattern.substr(curInd, 2) == L"\\E")
-    {
-      curInd += 2;
-      done = 1;
-    }
-    else if (pattern[curInd] == (wchar_t)'\\')
-    {
-      s += L" ";
-      s[s.size() - 1] = pattern[++curInd];
-      ++curInd;
-    }
-    else
-    {
-      s += L" ";
-      s[s.size() - 1] = pattern[curInd++];
-    }
-  }
-  if ((flags & WCPattern::CASE_INSENSITIVE) != 0) return registerNode(new NFACIQuoteUNode(s));
-  return registerNode(new NFAQuoteUNode(s));
+	bool done = 0;
+	CMString s = L"";
+
+	while (!done)
+	{
+		if (curInd >= pattern.GetLength())
+		{
+			raiseError();
+			done = 1;
+		}
+		else if (pattern.Mid(curInd, 2) == L"\\E")
+		{
+			curInd += 2;
+			done = 1;
+		}
+		else if (pattern[curInd] == '\\')
+		{
+			s.AppendChar(pattern[++curInd]);
+			++curInd;
+		}
+		else s.AppendChar(pattern[curInd++]);
+	}
+	if ((flags & WCPattern::CASE_INSENSITIVE) != 0) return registerNode(new NFACIQuoteUNode(s));
+	return registerNode(new NFAQuoteUNode(s));
 }
 NFAUNode * WCPattern::parse(const bool inParen, const bool inOr, NFAUNode ** end)
 {
-  NFAUNode * start, * cur, * next = NULL;
-  bkstring t;
-  int grc = groupCount++;
-  bool inv, quo;
-  bool ahead = 0, pos = 0, noncap = 0, indep = 0;
-  unsigned long oldFlags = flags;
-
-  if (inParen)
-  {
-    if (pattern[curInd] == (wchar_t)'?')
-    {
-      ++curInd;
-      --groupCount;
-      if      (pattern[curInd]           == (wchar_t)':')   { noncap = 1; ++curInd;     grc = --nonCapGroupCount; }
-      else if (pattern[curInd]           == (wchar_t)'=')   { ++curInd;     ahead = 1;  pos = 1;                  }
-      else if (pattern[curInd]           == (wchar_t)'!')   { ++curInd;     ahead = 1;  pos = 0;                  }
-      else if (pattern.substr(curInd, 2) == L"<=")  { curInd += 2;  return parseBehind(1, end);                   }
-      else if (pattern.substr(curInd, 2) == L"')   { ++curInd;     indep = 1;                            }
-      else
-      {
-        bool negate = false, done = false;
-        while (!done)
-        {
-          if (curInd >= (int)pattern.size())
-          {
-            raiseError();
-            return NULL;
-          }
-          else if (negate)
-          {
-            switch (pattern[curInd])
-            {
-            case (wchar_t)'i': flags &= ~WCPattern::CASE_INSENSITIVE;   break;
-            case (wchar_t)'d': flags &= ~WCPattern::UNIX_LINE_MODE;     break;
-            case (wchar_t)'m': flags &= ~WCPattern::MULTILINE_MATCHING; break;
-            case (wchar_t)'s': flags &= ~WCPattern::DOT_MATCHES_ALL;    break;
-            case (wchar_t)':': done = true;                             break;
-            case (wchar_t)')':
-              ++curInd;
-              *end = registerNode(new NFALookBehindUNode(L"", true));
-              return *end;
-            case (wchar_t)'-':
-            default: raiseError(); return NULL;
-            }
-          }
-          else
-          {
-            switch (pattern[curInd])
-            {
-            case (wchar_t)'i': flags |= WCPattern::CASE_INSENSITIVE;    break;
-            case (wchar_t)'d': flags |= WCPattern::UNIX_LINE_MODE;      break;
-            case (wchar_t)'m': flags |= WCPattern::MULTILINE_MATCHING;  break;
-            case (wchar_t)'s': flags |= WCPattern::DOT_MATCHES_ALL;     break;
-            case (wchar_t)':': done = true;                             break;
-            case (wchar_t)'-': negate = true;                           break;
-            case (wchar_t)')':
-              ++curInd;
-              *end = registerNode(new NFALookBehindUNode(L"", true));
-              return *end;
-            default:  raiseError(); return NULL;
-            }
-          }
-          ++curInd;
-        }
-        noncap = 1;
-        grc = --nonCapGroupCount;
-      }
-
-      if (noncap) cur = start = registerNode(new NFAGroupHeadUNode(grc));
-      else        cur = start = registerNode(new NFASubStartUNode);
-    }
-    else cur = start = registerNode(new NFAGroupHeadUNode(grc));
-  }
-  else cur = start = registerNode(new NFASubStartUNode);
-  while (curInd < (int)pattern.size())
-  {
-    wchar_t ch = pattern[curInd++];
-
-    next = NULL;
-    if (error) return NULL;
-    switch (ch)
-    {
-    case (wchar_t)'^':
-      if ((flags & WCPattern::MULTILINE_MATCHING) != 0) next = registerNode(new NFAStartOfLineUNode);
-      else                                            next = registerNode(new NFAStartOfInputUNode);
-      break;
-    case (wchar_t)'$':
-      if ((flags & WCPattern::MULTILINE_MATCHING) != 0) next = registerNode(new NFAEndOfLineUNode);
-      else                                            next = registerNode(new NFAEndOfInputUNode(0));
-      break;
-    case (wchar_t)'|':
-      --groupCount;
-      cur->next = registerNode(new NFAAcceptUNode);
-      cur = start = registerNode(new NFAOrUNode(start, parse(inParen, 1)));
-      break;
-    case (wchar_t)'\\':
-      if      (curInd < (int)pattern.size())
-      {
-        bool eoi = 0;
-        switch (pattern[curInd])
-        {
-        case (wchar_t)'1':
-        case (wchar_t)'2':
-        case (wchar_t)'3':
-        case (wchar_t)'4':
-        case (wchar_t)'5':
-        case (wchar_t)'6':
-        case (wchar_t)'7':
-        case (wchar_t)'8':
-        case (wchar_t)'9': next = parseBackref(); break;
-        case (wchar_t)'A': ++curInd; next = registerNode(new NFAStartOfInputUNode);     break;
-        case (wchar_t)'B': ++curInd; next = registerNode(new NFAWordBoundaryUNode(0));  break;
-        case (wchar_t)'b': ++curInd; next = registerNode(new NFAWordBoundaryUNode(1));  break;
-        case (wchar_t)'G': ++curInd; next = registerNode(new NFAEndOfMatchUNode);       break;
-        case (wchar_t)'Z': eoi = 1;
-        case (wchar_t)'z': ++curInd; next = registerNode(new NFAEndOfInputUNode(eoi));  break;
-        default:
-          t = parseEscape(inv, quo);
-          //printf("inv quo classes { %c %c %s }\n", inv ? (wchar_t)'t' : (wchar_t)'f', quo ? (wchar_t)'t' : (wchar_t)'f', t.c_str());
-          if (!quo)
-          {
-            if (t.size() > 1 || inv)
-            {
-              if ((flags & WCPattern::CASE_INSENSITIVE) != 0) next = registerNode(new NFACIClassUNode(t, inv));
-              else                                            next = registerNode(new NFAClassUNode(t, inv));
-            }
-            else
-            {
-              next = registerNode(new NFACharUNode(t[0]));
-            }
-          }
-          else
-          {
-            next = parseQuote();
-          }
-        }
-      }
-      else raiseError();
-      break;
-    case (wchar_t)'[':
-      if ((flags & WCPattern::CASE_INSENSITIVE) == 0)
-      {
-        NFAClassUNode * clazz = new NFAClassUNode();
-        bkstring s = parseClass();
-        for (int i = 0; i < (int)s.size(); ++i) clazz->vals[s[i]] = 1;
-        next = registerNode(clazz);
-      }
-      else
-      {
-        NFACIClassUNode * clazz = new NFACIClassUNode();
-        bkstring s = parseClass();
-        for (int i = 0; i < (int)s.size(); ++i) clazz->vals[to_lower(s[i])] = 1;
-        next = registerNode(clazz);
-      }
-      break;
-    case (wchar_t)'.':
-      {
-        bool useN = 1, useR = 1;
-        NFAClassUNode * clazz = new NFAClassUNode(1);
-        if ((flags & WCPattern::UNIX_LINE_MODE)  != 0) useR = 0;
-        if ((flags & WCPattern::DOT_MATCHES_ALL) != 0) useN = useR = 0;
-        if (useN) clazz->vals[(wchar_t)'\n'] = 1;
-        if (useR) clazz->vals[(wchar_t)'\r'] = 1;
-        next = registerNode(clazz);
-      }
-      break;
-    case (wchar_t)'(':
-      {
-        NFAUNode * end, * t1, * t2;
-        t1 = parse(1, 0, &end);
-        if (!t1) raiseError();
-        else if (t1->isGroupHeadNode() && (t2 = quantifyGroup(t1, end, grc)) != NULL)
-        {
-          cur->next = t2;
-          cur = t2->next;
-        }
-        else
-        {
-          cur->next = t1;
-          cur = end;
-        }
-      }
-      break;
-    case (wchar_t)')':
-      if (!inParen) raiseError();
-      else if (inOr)
-      {
-        --curInd;
-        cur = cur->next = registerNode(new NFAAcceptUNode);
-        flags = oldFlags;
-        return start;
-      }
-      else
-      {
-        if (ahead)
-        {
-          cur = cur->next = registerNode(new NFAAcceptUNode);
-          flags = oldFlags;
-          return *end = registerNode(new NFALookAheadUNode(start, pos));
-        }
-        else if (indep)
-        {
-          cur = cur->next = registerNode(new NFAAcceptUNode);
-          flags = oldFlags;
-          return *end = registerNode(new NFAPossessiveQuantifierUNode(this, start, 1, 1));
-        }
-        else // capping or noncapping, it doesnt matter
-        {
-          *end = cur = cur->next = registerNode(new NFAGroupTailUNode(grc));
-          next = quantifyGroup(start, *end, grc);
-          if (next)
-          {
-            start = next;
-            *end = next->next;
-          }
-          flags = oldFlags;
-          return start;
-        }
-      }
-      break;
-    case (wchar_t)'{': // registered pattern
-      cur->next = parseRegisteredWCPattern(&next);
-      if (cur->next) cur = next;
-      break;
-    case (wchar_t)'*':
-    case (wchar_t)'+':
-    case (wchar_t)'?':
-//    case (wchar_t)'}':
-//    case (wchar_t)']':
-      raiseError();
-      break;
-    default:
-      if ((flags & WCPattern::CASE_INSENSITIVE) != 0) next = registerNode(new NFACICharUNode(ch));
-      else                                          next = registerNode(new NFACharUNode(ch));
-      break;
-    }
-    if (next) cur = cur->next = quantify(next);
-  }
-  if (inParen) raiseError();
-  else
-  {
-    if (inOr) cur = cur->next = registerNode(new NFAAcceptUNode);
-    if (end) *end = cur;
-  }
-
-  flags = oldFlags;
-  if (error) return NULL;
-
-  return start;
-}
-
-WCPattern * WCPattern::compile(const bkstring & pattern, const unsigned long mode)
-{
-  WCPattern * p = new WCPattern(pattern);
-  NFAUNode * end;
-
-  p->flags = mode;
-  if ((mode & WCPattern::LITERAL) != 0)
-  {
-    p->head = p->registerNode(new NFAStartUNode);
-    if ((mode & WCPattern::CASE_INSENSITIVE) != 0)  p->head->next = p->registerNode(new NFACIQuoteUNode(pattern));
-    else                                          p->head->next = p->registerNode(new NFAQuoteUNode(pattern));
-    p->head->next->next = p->registerNode(new NFAEndUNode);
-  }
-  else
-  {
-    p->head = p->parse(0, 0, &end);
-    if (!p->head)
-    {
-      delete p;
-      p = NULL;
-    }
-    else
-    {
-      if (!(p->head && p->head->isStartOfInputNode()))
-      {
-        NFAUNode * n = p->registerNode(new NFAStartUNode);
-        n->next = p->head;
-        p->head = n;
-      }
-      end->next = p->registerNode(new NFAEndUNode);
-    }
-  }
-  if (p != NULL)
-  {
-    p->matcher = new WCMatcher(p, L"");
-  }
-
-  return p;
-}
-
-WCPattern * WCPattern::compileAndKeep(const bkstring & pattern, const unsigned long mode)
-{
-  WCPattern * ret = NULL;
-  std::map::iterator it = compiledWCPatterns.find(pattern);
-
-  if (it != compiledWCPatterns.end())
-  {
-    ret = it->second;
-  }
-  else
-  {
-    ret = compile(pattern, mode);
-    compiledWCPatterns[pattern] = ret;
-  }
-
-  return ret;
-}
-bkstring WCPattern::replace(const bkstring & pattern, const bkstring & str,
-                                     const bkstring & replacementText, const unsigned long mode)
-{
-  bkstring ret;
-  WCPattern * p = WCPattern::compile(pattern, mode);
-  if (p)
-  {
-    ret = p->replace(str, replacementText);
-    delete p;
-  }
-  return ret;
-}
-
-std::vector WCPattern::split(const bkstring & pattern, const bkstring & str, const bool keepEmptys,
-                              const unsigned long limit, const unsigned long mode)
-{
-  std::vector ret;
-  WCPattern * p = WCPattern::compile(pattern, mode);
-  if (p)
-  {
-    ret = p->split(str, keepEmptys, limit);
-    delete p;
-  }
-  return ret;
-}
-
-std::vector WCPattern::findAll(const bkstring & pattern, const bkstring & str, const unsigned long mode)
-{
-  std::vector ret;
-  WCPattern * p = WCPattern::compile(pattern, mode);
-  if (p)
-  {
-    ret = p->findAll(str);
-    delete p;
-  }
-  return ret;
-}
-
-bool WCPattern::matches(const bkstring & pattern, const bkstring & str, const unsigned long mode)
-{
-  bool ret = 0;
-  WCPattern * p = compile(pattern, mode);
-
-  if (p)
-  {
-    ret = p->matches(str);
-    delete p;
-  }
-
-  return ret;
-}
-
-bool WCPattern::registerWCPattern(const bkstring & name, const bkstring & pattern, const unsigned long mode)
-{
-  WCPattern * p = WCPattern::compile(pattern, mode);
-  if (!p) return 0;
-  WCPattern::registeredWCPatterns[name] = std::make_pair(pattern, mode);
-  delete p;
-  return 1;
+	NFAUNode * start, *cur, *next = NULL;
+	CMString t;
+	int grc = groupCount++;
+	bool inv, quo;
+	bool ahead = 0, pos = 0, noncap = 0, indep = 0;
+	unsigned long oldFlags = flags;
+
+	if (inParen)
+	{
+		if (pattern[curInd] == '?')
+		{
+			++curInd;
+			--groupCount;
+			if (pattern[curInd] == ':')   { noncap = 1; ++curInd;     grc = --nonCapGroupCount; }
+			else if (pattern[curInd] == '=')   { ++curInd;     ahead = 1;  pos = 1; }
+			else if (pattern[curInd] == '!')   { ++curInd;     ahead = 1;  pos = 0; }
+			else if (pattern.Mid(curInd, 2) == L"<=")  { curInd += 2;  return parseBehind(1, end); }
+			else if (pattern.Mid(curInd, 2) == L"')   { ++curInd;     indep = 1; }
+			else
+			{
+				bool negate = false, done = false;
+				while (!done)
+				{
+					if (curInd >= pattern.GetLength())
+					{
+						raiseError();
+						return NULL;
+					}
+					else if (negate)
+					{
+						switch (pattern[curInd])
+						{
+						case 'i': flags &= ~WCPattern::CASE_INSENSITIVE;   break;
+						case 'd': flags &= ~WCPattern::UNIX_LINE_MODE;     break;
+						case 'm': flags &= ~WCPattern::MULTILINE_MATCHING; break;
+						case 's': flags &= ~WCPattern::DOT_MATCHES_ALL;    break;
+						case ':': done = true;                             break;
+						case ')':
+							++curInd;
+							*end = registerNode(new NFALookBehindUNode(L"", true));
+							return *end;
+						case '-':
+						default: raiseError(); return NULL;
+						}
+					}
+					else
+					{
+						switch (pattern[curInd])
+						{
+						case 'i': flags |= WCPattern::CASE_INSENSITIVE;    break;
+						case 'd': flags |= WCPattern::UNIX_LINE_MODE;      break;
+						case 'm': flags |= WCPattern::MULTILINE_MATCHING;  break;
+						case 's': flags |= WCPattern::DOT_MATCHES_ALL;     break;
+						case ':': done = true;                             break;
+						case '-': negate = true;                           break;
+						case ')':
+							++curInd;
+							*end = registerNode(new NFALookBehindUNode(L"", true));
+							return *end;
+						default:  raiseError(); return NULL;
+						}
+					}
+					++curInd;
+				}
+				noncap = 1;
+				grc = --nonCapGroupCount;
+			}
+
+			if (noncap) cur = start = registerNode(new NFAGroupHeadUNode(grc));
+			else        cur = start = registerNode(new NFASubStartUNode);
+		}
+		else cur = start = registerNode(new NFAGroupHeadUNode(grc));
+	}
+	else cur = start = registerNode(new NFASubStartUNode);
+	while (curInd < pattern.GetLength())
+	{
+		wchar_t ch = pattern[curInd++];
+
+		next = NULL;
+		if (error) return NULL;
+		switch (ch) {
+		case '^':
+			if ((flags & WCPattern::MULTILINE_MATCHING) != 0) next = registerNode(new NFAStartOfLineUNode);
+			else                                            next = registerNode(new NFAStartOfInputUNode);
+			break;
+		case '$':
+			if ((flags & WCPattern::MULTILINE_MATCHING) != 0) next = registerNode(new NFAEndOfLineUNode);
+			else                                            next = registerNode(new NFAEndOfInputUNode(0));
+			break;
+		case '|':
+			--groupCount;
+			cur->next = registerNode(new NFAAcceptUNode);
+			cur = start = registerNode(new NFAOrUNode(start, parse(inParen, 1)));
+			break;
+		case '\\':
+			if (curInd < pattern.GetLength()) {
+				bool eoi = 0;
+				switch (pattern[curInd]) {
+				case '1':
+				case '2':
+				case '3':
+				case '4':
+				case '5':
+				case '6':
+				case '7':
+				case '8':
+				case '9': next = parseBackref(); break;
+				case 'A': ++curInd; next = registerNode(new NFAStartOfInputUNode);     break;
+				case 'B': ++curInd; next = registerNode(new NFAWordBoundaryUNode(0));  break;
+				case 'b': ++curInd; next = registerNode(new NFAWordBoundaryUNode(1));  break;
+				case 'G': ++curInd; next = registerNode(new NFAEndOfMatchUNode);       break;
+				case 'Z': eoi = 1;
+				case 'z': ++curInd; next = registerNode(new NFAEndOfInputUNode(eoi));  break;
+				default:
+					t = parseEscape(inv, quo);
+					//printf("inv quo classes { %c %c %s }\n", inv ? 't' : 'f', quo ? 't' : 'f', t.c_str());
+					if (!quo) {
+						if (t.GetLength() > 1 || inv) {
+							if ((flags & WCPattern::CASE_INSENSITIVE) != 0) next = registerNode(new NFACIClassUNode(t, inv));
+							else                                            next = registerNode(new NFAClassUNode(t, inv));
+						}
+						else next = registerNode(new NFACharUNode(t[0]));
+					}
+					else next = parseQuote();
+				}
+			}
+			else raiseError();
+			break;
+		case '[':
+			if ((flags & WCPattern::CASE_INSENSITIVE) == 0) {
+				NFAClassUNode * clazz = new NFAClassUNode();
+				CMString s = parseClass();
+				for (int i = 0; i < (int)s.GetLength(); ++i) clazz->vals[s[i]] = 1;
+				next = registerNode(clazz);
+			}
+			else {
+				NFACIClassUNode * clazz = new NFACIClassUNode();
+				CMString s = parseClass();
+				for (int i = 0; i < s.GetLength(); ++i) clazz->vals[to_lower(s[i])] = 1;
+				next = registerNode(clazz);
+			}
+			break;
+		case '.':
+			{
+				bool useN = 1, useR = 1;
+				NFAClassUNode * clazz = new NFAClassUNode(1);
+				if ((flags & WCPattern::UNIX_LINE_MODE) != 0) useR = 0;
+				if ((flags & WCPattern::DOT_MATCHES_ALL) != 0) useN = useR = 0;
+				if (useN) clazz->vals['\n'] = 1;
+				if (useR) clazz->vals['\r'] = 1;
+				next = registerNode(clazz);
+			}
+			break;
+		case '(':
+			{
+				NFAUNode *end, *t1, *t2;
+				t1 = parse(1, 0, &end);
+				if (!t1) raiseError();
+				else if (t1->isGroupHeadNode() && (t2 = quantifyGroup(t1, end, grc)) != NULL) {
+					cur->next = t2;
+					cur = t2->next;
+				}
+				else {
+					cur->next = t1;
+					cur = end;
+				}
+			}
+			break;
+		case ')':
+			if (!inParen) raiseError();
+			else if (inOr)
+			{
+				--curInd;
+				cur = cur->next = registerNode(new NFAAcceptUNode);
+				flags = oldFlags;
+				return start;
+			}
+			else
+			{
+				if (ahead)
+				{
+					cur = cur->next = registerNode(new NFAAcceptUNode);
+					flags = oldFlags;
+					return *end = registerNode(new NFALookAheadUNode(start, pos));
+				}
+				else if (indep)
+				{
+					cur = cur->next = registerNode(new NFAAcceptUNode);
+					flags = oldFlags;
+					return *end = registerNode(new NFAPossessiveQuantifierUNode(this, start, 1, 1));
+				}
+				else // capping or noncapping, it doesnt matter
+				{
+					*end = cur = cur->next = registerNode(new NFAGroupTailUNode(grc));
+					next = quantifyGroup(start, *end, grc);
+					if (next)
+					{
+						start = next;
+						*end = next->next;
+					}
+					flags = oldFlags;
+					return start;
+				}
+			}
+			break;
+		case '{': // registered pattern
+			cur->next = parseRegisteredWCPattern(&next);
+			if (cur->next) cur = next;
+			break;
+		case '*':
+		case '+':
+		case '?':
+			//    case '}':
+			//    case ']':
+			raiseError();
+			break;
+		default:
+			if ((flags & WCPattern::CASE_INSENSITIVE) != 0) next = registerNode(new NFACICharUNode(ch));
+			else                                          next = registerNode(new NFACharUNode(ch));
+			break;
+		}
+		if (next) cur = cur->next = quantify(next);
+	}
+	if (inParen) raiseError();
+	else
+	{
+		if (inOr) cur = cur->next = registerNode(new NFAAcceptUNode);
+		if (end) *end = cur;
+	}
+
+	flags = oldFlags;
+	if (error) return NULL;
+
+	return start;
+}
+
+WCPattern * WCPattern::compile(const CMString & pattern, const unsigned long mode)
+{
+	WCPattern * p = new WCPattern(pattern);
+	NFAUNode * end;
+
+	p->flags = mode;
+	if ((mode & WCPattern::LITERAL) != 0) {
+		p->head = p->registerNode(new NFAStartUNode);
+		if ((mode & WCPattern::CASE_INSENSITIVE) != 0)  p->head->next = p->registerNode(new NFACIQuoteUNode(pattern));
+		else                                          p->head->next = p->registerNode(new NFAQuoteUNode(pattern));
+		p->head->next->next = p->registerNode(new NFAEndUNode);
+	}
+	else {
+		p->head = p->parse(0, 0, &end);
+		if (!p->head) {
+			delete p;
+			p = NULL;
+		}
+		else {
+			if (!(p->head && p->head->isStartOfInputNode())) {
+				NFAUNode * n = p->registerNode(new NFAStartUNode);
+				n->next = p->head;
+				p->head = n;
+			}
+			end->next = p->registerNode(new NFAEndUNode);
+		}
+	}
+
+	if (p != NULL)
+		p->matcher = new WCMatcher(p, L"");
+
+	return p;
+}
+
+WCPattern * WCPattern::compileAndKeep(const CMString & pattern, const unsigned long mode)
+{
+	WCPattern * ret = NULL;
+	std::map::iterator it = compiledWCPatterns.find(pattern);
+	if (it != compiledWCPatterns.end())
+		ret = it->second;
+	else {
+		ret = compile(pattern, mode);
+		compiledWCPatterns[pattern] = ret;
+	}
+
+	return ret;
+}
+CMString WCPattern::replace(const CMString & pattern, const CMString & str,
+	const CMString & replacementText, const unsigned long mode)
+{
+	CMString ret;
+	WCPattern * p = WCPattern::compile(pattern, mode);
+	if (p)
+	{
+		ret = p->replace(str, replacementText);
+		delete p;
+	}
+	return ret;
+}
+
+std::vector WCPattern::split(const CMString & pattern, const CMString & str, const bool keepEmptys,
+	const unsigned long limit, const unsigned long mode)
+{
+	std::vector ret;
+	WCPattern *p = WCPattern::compile(pattern, mode);
+	if (p) {
+		ret = p->split(str, keepEmptys, limit);
+		delete p;
+	}
+	return ret;
+}
+
+std::vector WCPattern::findAll(const CMString & pattern, const CMString & str, const unsigned long mode)
+{
+	std::vector ret;
+	WCPattern *p = WCPattern::compile(pattern, mode);
+	if (p) {
+		ret = p->findAll(str);
+		delete p;
+	}
+	return ret;
+}
+
+bool WCPattern::matches(const CMString & pattern, const CMString & str, const unsigned long mode)
+{
+	bool ret = 0;
+	WCPattern * p = compile(pattern, mode);
+
+	if (p)
+	{
+		ret = p->matches(str);
+		delete p;
+	}
+
+	return ret;
+}
+
+bool WCPattern::registerWCPattern(const CMString & name, const CMString & pattern, const unsigned long mode)
+{
+	WCPattern * p = WCPattern::compile(pattern, mode);
+	if (!p) return 0;
+	WCPattern::registeredWCPatterns[name] = std::make_pair(pattern, mode);
+	delete p;
+	return 1;
 }
 
 void WCPattern::unregisterWCPatterns()
 {
-  registeredWCPatterns.clear();
+	registeredWCPatterns.clear();
 }
 void WCPattern::clearWCPatternCache()
 {
-  std::map::iterator it;
-  for (it = compiledWCPatterns.begin(); it != compiledWCPatterns.end(); ++it)
-  {
-    delete it->second;
-  }
-  compiledWCPatterns.clear();
+	std::map::iterator it;
+	for (it = compiledWCPatterns.begin(); it != compiledWCPatterns.end(); ++it)
+		delete it->second;
+
+	compiledWCPatterns.clear();
 }
 
-std::pair  WCPattern::findNthMatch(const bkstring & pattern, const bkstring & str,
-                                         const int matchNum, const unsigned long mode)
+std::pair  WCPattern::findNthMatch(const CMString & pattern, const CMString & str,
+	const int matchNum, const unsigned long mode)
 {
-  std::pair ret;
-  WCPattern * p = WCPattern::compile(pattern, mode);
+	std::pair ret;
+	WCPattern * p = WCPattern::compile(pattern, mode);
 
-  ret.second = -1;
-  if (p)
-  {
-    int i = -1;
-    p->matcher->setString(str);
-    while (i < matchNum && p->matcher->findNextMatch()) { ++i; }
-    if (i == matchNum && p->matcher->getStartingIndex() >= 0)
-    {
-      ret.first = p->matcher->getGroup(0);
-      ret.second = p->matcher->getStartingIndex();
-    }
-    delete p;
-  }
+	ret.second = -1;
+	if (p)
+	{
+		int i = -1;
+		p->matcher->setString(str);
+		while (i < matchNum && p->matcher->findNextMatch()) { ++i; }
+		if (i == matchNum && p->matcher->getStartingIndex() >= 0)
+		{
+			ret.first = p->matcher->getGroup(0);
+			ret.second = p->matcher->getStartingIndex();
+		}
+		delete p;
+	}
 
-  return ret;
+	return ret;
 }
 
 WCPattern::~WCPattern()
 {
-  /*
-  nodes.clear();
-  if (head) head->findAllNodes(nodes);
-  */
-  if (matcher) delete matcher;
-  for (std::map::iterator it = nodes.begin(); it != nodes.end(); ++it) delete it->first;
+	/*
+	nodes.Empty();
+	if (head) head->findAllNodes(nodes);
+	*/
+	if (matcher) delete matcher;
+	for (std::map::iterator it = nodes.begin(); it != nodes.end(); ++it)
+		delete it->first;
 }
-bkstring WCPattern::replace(const bkstring & str, const bkstring & replacementText)
+CMString WCPattern::replace(const CMString & str, const CMString & replacementText)
 {
-  int li = 0;
-  bkstring ret = L"";
+	int li = 0;
+	CMString ret = L"";
 
-  matcher->setString(str);
-  while (matcher->findNextMatch())
-  {
-    ret += str.substr(li, matcher->getStartingIndex() - li);
-    ret += matcher->replaceWithGroups(replacementText);
-    li = matcher->getEndingIndex();
-  }
-  ret += str.substr(li);
+	matcher->setString(str);
+	while (matcher->findNextMatch())
+	{
+		ret += str.Mid(li, matcher->getStartingIndex() - li);
+		ret += matcher->replaceWithGroups(replacementText);
+		li = matcher->getEndingIndex();
+	}
+	ret += str.Mid(li);
 
-  return ret;
+	return ret;
 }
-std::vector WCPattern::split(const bkstring & str, const bool keepEmptys, const unsigned long limit)
+std::vector WCPattern::split(const CMString & str, const bool keepEmptys, const unsigned long limit)
 {
-  unsigned long lim = (limit == 0 ? MAX_QMATCH : limit);
-  int li = 0;
-  std::vector ret;
+	unsigned long lim = (limit == 0 ? MAX_QMATCH : limit);
+	int li = 0;
+	std::vector ret;
 
-  matcher->setString(str);
+	matcher->setString(str);
 
-  while (matcher->findNextMatch() && ret.size() < lim)
-  {
-    if (matcher->getStartingIndex() == 0 && keepEmptys) ret.push_back(L"");
-    if ((matcher->getStartingIndex() != matcher->getEndingIndex()) || keepEmptys)
-    {
-      if (li != matcher->getStartingIndex() || keepEmptys)
-      {
-        ret.push_back(str.substr(li, matcher->getStartingIndex() - li));
-      }
-      li = matcher->getEndingIndex();
-    }
-  }
-  if (li < (int)str.size()) ret.push_back(str.substr(li));
+	while (matcher->findNextMatch() && ret.size() < lim)
+	{
+		if (matcher->getStartingIndex() == 0 && keepEmptys) ret.push_back(L"");
+		if ((matcher->getStartingIndex() != matcher->getEndingIndex()) || keepEmptys)
+		{
+			if (li != matcher->getStartingIndex() || keepEmptys)
+			{
+				ret.push_back(str.Mid(li, matcher->getStartingIndex() - li));
+			}
+			li = matcher->getEndingIndex();
+		}
+	}
+	if (li < str.GetLength()) ret.push_back(str.Mid(li));
 
-  return ret;
+	return ret;
 }
-std::vector WCPattern::findAll(const bkstring & str)
+std::vector WCPattern::findAll(const CMString & str)
 {
-  matcher->setString(str);
-  return matcher->findAll();
+	matcher->setString(str);
+	return matcher->findAll();
 }
-bool WCPattern::matches(const bkstring & str)
+bool WCPattern::matches(const CMString & str)
 {
-  matcher->setString(str);
-  return matcher->matches();
+	matcher->setString(str);
+	return matcher->matches();
 }
 unsigned long WCPattern::getFlags() const
 {
-  return flags;
+	return flags;
 }
-bkstring WCPattern::getWCPattern() const
+CMString WCPattern::getWCPattern() const
 {
-  return pattern;
+	return pattern;
 }
-WCMatcher * WCPattern::createWCMatcher(const bkstring & str)
+WCMatcher * WCPattern::createWCMatcher(const CMString & str)
 {
-  return new WCMatcher(this, str);
+	return new WCMatcher(this, str);
 }
 
 // NFAUNode
@@ -1196,227 +1133,233 @@ NFAUNode::NFAUNode() { next = NULL; }
 NFAUNode::~NFAUNode() { }
 void NFAUNode::findAllNodes(std::map & soFar)
 {
-  if (soFar.find(this) == soFar.end()) return;
-  soFar[this] = 1;
-  if (next) next->findAllNodes(soFar);
+	if (soFar.find(this) == soFar.end()) return;
+	soFar[this] = 1;
+	if (next) next->findAllNodes(soFar);
 }
 
 // NFACharUNode
 
 NFACharUNode::NFACharUNode(const wchar_t c) { ch = c; }
-int NFACharUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFACharUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd < (int)str.size() && str[curInd] == ch) return next->match(str, matcher, curInd + 1);
-  return -1;
+	if (curInd < str.GetLength() && str[curInd] == ch)
+		return next->match(str, matcher, curInd + 1);
+	return -1;
 }
 
 // NFACICharUNode
 
 NFACICharUNode::NFACICharUNode(const wchar_t c) { ch = to_lower(c); }
-int NFACICharUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFACICharUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd < (int)str.size() && to_lower(str[curInd]) == ch) return next->match(str, matcher, curInd + 1);
-  return -1;
+	if (curInd < str.GetLength() && to_lower(str[curInd]) == ch)
+		return next->match(str, matcher, curInd + 1);
+	return -1;
 }
 
 // NFAStartUNode
 
 NFAStartUNode::NFAStartUNode() { }
-int NFAStartUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  int ret = -1, ci = curInd;
-
-  matcher->starts[0] = curInd;
-  if ((matcher->getFlags() & WCMatcher::MATCH_ENTIRE_STRING) == (unsigned int)WCMatcher::MATCH_ENTIRE_STRING)
-  {
-    if (curInd != 0)
-    {
-      matcher->starts[0] = -1;
-      return -1;
-    }
-    return next->match(str, matcher, 0);
-  }
-  while ((ret = next->match(str, matcher, ci)) == -1 && ci < (int)str.size())
-  {
-    matcher->clearGroups();
-    matcher->starts[0] = ++ci;
-  }
-  if (ret < 0) matcher->starts[0] = -1;
-  return ret;
+int NFAStartUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	int ret = -1, ci = curInd;
+
+	matcher->starts[0] = curInd;
+	if ((matcher->getFlags() & WCMatcher::MATCH_ENTIRE_STRING) == (unsigned int)WCMatcher::MATCH_ENTIRE_STRING)
+	{
+		if (curInd != 0)
+		{
+			matcher->starts[0] = -1;
+			return -1;
+		}
+		return next->match(str, matcher, 0);
+	}
+	while ((ret = next->match(str, matcher, ci)) == -1 && ci < str.GetLength())
+	{
+		matcher->clearGroups();
+		matcher->starts[0] = ++ci;
+	}
+	if (ret < 0) matcher->starts[0] = -1;
+	return ret;
 }
 
 // NFAEndUNode
 
 NFAEndUNode::NFAEndUNode() { }
-int NFAEndUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAEndUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  matcher->ends[0] = curInd;
-  if ((matcher->getFlags() & WCMatcher::MATCH_ENTIRE_STRING) != 0)
-  {
-    if (curInd == (int)str.size()) return curInd;
-    matcher->ends[0] = -1;
-    return -1;
-  }
-  return curInd;
+	matcher->ends[0] = curInd;
+	if ((matcher->getFlags() & WCMatcher::MATCH_ENTIRE_STRING) != 0)
+	{
+		if (curInd == str.GetLength())
+			return curInd;
+		matcher->ends[0] = -1;
+		return -1;
+	}
+	return curInd;
 }
 
 // NFAQuantifierUNode
 
 void NFAQuantifierUNode::findAllNodes(std::map & soFar)
 {
-  inner->findAllNodes(soFar);
-  NFAUNode::findAllNodes(soFar);
+	inner->findAllNodes(soFar);
+	NFAUNode::findAllNodes(soFar);
 }
 NFAQuantifierUNode::NFAQuantifierUNode(WCPattern * pat, NFAUNode * internal, const int minMatch, const int maxMatch)
 {
-  inner = internal;
-  inner->next = pat->registerNode(new NFAAcceptUNode);
-  min = (minMatch < WCPattern::MIN_QMATCH) ? WCPattern::MIN_QMATCH : minMatch;
-  max = (maxMatch > WCPattern::MAX_QMATCH) ? WCPattern::MAX_QMATCH : maxMatch;
+	inner = internal;
+	inner->next = pat->registerNode(new NFAAcceptUNode);
+	min = (minMatch < WCPattern::MIN_QMATCH) ? WCPattern::MIN_QMATCH : minMatch;
+	max = (maxMatch > WCPattern::MAX_QMATCH) ? WCPattern::MAX_QMATCH : maxMatch;
 }
 
-int NFAQuantifierUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAQuantifierUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int i0, i1, i2 = 0;
+	int i0, i1, i2 = 0;
 
-  i0 = i1 = curInd;
-  while (i2 < min)
-  {
+	i0 = i1 = curInd;
+	while (i2 < min)
+	{
 
-    ++i2;
-    i1 = inner->match(str, matcher, i0);
-    if (i1 <= i0) return i1; // i1 < i0 means i1 is -1
-    i0 = i1;
-  }
+		++i2;
+		i1 = inner->match(str, matcher, i0);
+		if (i1 <= i0) return i1; // i1 < i0 means i1 is -1
+		i0 = i1;
+	}
 
-  return i1;
+	return i1;
 }
 // NFAGreedyQuantifierUNode
 
 NFAGreedyQuantifierUNode::NFAGreedyQuantifierUNode(WCPattern * pat, NFAUNode * internal, const int minMatch, const int maxMatch)
-                        : NFAQuantifierUNode(pat, internal, minMatch, maxMatch) { }
-int NFAGreedyQuantifierUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+: NFAQuantifierUNode(pat, internal, minMatch, maxMatch) { }
+int NFAGreedyQuantifierUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int t = NFAQuantifierUNode::match(str, matcher, curInd);
-  if (t != -1) return matchInternal(str, matcher, t, min);
-  return t;
+	int t = NFAQuantifierUNode::match(str, matcher, curInd);
+	if (t != -1) return matchInternal(str, matcher, t, min);
+	return t;
 }
-int NFAGreedyQuantifierUNode::matchInternal(const bkstring & str, WCMatcher * matcher, const int curInd, const int soFar) const
+int NFAGreedyQuantifierUNode::matchInternal(const CMString & str, WCMatcher * matcher, const int curInd, const int soFar) const
 {
-  if (soFar >= max) return next->match(str, matcher, curInd);
+	if (soFar >= max) return next->match(str, matcher, curInd);
 
-  int i, j;
+	int i, j;
 
-  i = inner->match(str, matcher, curInd);
-  if (i != -1)
-  {
-    j = matchInternal(str, matcher, i, soFar + 1);
-    if (j != -1) return j;
-  }
-  return next->match(str, matcher, curInd);
+	i = inner->match(str, matcher, curInd);
+	if (i != -1)
+	{
+		j = matchInternal(str, matcher, i, soFar + 1);
+		if (j != -1) return j;
+	}
+	return next->match(str, matcher, curInd);
 }
 
 // NFALazyQuantifierUNode
 
 NFALazyQuantifierUNode::NFALazyQuantifierUNode(WCPattern * pat, NFAUNode * internal, const int minMatch, const int maxMatch)
-                      : NFAQuantifierUNode(pat, internal, minMatch, maxMatch) { }
-int NFALazyQuantifierUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  int i, j, m = NFAQuantifierUNode::match(str, matcher, curInd);
-
-  if (m == -1) return -1;
-
-  for (i = min; i < max; ++i)
-  {
-    j = next->match(str, matcher, m);
-    if (j == -1)
-    {
-      j = inner->match(str, matcher, m);
-      // if j < m, then j is -1, so we bail.
-      // if j == m, then we would just go and call next->match on the same index,
-      // but it already failed trying to match right there, so we know we can
-      // just bail
-      if (j <= m) return -1;
-      m = j;
-    }
-    else return j;
-  }
-  return next->match(str, matcher, m);
+: NFAQuantifierUNode(pat, internal, minMatch, maxMatch) { }
+int NFALazyQuantifierUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	int i, j, m = NFAQuantifierUNode::match(str, matcher, curInd);
+
+	if (m == -1) return -1;
+
+	for (i = min; i < max; ++i)
+	{
+		j = next->match(str, matcher, m);
+		if (j == -1)
+		{
+			j = inner->match(str, matcher, m);
+			// if j < m, then j is -1, so we bail.
+			// if j == m, then we would just go and call next->match on the same index,
+			// but it already failed trying to match right there, so we know we can
+			// just bail
+			if (j <= m) return -1;
+			m = j;
+		}
+		else return j;
+	}
+	return next->match(str, matcher, m);
 }
 
 // NFAPossessiveQuantifierUNode
 
 NFAPossessiveQuantifierUNode::NFAPossessiveQuantifierUNode(WCPattern * pat, NFAUNode * internal, const int minMatch, const int maxMatch)
-                            : NFAQuantifierUNode(pat, internal, minMatch, maxMatch) { }
-int NFAPossessiveQuantifierUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+: NFAQuantifierUNode(pat, internal, minMatch, maxMatch) { }
+int NFAPossessiveQuantifierUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int i, j, m = NFAQuantifierUNode::match(str, matcher, curInd);
+	int i, j, m = NFAQuantifierUNode::match(str, matcher, curInd);
 
-  if (m == -1) return -1;
-  for (i = min; i < max; ++i)
-  {
-    j = inner->match(str, matcher, m);
-    if (j <= m) return next->match(str, matcher, m);
-    m = j;
-  }
-  return next->match(str, matcher, m);
+	if (m == -1) return -1;
+	for (i = min; i < max; ++i)
+	{
+		j = inner->match(str, matcher, m);
+		if (j <= m) return next->match(str, matcher, m);
+		m = j;
+	}
+	return next->match(str, matcher, m);
 }
 
 // NFAAcceptUNode
 
 NFAAcceptUNode::NFAAcceptUNode() { }
-int NFAAcceptUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAAcceptUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (!next) return curInd;
-  else return next->match(str, matcher, curInd);
+	if (!next) return curInd;
+	else return next->match(str, matcher, curInd);
 }
 
 // NFAClassUNode
 
 NFAClassUNode::NFAClassUNode(const bool invert)
 {
-  inv = invert;
+	inv = invert;
 }
-NFAClassUNode::NFAClassUNode(const bkstring & clazz, const bool invert)
+NFAClassUNode::NFAClassUNode(const CMString & clazz, const bool invert)
 {
-  inv = invert;
-  for (int i = 0; i < (int)clazz.size(); ++i) vals[clazz[i]] = 1;
+	inv = invert;
+	for (int i = 0; i < clazz.GetLength(); ++i)
+		vals[clazz[i]] = 1;
 }
-int NFAClassUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAClassUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd < (int)str.size() && ((vals.find(str[curInd]) != vals.end()) ^ inv))
-  {
-    return next->match(str, matcher, curInd + 1);
-  }
-  return -1;
+	if (curInd < str.GetLength() && ((vals.find(str[curInd]) != vals.end()) ^ inv))
+	{
+		return next->match(str, matcher, curInd + 1);
+	}
+	return -1;
 }
 
 // NFACIClassUNode
 
 NFACIClassUNode::NFACIClassUNode(const bool invert)
 {
-  inv = invert;
+	inv = invert;
 }
-NFACIClassUNode::NFACIClassUNode(const bkstring & clazz, const bool invert)
+
+NFACIClassUNode::NFACIClassUNode(const CMString & clazz, const bool invert)
 {
-  inv = invert;
-  for (int i = 0; i < (int)clazz.size(); ++i) vals[to_lower(clazz[i])] = 1;
+	inv = invert;
+	for (int i = 0; i < (int)clazz.GetLength(); ++i)
+		vals[to_lower(clazz[i])] = 1;
 }
-int NFACIClassUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+
+int NFACIClassUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd < (int)str.size() && ((vals.find(to_lower(str[curInd])) != vals.end()) ^ inv))
-  {
-    return next->match(str, matcher, curInd + 1);
-  }
-  return -1;
+	if (curInd < str.GetLength() && ((vals.find(to_lower(str[curInd])) != vals.end()) ^ inv))
+		return next->match(str, matcher, curInd + 1);
+
+	return -1;
 }
 
 // NFASubStartUNode
 
 NFASubStartUNode::NFASubStartUNode() { }
-int NFASubStartUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFASubStartUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  return next->match(str, matcher, curInd);
+	return next->match(str, matcher, curInd);
 }
 
 // NFAOrUNode
@@ -1424,39 +1367,39 @@ int NFASubStartUNode::match(const bkstring & str, WCMatcher * matcher, const int
 NFAOrUNode::NFAOrUNode(NFAUNode * first, NFAUNode * second) : one(first), two(second) { }
 void NFAOrUNode::findAllNodes(std::map & soFar)
 {
-  if (one) one->findAllNodes(soFar);
-  if (two) two->findAllNodes(soFar);
-  NFAUNode::findAllNodes(soFar);
+	if (one) one->findAllNodes(soFar);
+	if (two) two->findAllNodes(soFar);
+	NFAUNode::findAllNodes(soFar);
 }
-int NFAOrUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAOrUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int ci = one->match(str, matcher, curInd);
+	int ci = one->match(str, matcher, curInd);
 
-  if (ci != -1) ci = next->match(str, matcher, ci);
-  if (ci != -1) return ci;
-  if (ci == -1) ci = two->match(str, matcher, curInd);
-  if (ci != -1) ci = next->match(str, matcher, ci);
-  return ci;
+	if (ci != -1) ci = next->match(str, matcher, ci);
+	if (ci != -1) return ci;
+	if (ci == -1) ci = two->match(str, matcher, curInd);
+	if (ci != -1) ci = next->match(str, matcher, ci);
+	return ci;
 }
 
 // NFAQuoteUNode
 
-NFAQuoteUNode::NFAQuoteUNode(const bkstring & quoted) : qStr(quoted) { }
-int NFAQuoteUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+NFAQuoteUNode::NFAQuoteUNode(const CMString & quoted) : qStr(quoted) { }
+int NFAQuoteUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd + qStr.size() > str.size())       return -1;
-  if (str.substr(curInd, qStr.size()) != qStr) return -1;
-  return next->match(str, matcher, curInd + (int)qStr.size());
+	if (curInd + qStr.GetLength() > str.GetLength()) return -1;
+	if (str.Mid(curInd, qStr.GetLength()) != qStr) return -1;
+	return next->match(str, matcher, curInd + qStr.GetLength());
 }
 
 // NFACIQuoteUNode
 
-NFACIQuoteUNode::NFACIQuoteUNode(const bkstring & quoted) : qStr(quoted) { }
-int NFACIQuoteUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+NFACIQuoteUNode::NFACIQuoteUNode(const CMString & quoted) : qStr(quoted) { }
+int NFACIQuoteUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd + qStr.size() > str.size()) return -1;
-  if (str_icmp(str.substr(curInd, qStr.size()).c_str(),  qStr.c_str())) return -1;
-  return next->match(str, matcher, (int)qStr.size());
+	if (curInd + qStr.GetLength() > str.GetLength()) return -1;
+	if (str_icmp(str.Mid(curInd, qStr.GetLength()).c_str(), qStr.c_str())) return -1;
+	return next->match(str, matcher, qStr.GetLength());
 }
 
 // NFALookAheadUNode
@@ -1464,267 +1407,268 @@ int NFACIQuoteUNode::match(const bkstring & str, WCMatcher * matcher, const int
 NFALookAheadUNode::NFALookAheadUNode(NFAUNode * internal, const bool positive) : NFAUNode(), pos(positive), inner(internal) { }
 void NFALookAheadUNode::findAllNodes(std::map & soFar)
 {
-  if (inner) inner->findAllNodes(soFar);
-  NFAUNode::findAllNodes(soFar);
+	if (inner) inner->findAllNodes(soFar);
+	NFAUNode::findAllNodes(soFar);
 }
-int NFALookAheadUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFALookAheadUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  return ((inner->match(str, matcher, curInd) == -1) ^ pos) ? next->match(str, matcher, curInd) : -1;
+	return ((inner->match(str, matcher, curInd) == -1) ^ pos) ? next->match(str, matcher, curInd) : -1;
 }
 
 // NFALookBehindUNode
 
-NFALookBehindUNode::NFALookBehindUNode(const bkstring & str, const bool positive) : pos(positive), mStr(str) { }
-int NFALookBehindUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  if (pos)
-  {
-    if (curInd < (int)mStr.size()) return -1;
-    if (str.substr(curInd - mStr.size(), mStr.size()) == mStr) return next->match(str, matcher, curInd);
-  }
-  else
-  {
-    if (curInd < (int)mStr.size()) return next->match(str, matcher, curInd);
-    if (str.substr(curInd - mStr.size(), mStr.size()) == mStr) return -1;
-     return next->match(str, matcher, curInd);
-  }
-  return -1;
+NFALookBehindUNode::NFALookBehindUNode(const CMString & str, const bool positive) : pos(positive), mStr(str) { }
+int NFALookBehindUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	if (pos) {
+		if (curInd < mStr.GetLength())
+			return -1;
+		if (str.Mid(curInd - mStr.GetLength(), mStr.GetLength()) == mStr)
+			return next->match(str, matcher, curInd);
+	}
+	else {
+		if (curInd < mStr.GetLength())
+			return next->match(str, matcher, curInd);
+		if (str.Mid(curInd - mStr.GetLength(), mStr.GetLength()) == mStr)
+			return -1;
+		return next->match(str, matcher, curInd);
+	}
+	return -1;
 }
 
 // NFAStartOfLineUNode
 
 NFAStartOfLineUNode::NFAStartOfLineUNode() { }
-int NFAStartOfLineUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAStartOfLineUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd == 0 || str[curInd - 1] == (wchar_t)'\n' || str[curInd - 1] == (wchar_t)'\r')
-  {
-    return next->match(str, matcher, curInd);
-  }
-  return -1;
+	if (curInd == 0 || str[curInd - 1] == '\n' || str[curInd - 1] == '\r')
+	{
+		return next->match(str, matcher, curInd);
+	}
+	return -1;
 }
 
 // NFAEndOfLineUNode
 
 NFAEndOfLineUNode::NFAEndOfLineUNode() { }
-int NFAEndOfLineUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAEndOfLineUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd >= (int)str.size() || str[curInd] == (wchar_t)'\n' || str[curInd] == (wchar_t)'\r')
-  {
-    return next->match(str, matcher, curInd);
-  }
-  return -1;
+	if (curInd >= str.GetLength() || str[curInd] == '\n' || str[curInd] == '\r')
+		return next->match(str, matcher, curInd);
+
+	return -1;
 }
 
 // NFAReferenceUNode
 
 NFAReferenceUNode::NFAReferenceUNode(const int groupIndex) : gi(groupIndex) { }
-int NFAReferenceUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAReferenceUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int len = matcher->ends[gi] - matcher->starts[gi];
-  int ni = -1;
-  if      (gi < 1 || matcher->ends[gi] < matcher->starts[gi] || len == 0)             ni = curInd;
-  else if (curInd + len > (int)str.size())                                            return -1;
-  else if (str.substr(curInd, len) != str.substr(matcher->starts[gi], len))  return -1;
-  else                                                                                ni = curInd + len;
+	int len = matcher->ends[gi] - matcher->starts[gi];
+	int ni = -1;
+	if (gi < 1 || matcher->ends[gi] < matcher->starts[gi] || len == 0)   ni = curInd;
+	else if (curInd + len > (int)str.GetLength())                        return -1;
+	else if (str.Mid(curInd, len) != str.Mid(matcher->starts[gi], len))  return -1;
+	else                                                                 ni = curInd + len;
 
-  return next->match(str, matcher, ni);
+	return next->match(str, matcher, ni);
 }
 
 // NFAStartOfInputUNode
 
 NFAStartOfInputUNode::NFAStartOfInputUNode() { }
-int NFAStartOfInputUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAStartOfInputUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd == 0) return next->match(str, matcher, curInd);
-  return -1;
+	if (curInd == 0) return next->match(str, matcher, curInd);
+	return -1;
 }
 
 // NFAEndOfInputUNode
 
 NFAEndOfInputUNode::NFAEndOfInputUNode(const bool lookForTerm) : term(lookForTerm) { }
-int NFAEndOfInputUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  int len = (int)str.size();
-  if      (curInd == len) return next->match(str, matcher, curInd);
-  else if (term)
-  {
-    if      (curInd == len - 1 && (str[curInd] == (wchar_t)'\r' || str[curInd] == (wchar_t)'\n'))
-    {
-      return next->match(str, matcher, curInd);
-    }
-    else if (curInd == len - 2 && str.substr(curInd, 2) == L"\r\n")
-    {
-      return next->match(str, matcher, curInd);
-    }
-  }
-  return -1;
+int NFAEndOfInputUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	int len = str.GetLength();
+	if (curInd == len) return next->match(str, matcher, curInd);
+	else if (term)
+	{
+		if (curInd == len - 1 && (str[curInd] == '\r' || str[curInd] == '\n'))
+		{
+			return next->match(str, matcher, curInd);
+		}
+		else if (curInd == len - 2 && str.Mid(curInd, 2) == L"\r\n")
+		{
+			return next->match(str, matcher, curInd);
+		}
+	}
+	return -1;
 }
 
 // NFAWordBoundaryUNode
 
 NFAWordBoundaryUNode::NFAWordBoundaryUNode(const bool positive) : pos(positive) { }
-int NFAWordBoundaryUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAWordBoundaryUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int len = (int)str.size();
+	int len = str.GetLength();
 
-  wchar_t c1 = (curInd - 1 < len && curInd > 0) ? str[curInd - 1] : '\n';
-  wchar_t c2 = (curInd     < len) ? str[curInd    ] : '\n';
+	wchar_t c1 = (curInd - 1 < len && curInd > 0) ? str[curInd - 1] : '\n';
+	wchar_t c2 = (curInd < len) ? str[curInd] : '\n';
 
-  if      (curInd == len) return next->match(str, matcher, curInd);
-  bool ok = is_alpha(c1) != is_alpha(c2);
-  if (ok && pos) return next->match(str, matcher, curInd);
-  return -1;
+	if (curInd == len) return next->match(str, matcher, curInd);
+	bool ok = is_alpha(c1) != is_alpha(c2);
+	if (ok && pos) return next->match(str, matcher, curInd);
+	return -1;
 }
 
 // NFAEndOfMatchUNode
 
 NFAEndOfMatchUNode::NFAEndOfMatchUNode() { }
-int NFAEndOfMatchUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAEndOfMatchUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  if (curInd == matcher->lm) return next->match(str, matcher, curInd);
-  return -1;
+	if (curInd == matcher->lm) return next->match(str, matcher, curInd);
+	return -1;
 }
 
 // NFAGroupHeadUNode
 
 NFAGroupHeadUNode::NFAGroupHeadUNode(const int groupIndex) : gi(groupIndex) { }
-int NFAGroupHeadUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAGroupHeadUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int ret, o = matcher->starts[gi];
+	int ret, o = matcher->starts[gi];
 
-  matcher->starts[gi] = curInd;
-  ret = next->match(str, matcher, curInd);
-  if (ret < 0) matcher->starts[gi] = o;
+	matcher->starts[gi] = curInd;
+	ret = next->match(str, matcher, curInd);
+	if (ret < 0) matcher->starts[gi] = o;
 
-  return ret;
+	return ret;
 }
 
 // NFAGroupTailUNode
 
 NFAGroupTailUNode::NFAGroupTailUNode(const int groupIndex) : gi(groupIndex) { }
-int NFAGroupTailUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAGroupTailUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int ret, o = matcher->ends[gi];
+	int ret, o = matcher->ends[gi];
 
-  matcher->ends[gi] = curInd;
-  ret = next->match(str, matcher, curInd);
-  if (ret < 0) matcher->ends[gi] = o;
+	matcher->ends[gi] = curInd;
+	ret = next->match(str, matcher, curInd);
+	if (ret < 0) matcher->ends[gi] = o;
 
-  return ret;
+	return ret;
 }
 
 // NFAGroupLoopPrologueUNode
 
 NFAGroupLoopPrologueUNode::NFAGroupLoopPrologueUNode(const int groupIndex) : gi(groupIndex) { }
-int NFAGroupLoopPrologueUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
+int NFAGroupLoopPrologueUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
 {
-  int ret, o1 = matcher->groups[gi], o2 = matcher->groupPos[gi], o3 = matcher->groupIndeces[gi];
+	int ret, o1 = matcher->groups[gi], o2 = matcher->groupPos[gi], o3 = matcher->groupIndeces[gi];
 
-  matcher->groups[gi] = 0;
-  matcher->groupPos[gi] = 0;
-  matcher->groupIndeces[gi] = -1;
-  ret = next->match(str, matcher, curInd);
-  if (ret < 0)
-  {
-    matcher->groups[gi] = o1;
-    matcher->groupPos[gi] = o2;
-    matcher->groupIndeces[gi] = o3;
-  }
+	matcher->groups[gi] = 0;
+	matcher->groupPos[gi] = 0;
+	matcher->groupIndeces[gi] = -1;
+	ret = next->match(str, matcher, curInd);
+	if (ret < 0)
+	{
+		matcher->groups[gi] = o1;
+		matcher->groupPos[gi] = o2;
+		matcher->groupIndeces[gi] = o3;
+	}
 
-  return ret;
+	return ret;
 }
 
 // NFAGroupLoopUNode
 
 NFAGroupLoopUNode::NFAGroupLoopUNode(NFAUNode * internal, const int minMatch, const int maxMatch,
-                                   const int groupIndex, const int matchType)
+	const int groupIndex, const int matchType)
 {
-  inner = internal;
-  min = minMatch;
-  max = maxMatch;
-  gi = groupIndex;
-  type = matchType;
+	inner = internal;
+	min = minMatch;
+	max = maxMatch;
+	gi = groupIndex;
+	type = matchType;
 }
 void NFAGroupLoopUNode::findAllNodes(std::map & soFar)
 {
-  if (inner) inner->findAllNodes(soFar);
-  NFAUNode::findAllNodes(soFar);
-}
-int NFAGroupLoopUNode::match(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  bool b = (curInd > matcher->groupIndeces[gi]);
-
-  if (b && matcher->groups[gi] < min)
-  {
-    ++matcher->groups[gi];
-    int o = matcher->groupIndeces[gi];
-    matcher->groupIndeces[gi] = curInd;
-    int ret = inner->match(str, matcher, curInd);
-    if (ret < 0)
-    {
-      matcher->groupIndeces[gi] = o;
-      --matcher->groups[gi];
-    }
-    return ret;
-  }
-  else if (!b || matcher->groups[gi] >= max)
-  {
-    return next->match(str, matcher, curInd);
-  }
-  else
-  {
-    switch (type)
-    {
-    case 0: return matchGreedy(str, matcher, curInd);
-    case 1: return matchLazy(str, matcher, curInd);
-    case 2: return matchPossessive(str, matcher, curInd);
-    }
-  }
-  return -1;
-}
-int NFAGroupLoopUNode::matchGreedy(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  int o = matcher->groupIndeces[gi];            // save our info for backtracking
-  matcher->groupIndeces[gi] = curInd;           // move along
-  ++matcher->groups[gi];
-  int ret = inner->match(str, matcher, curInd); // match internally
-  if (ret < 0)
-  {                                             // if we failed, then restore info and match next
-    --matcher->groups[gi];
-    matcher->groupIndeces[gi] = o;
-    ret = next->match(str, matcher, curInd);
-  }
-  return ret;
-}
-int NFAGroupLoopUNode::matchLazy(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  int ret = next->match(str, matcher, curInd);  // be lazy, just go on
-  if (ret < 0)
-  {
-    int o = matcher->groupIndeces[gi];          // save info for backtracking
-    matcher->groupIndeces[gi] = curInd;         // advance our position
-    ++matcher->groups[gi];
-    ret = inner->match(str, matcher, curInd);   // match our internal stuff
-    if (ret < 0)                                // if we failed, then restore the info
-    {
-      --matcher->groups[gi];
-      matcher->groupIndeces[gi] = o;
-    }
-  }
-  return ret;
-}
-int NFAGroupLoopUNode::matchPossessive(const bkstring & str, WCMatcher * matcher, const int curInd) const
-{
-  int o = matcher->groupIndeces[gi];            // save info for backtracking
-  matcher->groupPos[gi] = matcher->groups[gi];  // set a flag stating we have matcher at least this much
-  matcher->groupIndeces[gi] = curInd;           // move along
-  ++matcher->groups[gi];
-  int ret = inner->match(str, matcher, curInd); // try and match again
-  if (ret < 0)
-  {                                             // if we fail, back off, but to an extent
-    --matcher->groups[gi];
-    matcher->groupIndeces[gi] = o;
-    if (matcher->groups[gi] == matcher->groupPos[gi]) ret = next->match(str, matcher, curInd);
-  }
-  return ret;
-}
\ No newline at end of file
+	if (inner) inner->findAllNodes(soFar);
+	NFAUNode::findAllNodes(soFar);
+}
+int NFAGroupLoopUNode::match(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	bool b = (curInd > matcher->groupIndeces[gi]);
+
+	if (b && matcher->groups[gi] < min)
+	{
+		++matcher->groups[gi];
+		int o = matcher->groupIndeces[gi];
+		matcher->groupIndeces[gi] = curInd;
+		int ret = inner->match(str, matcher, curInd);
+		if (ret < 0)
+		{
+			matcher->groupIndeces[gi] = o;
+			--matcher->groups[gi];
+		}
+		return ret;
+	}
+	else if (!b || matcher->groups[gi] >= max)
+	{
+		return next->match(str, matcher, curInd);
+	}
+	else
+	{
+		switch (type)
+		{
+		case 0: return matchGreedy(str, matcher, curInd);
+		case 1: return matchLazy(str, matcher, curInd);
+		case 2: return matchPossessive(str, matcher, curInd);
+		}
+	}
+	return -1;
+}
+int NFAGroupLoopUNode::matchGreedy(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	int o = matcher->groupIndeces[gi];            // save our info for backtracking
+	matcher->groupIndeces[gi] = curInd;           // move along
+	++matcher->groups[gi];
+	int ret = inner->match(str, matcher, curInd); // match internally
+	if (ret < 0)
+	{                                             // if we failed, then restore info and match next
+		--matcher->groups[gi];
+		matcher->groupIndeces[gi] = o;
+		ret = next->match(str, matcher, curInd);
+	}
+	return ret;
+}
+int NFAGroupLoopUNode::matchLazy(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	int ret = next->match(str, matcher, curInd);  // be lazy, just go on
+	if (ret < 0)
+	{
+		int o = matcher->groupIndeces[gi];          // save info for backtracking
+		matcher->groupIndeces[gi] = curInd;         // advance our position
+		++matcher->groups[gi];
+		ret = inner->match(str, matcher, curInd);   // match our internal stuff
+		if (ret < 0)                                // if we failed, then restore the info
+		{
+			--matcher->groups[gi];
+			matcher->groupIndeces[gi] = o;
+		}
+	}
+	return ret;
+}
+int NFAGroupLoopUNode::matchPossessive(const CMString & str, WCMatcher * matcher, const int curInd) const
+{
+	int o = matcher->groupIndeces[gi];            // save info for backtracking
+	matcher->groupPos[gi] = matcher->groups[gi];  // set a flag stating we have matcher at least this much
+	matcher->groupIndeces[gi] = curInd;           // move along
+	++matcher->groups[gi];
+	int ret = inner->match(str, matcher, curInd); // try and match again
+	if (ret < 0)
+	{                                             // if we fail, back off, but to an extent
+		--matcher->groups[gi];
+		matcher->groupIndeces[gi] = o;
+		if (matcher->groups[gi] == matcher->groupPos[gi]) ret = next->match(str, matcher, curInd);
+	}
+	return ret;
+}
diff --git a/plugins/SmileyAdd/src/regexp/WCPattern.h b/plugins/SmileyAdd/src/regexp/WCPattern.h
index 143eff7eb7..e3455e8b31 100644
--- a/plugins/SmileyAdd/src/regexp/WCPattern.h
+++ b/plugins/SmileyAdd/src/regexp/WCPattern.h
@@ -771,7 +771,7 @@ class NFAQuantifierUNode;
 
    
 Backslashes, escapes, and quoting 

 
-   
 The backslash character ((wchar_t)'\') serves to introduce escaped
+   
 The backslash character ('\') serves to introduce escaped
    constructs, as defined in the table above, as well as to quote characters
    that otherwise would be interpreted as unescaped constructs.  Thus the
    expression \\ matches a single backslash and \{ matches a
@@ -963,691 +963,691 @@ class NFAQuantifierUNode;
  */
 class WCPattern
 {
-  friend class WCMatcher;
-  friend class NFAUNode;
-  friend class NFAQuantifierUNode;
-  private:
-    /**
-      This constructor should not be called directly. Those wishing to use the
-      WCPattern class should instead use the {@link compile compile} method.
-
-      @param rhs The pattern to compile
-      @memo Creates a new pattern from the regular expression in rhs.
-     */
-    WCPattern(const bkstring & rhs);
-  protected:
-    /**
-      This currently is not used, so don't try to do anything with it.
-      @memo Holds all the compiled patterns for quick access.
-     */
-    static std::map compiledWCPatterns;
-    /**
-      Holds all of the registered patterns as strings. Due to certain problems
-      with compilation of patterns, especially with capturing groups, this seemed
-      to be the best way to do it.
-     */
-    static std::map > registeredWCPatterns;
-  protected:
-    /**
-      Holds all the NFA nodes used. This makes deletion of a pattern, as well as
-      clean-up from an unsuccessful compile much easier and faster.
-     */
-    std::map nodes;
-    /**
-      Used when methods like split are called. The matcher class uses a lot of
-      dynamic memeory, so having an instance increases speedup of certain
-      operations.
-     */
-    WCMatcher * matcher;
-    /**
-      The front node of the NFA.
-     */
-    NFAUNode * head;
-    /**
-      The actual regular expression we rerpesent
-      */
-    bkstring pattern;
-    /**
-      Flag used during compilation. Once the pattern is successfully compiled,
-      error is no longer used.
-     */
-    bool error;
-    /**
-      Used during compilation to keep track of the current index into
-      {@link pattern pattern}.  Once the pattern is successfully
-      compiled, error is no longer used.
-     */
-    int curInd;
-    /**
-      The number of capture groups this contains.
-     */
-    int groupCount;
-    /**
-      The number of non-capture groups this contains.
-     */
-    int nonCapGroupCount;
-    /**
-      The flags specified when this was compiled.
-     */
-    unsigned long flags;
-  protected:
-    /**
-      Raises an error during compilation. Compilation will cease at that point
-      and compile will return NULL.
-     */
-    void raiseError();
-    /**
-      Convenience function for registering a node in nodes.
-      @param node The node to register
-      @return The registered node
-     */
-    NFAUNode * registerNode(NFAUNode * node);
-
-    /**
-      Calculates the union of two strings. This function will first sort the
-      strings and then use a simple selection algorithm to find the union.
-      @param s1 The first "class" to union
-      @param s2 The second "class" to union
-      @return A new string containing all unique characters. Each character
-              must have appeared in one or both of s1 and
-              s2.
-     */
-    bkstring classUnion      (bkstring s1, bkstring s2)  const;
-    /**
-      Calculates the intersection of two strings. This function will first sort
-      the strings and then use a simple selection algorithm to find the
-      intersection.
-      @param s1 The first "class" to intersect
-      @param s2 The second "class" to intersect
-      @return A new string containing all unique characters. Each character
-              must have appeared both s1 and s2.
-     */
-    bkstring classIntersect  (bkstring s1, bkstring s2)  const;
-    /**
-      Calculates the negation of a string. The negation is the set of all
-      characters between \x00 and \xFF not
-      contained in s1.
-      @param s1 The "class" to be negated.
-      @param s2 The second "class" to intersect
-      @return A new string containing all unique characters. Each character
-              must have appeared both s1 and s2.
-     */
-    bkstring classNegate     (bkstring s1)                  const;
-    /**
-      Creates a new "class" representing the range from low thru
-      hi. This function will wrap if low >
-      hi. This is a feature, not a buf. Sometimes it is useful
-      to be able to say [\x70-\x10] instead of [\x70-\x7F\x00-\x10].
-      @param low The beginning character
-      @param hi  The ending character
-      @return A new string containing all the characters from low thru hi.
-     */
-    bkstring classCreateRange(wchar_t low,       wchar_t hi)         const;
-
-    /**
-      Extracts a decimal number from the substring of member-variable
-      {@link pattern pattern} starting at start and
-      ending at end.
-      @param start The starting index in {@link pattern pattern}
-      @param end The last index in {@link pattern pattern}
-      @return The decimal number in {@link pattern pattern}
-     */
-    int getInt(int start, int end);
-    /**
-      Parses a {n,m} string out of the member-variable
-      {@link pattern pattern} stores the result in sNum
-      and eNum.
-      @param sNum Output parameter. The minimum number of matches required
-                  by the curly quantifier are stored here.
-      @param eNum Output parameter. The maximum number of matches allowed
-                  by the curly quantifier are stored here.
-      @return Success/Failure. Fails when the curly does not have the proper
-              syntax
-     */
-    bool quantifyCurly(int & sNum, int & eNum);
-    /**
-      Tries to quantify the currently parsed group. If the group being parsed
-      is indeed quantified in the member-variable
-      {@link pattern pattern}, then the NFA is modified accordingly.
-      @param start  The starting node of the current group being parsed
-      @param stop   The ending node of the current group being parsed
-      @param gn     The group number of the current group being parsed
-      @return       The node representing the starting node of the group. If the
-                    group becomes quantified, then this node is not necessarily
-                    a GroupHead node.
-     */
-    NFAUNode * quantifyGroup(NFAUNode * start, NFAUNode * stop, const int gn);
-
-    /**
-      Tries to quantify the last parsed expression. If the character was indeed
-      quantified, then the NFA is modified accordingly.
-      @param newNode The recently created expression node
-      @return The node representing the last parsed expression. If the
-              expression was quantified, return value != newNode
-     */
-    NFAUNode * quantify(NFAUNode * newNode);
-    /**
-      Parses the current class being examined in
-      {@link pattern pattern}.
-      @return A string of unique characters contained in the current class being
-              parsed
-     */
-    bkstring parseClass();
-    /**
-      Parses the current POSIX class being examined in
-      {@link pattern pattern}.
-      @return A string of unique characters representing the POSIX class being
-              parsed
-     */
-    bkstring parsePosix();
-    /**
-      Returns a string containing the octal character being parsed
-      @return The string contained the octal value being parsed
-     */
-    bkstring parseOctal();
-    /**
-      Returns a string containing the hex character being parsed
-      @return The string contained the hex value being parsed
-     */
-    bkstring parseHex();
-    /**
-      Returns a new node representing the back reference being parsed
-      @return The new node representing the back reference being parsed
-     */
-    NFAUNode *   parseBackref();
-    /**
-      Parses the escape sequence currently being examined. Determines if the
-      escape sequence is a class, a single character, or the beginning of a
-      quotation sequence.
-      @param inv Output parameter. Whether or not to invert the returned class
-      @param quo Output parameter. Whether or not this sequence starts a
-                 quotation.
-      @return The characters represented by the class
-     */
-    bkstring parseEscape(bool & inv, bool & quo);
-    /**
-      Parses a supposed registered pattern currently under compilation. If the
-      sequence of characters does point to a registered pattern, then the
-      registered pattern is appended to *end. The registered pattern
-      is parsed with the current compilation flags.
-      @param end The ending node of the thus-far compiled pattern
-      @return The new end node of the current pattern
-     */
-    NFAUNode * parseRegisteredWCPattern(NFAUNode ** end);
-    /**
-      Parses a lookbehind expression. Appends the necessary nodes
-      *end.
-      @param pos Positive or negative look behind
-      @param end The ending node of the current pattern
-      @return The new end node of the current pattern
-     */
-    NFAUNode * parseBehind(const bool pos, NFAUNode ** end);
-    /**
-      Parses the current expression and tacks on nodes until a \E is found.
-      @return The end of the current pattern
-     */
-    NFAUNode * parseQuote();
-    /**
-      Parses {@link pattern pattern}. This function is called
-      recursively when an or (|) or a group is encountered.
-      @param inParen Are we currently parsing inside a group
-      @param inOr Are we currently parsing one side of an or (|)
-      @param end The end of the current expression
-      @return The starting node of the NFA constructed from this parse
-     */
-    NFAUNode * parse(const bool inParen = 0, const bool inOr = 0, NFAUNode ** end = NULL);
-  public:
-    /// We should match regardless of case
-    const static unsigned long CASE_INSENSITIVE;
-    /// We are implicitly quoted
-    const static unsigned long LITERAL;
-    /// @memo We should treat a . as [\x00-\x7F]
-    const static unsigned long DOT_MATCHES_ALL;
-    /** ^ and $ should anchor to the beginning and
-        ending of lines, not all input
-     */
-    const static unsigned long MULTILINE_MATCHING;
-    /** When enabled, only instances of \n are recognized as
-        line terminators
-     */
-    const static unsigned long UNIX_LINE_MODE;
-    /// The absolute minimum number of matches a quantifier can match (0)
-    const static int MIN_QMATCH;
-    /// The absolute maximum number of matches a quantifier can match (0x7FFFFFFF)
-    const static int MAX_QMATCH;
-  public:
-    /**
-      Call this function to compile a regular expression into a
-      WCPattern object. Special values can be assigned to
-      mode when certain non-standard behaviors are expected from
-      the WCPattern object.
-      @param pattern The regular expression to compile
-      @param mode    A bitwise or of flags signalling what special behaviors are
-                     wanted from this WCPattern object
-      @return If successful, compile returns a WCPattern
-              pointer. Upon failure, compile returns
-              NULL
-     */
-    static WCPattern                    * compile        (const bkstring & pattern,
-                                                        const unsigned long mode = 0);
-    /**
-      Dont use this function. This function will compile a pattern, and cache
-      the result. This will eventually be used as an optimization when people
-      just want to call static methods using the same pattern over and over
-      instead of first compiling the pattern and then using the compiled
-      instance for matching.
-      @param pattern The regular expression to compile
-      @param mode    A bitwise or of flags signalling what special behaviors are
-                     wanted from this WCPattern object
-      @return If successful, compileAndKeep returns a
-              WCPattern pointer. Upon failure, compile
-              returns NULL.
-     */
-    static WCPattern                    * compileAndKeep (const bkstring & pattern,
-                                                        const unsigned long mode = 0);
-
-    /**
-      Searches through replace and replaces all substrings matched
-      by pattern with str. str may
-      contain backreferences (e.g. \1) to capture groups. A typical
-      invocation looks like:
-      

-      
-      WCPattern::replace(L"(a+)b(c+)", L"abcccbbabcbabc", L"\\2b\\1");
-      
-      

-      which would replace abcccbbabcbabc with
-      cccbabbcbabcba.
-      @param pattern          The regular expression
-      @param str              The replacement text
-      @param replacementText  The string in which to perform replacements
-      @param mode             The special mode requested of the WCPattern
-                              during the replacement process
-      @return The text with the replacement string substituted where necessary
-     */
-    static bkstring                  replace       (const bkstring & pattern,
-                                                        const bkstring & str,
-                                                        const bkstring & replacementText,
-                                                        const unsigned long mode = 0);
-
-    /**
-      Splits the specified string over occurrences of the specified pattern.
-      Empty strings can be optionally ignored. The number of strings returned is
-      configurable. A typical invocation looks like:
-      

-      
-      bkstring str(strSize, 0);

-      FILE * fp = fopen(fileName, "r");

-      fread((char*)str.data(), strSize * 2, 1, fp);

-      fclose(fp);

-      

-      std::vector<bkstring> lines = WCPattern::split(L"[\r\n]+", str, true);

-      

-      
-
-      @param pattern    The regular expression
-      @param replace    The string to split
-      @param keepEmptys Whether or not to keep empty strings
-      @param limit      The maximum number of splits to make
-      @param mode       The special mode requested of the WCPattern
-                        during the split process
-      @return All substrings of str split across pattern.
-     */
-    static std::vector     split         (const bkstring & pattern,
-                                                        const bkstring & str,
-                                                        const bool keepEmptys = 0,
-                                                        const unsigned long limit = 0,
-                                                        const unsigned long mode = 0);
-
-    /**
-      Finds all the instances of the specified pattern within the string. You
-      should be careful to only pass patterns with a minimum length of one. For
-      example, the pattern a* can be matched by an empty string, so
-      instead you should pass a+ since at least one character must
-      be matched. A typical invocation of findAll looks like:
-      

-      
-      std::vector<td::string> numbers = WCPattern::findAll(L"\\d+", string);
-      
-      

-
-      @param pattern  The pattern for which to search
-      @param str      The string to search
-      @param mode     The special mode requested of the WCPattern
-                      during the find process
-      @return All instances of pattern in str
-     */
-    static std::vector     findAll       (const bkstring & pattern,
-                                                        const bkstring & str,
-                                                        const unsigned long mode = 0);
-
-    /**
-      Determines if an entire string matches the specified pattern
-
-      @param pattern  The pattern for to match
-      @param str      The string to match
-      @param mode     The special mode requested of the WCPattern
-                      during the replacement process
-      @return True if str is recognized by pattern
-     */
-    static bool                         matches        (const bkstring & pattern,
-                                                        const bkstring & str,
-                                                        const unsigned long mode = 0);
-
-    /**
-      Registers a pattern under a specific name for use in later compilations.
-      A typical invocation and later use looks like:
-      

-      
-      WCPattern::registerWCPattern(L"ip", L"(?:\\d{1,3}\\.){3}\\d{1,3}");

-      WCPattern * p1 = WCPattern::compile(L"{ip}:\\d+");

-      WCPattern * p2 = WCPattern::compile(L"Connection from ({ip}) on port \\d+");

-      
-      

-      Multiple calls to registerWCPattern with the same
-      name will result in the pattern getting overwritten.
-
-      @param name     The name to give to the pattern
-      @param pattern  The pattern to register
-      @param mode     Any special flags to use when compiling pattern
-      @return Success/Failure. Fails only if pattern has invalid
-              syntax
-     */
-    static bool                         registerWCPattern(const bkstring & name,
-                                                        const bkstring & pattern,
-                                                        const unsigned long mode = 0);
-
-    /**
-      Clears the pattern registry
-      */
-    static void                         unregisterWCPatterns();
-    /**
-      Don't use
-     */
-    static void                         clearWCPatternCache();
-
-    /**
-      Searches through a string for the nth match of the
-      given pattern in the string. Match indeces start at zero, not one.
-      A typical invocation looks like this:
-      

-      
-      std::pair<bkstring, int> match = WCPattern::findNthMatch(L"\\d{1,3}", L"192.168.1.101:22", 1);

-      wprintf(L"%s %i\n", match.first.c_str(), match.second);

-      

-      Output: 168 4

-      

-
-      @param pattern  The pattern for which to search
-      @param str      The string to search
-      @param matchNum Which match to find
-      @param mode     Any special flags to use during the matching process
-      @return A string and an integer. The string is the string matched. The
-              integer is the starting location of the matched string in
-              str. You can check for success/failure by making sure
-              that the integer returned is greater than or equal to zero.
-     */
-    static std::pair  findNthMatch   (const bkstring & pattern,
-                                                        const bkstring & str,
-                                                        const int matchNum,
-                                                        const unsigned long mode = 0);
-  public:
-    /**
-      Deletes all NFA nodes allocated during compilation
-     */
-    ~WCPattern();
-
-    bkstring               replace       (const bkstring & str,
-                                              const bkstring & replacementText);
-    std::vector  split         (const bkstring & str, const bool keepEmptys = 0,
-                                              const unsigned long limit = 0);
-    std::vector  findAll       (const bkstring & str);
-    bool                       matches       (const bkstring & str);
-    /**
-      Returns the flags used during compilation of this pattern
-      @return The flags used during compilation of this pattern
-     */
-    unsigned long             getFlags       () const;
-    /**
-      Returns the regular expression this pattern represents
-      @return The regular expression this pattern represents
-     */
-    bkstring               getWCPattern     () const;
-    /**
-      Creates a matcher object using the specified string and this pattern.
-      @param str The string to match against
-      @return A new matcher using object using this pattern and the specified
-              string
-     */
-    WCMatcher                 * createWCMatcher  (const bkstring & str);
+	friend class WCMatcher;
+	friend class NFAUNode;
+	friend class NFAQuantifierUNode;
+private:
+	/**
+	  This constructor should not be called directly. Those wishing to use the
+	  WCPattern class should instead use the {@link compile compile} method.
+
+	  @param rhs The pattern to compile
+	  @memo Creates a new pattern from the regular expression in rhs.
+	  */
+	WCPattern(const CMString & rhs);
+protected:
+	/**
+	  This currently is not used, so don't try to do anything with it.
+	  @memo Holds all the compiled patterns for quick access.
+	  */
+	static std::map compiledWCPatterns;
+	/**
+	  Holds all of the registered patterns as strings. Due to certain problems
+	  with compilation of patterns, especially with capturing groups, this seemed
+	  to be the best way to do it.
+	  */
+	static std::map > registeredWCPatterns;
+protected:
+	/**
+	  Holds all the NFA nodes used. This makes deletion of a pattern, as well as
+	  clean-up from an unsuccessful compile much easier and faster.
+	  */
+	std::map nodes;
+	/**
+	  Used when methods like split are called. The matcher class uses a lot of
+	  dynamic memeory, so having an instance increases speedup of certain
+	  operations.
+	  */
+	WCMatcher * matcher;
+	/**
+	  The front node of the NFA.
+	  */
+	NFAUNode * head;
+	/**
+	  The actual regular expression we rerpesent
+	  */
+	CMString pattern;
+	/**
+	  Flag used during compilation. Once the pattern is successfully compiled,
+	  error is no longer used.
+	  */
+	bool error;
+	/**
+	  Used during compilation to keep track of the current index into
+	  {@link pattern pattern}.  Once the pattern is successfully
+	  compiled, error is no longer used.
+	  */
+	int curInd;
+	/**
+	  The number of capture groups this contains.
+	  */
+	int groupCount;
+	/**
+	  The number of non-capture groups this contains.
+	  */
+	int nonCapGroupCount;
+	/**
+	  The flags specified when this was compiled.
+	  */
+	unsigned long flags;
+protected:
+	/**
+	  Raises an error during compilation. Compilation will cease at that point
+	  and compile will return NULL.
+	  */
+	void raiseError();
+	/**
+	  Convenience function for registering a node in nodes.
+	  @param node The node to register
+	  @return The registered node
+	  */
+	NFAUNode * registerNode(NFAUNode * node);
+
+	/**
+	  Calculates the union of two strings. This function will first sort the
+	  strings and then use a simple selection algorithm to find the union.
+	  @param s1 The first "class" to union
+	  @param s2 The second "class" to union
+	  @return A new string containing all unique characters. Each character
+	  must have appeared in one or both of s1 and
+	  s2.
+	  */
+	CMString classUnion(CMString s1, CMString s2)  const;
+	/**
+	  Calculates the intersection of two strings. This function will first sort
+	  the strings and then use a simple selection algorithm to find the
+	  intersection.
+	  @param s1 The first "class" to intersect
+	  @param s2 The second "class" to intersect
+	  @return A new string containing all unique characters. Each character
+	  must have appeared both s1 and s2.
+	  */
+	CMString classIntersect(CMString s1, CMString s2)  const;
+	/**
+	  Calculates the negation of a string. The negation is the set of all
+	  characters between \x00 and \xFF not
+	  contained in s1.
+	  @param s1 The "class" to be negated.
+	  @param s2 The second "class" to intersect
+	  @return A new string containing all unique characters. Each character
+	  must have appeared both s1 and s2.
+	  */
+	CMString classNegate(CMString s1)                  const;
+	/**
+	  Creates a new "class" representing the range from low thru
+	  hi. This function will wrap if low >
+	  hi. This is a feature, not a buf. Sometimes it is useful
+	  to be able to say [\x70-\x10] instead of [\x70-\x7F\x00-\x10].
+	  @param low The beginning character
+	  @param hi  The ending character
+	  @return A new string containing all the characters from low thru hi.
+	  */
+	CMString classCreateRange(wchar_t low, wchar_t hi)         const;
+
+	/**
+	  Extracts a decimal number from the substring of member-variable
+	  {@link pattern pattern} starting at start and
+	  ending at end.
+	  @param start The starting index in {@link pattern pattern}
+	  @param end The last index in {@link pattern pattern}
+	  @return The decimal number in {@link pattern pattern}
+	  */
+	int getInt(int start, int end);
+	/**
+	  Parses a {n,m} string out of the member-variable
+	  {@link pattern pattern} stores the result in sNum
+	  and eNum.
+	  @param sNum Output parameter. The minimum number of matches required
+	  by the curly quantifier are stored here.
+	  @param eNum Output parameter. The maximum number of matches allowed
+	  by the curly quantifier are stored here.
+	  @return Success/Failure. Fails when the curly does not have the proper
+	  syntax
+	  */
+	bool quantifyCurly(int & sNum, int & eNum);
+	/**
+	  Tries to quantify the currently parsed group. If the group being parsed
+	  is indeed quantified in the member-variable
+	  {@link pattern pattern}, then the NFA is modified accordingly.
+	  @param start  The starting node of the current group being parsed
+	  @param stop   The ending node of the current group being parsed
+	  @param gn     The group number of the current group being parsed
+	  @return       The node representing the starting node of the group. If the
+	  group becomes quantified, then this node is not necessarily
+	  a GroupHead node.
+	  */
+	NFAUNode * quantifyGroup(NFAUNode * start, NFAUNode * stop, const int gn);
+
+	/**
+	  Tries to quantify the last parsed expression. If the character was indeed
+	  quantified, then the NFA is modified accordingly.
+	  @param newNode The recently created expression node
+	  @return The node representing the last parsed expression. If the
+	  expression was quantified, return value != newNode
+	  */
+	NFAUNode * quantify(NFAUNode * newNode);
+	/**
+	  Parses the current class being examined in
+	  {@link pattern pattern}.
+	  @return A string of unique characters contained in the current class being
+	  parsed
+	  */
+	CMString parseClass();
+	/**
+	  Parses the current POSIX class being examined in
+	  {@link pattern pattern}.
+	  @return A string of unique characters representing the POSIX class being
+	  parsed
+	  */
+	CMString parsePosix();
+	/**
+	  Returns a string containing the octal character being parsed
+	  @return The string contained the octal value being parsed
+	  */
+	CMString parseOctal();
+	/**
+	  Returns a string containing the hex character being parsed
+	  @return The string contained the hex value being parsed
+	  */
+	CMString parseHex();
+	/**
+	  Returns a new node representing the back reference being parsed
+	  @return The new node representing the back reference being parsed
+	  */
+	NFAUNode *   parseBackref();
+	/**
+	  Parses the escape sequence currently being examined. Determines if the
+	  escape sequence is a class, a single character, or the beginning of a
+	  quotation sequence.
+	  @param inv Output parameter. Whether or not to invert the returned class
+	  @param quo Output parameter. Whether or not this sequence starts a
+	  quotation.
+	  @return The characters represented by the class
+	  */
+	CMString parseEscape(bool & inv, bool & quo);
+	/**
+	  Parses a supposed registered pattern currently under compilation. If the
+	  sequence of characters does point to a registered pattern, then the
+	  registered pattern is appended to *end. The registered pattern
+	  is parsed with the current compilation flags.
+	  @param end The ending node of the thus-far compiled pattern
+	  @return The new end node of the current pattern
+	  */
+	NFAUNode * parseRegisteredWCPattern(NFAUNode ** end);
+	/**
+	  Parses a lookbehind expression. Appends the necessary nodes
+	  *end.
+	  @param pos Positive or negative look behind
+	  @param end The ending node of the current pattern
+	  @return The new end node of the current pattern
+	  */
+	NFAUNode * parseBehind(const bool pos, NFAUNode ** end);
+	/**
+	  Parses the current expression and tacks on nodes until a \E is found.
+	  @return The end of the current pattern
+	  */
+	NFAUNode * parseQuote();
+	/**
+	  Parses {@link pattern pattern}. This function is called
+	  recursively when an or (|) or a group is encountered.
+	  @param inParen Are we currently parsing inside a group
+	  @param inOr Are we currently parsing one side of an or (|)
+	  @param end The end of the current expression
+	  @return The starting node of the NFA constructed from this parse
+	  */
+	NFAUNode * parse(const bool inParen = 0, const bool inOr = 0, NFAUNode ** end = NULL);
+public:
+	/// We should match regardless of case
+	const static unsigned long CASE_INSENSITIVE;
+	/// We are implicitly quoted
+	const static unsigned long LITERAL;
+	/// @memo We should treat a . as [\x00-\x7F]
+	const static unsigned long DOT_MATCHES_ALL;
+	/** ^ and $ should anchor to the beginning and
+		 ending of lines, not all input
+		 */
+	const static unsigned long MULTILINE_MATCHING;
+	/** When enabled, only instances of \n are recognized as
+		 line terminators
+		 */
+	const static unsigned long UNIX_LINE_MODE;
+	/// The absolute minimum number of matches a quantifier can match (0)
+	const static int MIN_QMATCH;
+	/// The absolute maximum number of matches a quantifier can match (0x7FFFFFFF)
+	const static int MAX_QMATCH;
+public:
+	/**
+	  Call this function to compile a regular expression into a
+	  WCPattern object. Special values can be assigned to
+	  mode when certain non-standard behaviors are expected from
+	  the WCPattern object.
+	  @param pattern The regular expression to compile
+	  @param mode    A bitwise or of flags signalling what special behaviors are
+	  wanted from this WCPattern object
+	  @return If successful, compile returns a WCPattern
+	  pointer. Upon failure, compile returns
+	  NULL
+	  */
+	static WCPattern                    * compile(const CMString & pattern,
+		const unsigned long mode = 0);
+	/**
+	  Dont use this function. This function will compile a pattern, and cache
+	  the result. This will eventually be used as an optimization when people
+	  just want to call static methods using the same pattern over and over
+	  instead of first compiling the pattern and then using the compiled
+	  instance for matching.
+	  @param pattern The regular expression to compile
+	  @param mode    A bitwise or of flags signalling what special behaviors are
+	  wanted from this WCPattern object
+	  @return If successful, compileAndKeep returns a
+	  WCPattern pointer. Upon failure, compile
+	  returns NULL.
+	  */
+	static WCPattern                    * compileAndKeep(const CMString & pattern,
+		const unsigned long mode = 0);
+
+	/**
+	  Searches through replace and replaces all substrings matched
+	  by pattern with str. str may
+	  contain backreferences (e.g. \1) to capture groups. A typical
+	  invocation looks like:
+	  

+	  
+	  WCPattern::replace(L"(a+)b(c+)", L"abcccbbabcbabc", L"\\2b\\1");
+	  
+	  

+	  which would replace abcccbbabcbabc with
+	  cccbabbcbabcba.
+	  @param pattern          The regular expression
+	  @param str              The replacement text
+	  @param replacementText  The string in which to perform replacements
+	  @param mode             The special mode requested of the WCPattern
+	  during the replacement process
+	  @return The text with the replacement string substituted where necessary
+	  */
+	static CMString                  replace(const CMString & pattern,
+		const CMString & str,
+		const CMString & replacementText,
+		const unsigned long mode = 0);
+
+	/**
+	  Splits the specified string over occurrences of the specified pattern.
+	  Empty strings can be optionally ignored. The number of strings returned is
+	  configurable. A typical invocation looks like:
+	  

+	  
+	  CMString str(strSize, 0);

+	  FILE * fp = fopen(fileName, "r");

+	  fread((char*)str.data(), strSize * 2, 1, fp);

+	  fclose(fp);

+	  

+	  std::vector<CMString> lines = WCPattern::split(L"[\r\n]+", str, true);

+	  

+	  
+
+	  @param pattern    The regular expression
+	  @param replace    The string to split
+	  @param keepEmptys Whether or not to keep empty strings
+	  @param limit      The maximum number of splits to make
+	  @param mode       The special mode requested of the WCPattern
+	  during the split process
+	  @return All substrings of str split across pattern.
+	  */
+	static std::vector     split(const CMString & pattern,
+		const CMString & str,
+		const bool keepEmptys = 0,
+		const unsigned long limit = 0,
+		const unsigned long mode = 0);
+
+	/**
+	  Finds all the instances of the specified pattern within the string. You
+	  should be careful to only pass patterns with a minimum length of one. For
+	  example, the pattern a* can be matched by an empty string, so
+	  instead you should pass a+ since at least one character must
+	  be matched. A typical invocation of findAll looks like:
+	  

+	  
+	  std::vector<td::string> numbers = WCPattern::findAll(L"\\d+", string);
+	  
+	  

+
+	  @param pattern  The pattern for which to search
+	  @param str      The string to search
+	  @param mode     The special mode requested of the WCPattern
+	  during the find process
+	  @return All instances of pattern in str
+	  */
+	static std::vector     findAll(const CMString & pattern,
+		const CMString & str,
+		const unsigned long mode = 0);
+
+	/**
+	  Determines if an entire string matches the specified pattern
+
+	  @param pattern  The pattern for to match
+	  @param str      The string to match
+	  @param mode     The special mode requested of the WCPattern
+	  during the replacement process
+	  @return True if str is recognized by pattern
+	  */
+	static bool                         matches(const CMString & pattern,
+		const CMString & str,
+		const unsigned long mode = 0);
+
+	/**
+	  Registers a pattern under a specific name for use in later compilations.
+	  A typical invocation and later use looks like:
+	  

+	  
+	  WCPattern::registerWCPattern(L"ip", L"(?:\\d{1,3}\\.){3}\\d{1,3}");

+	  WCPattern * p1 = WCPattern::compile(L"{ip}:\\d+");

+	  WCPattern * p2 = WCPattern::compile(L"Connection from ({ip}) on port \\d+");

+	  
+	  

+	  Multiple calls to registerWCPattern with the same
+	  name will result in the pattern getting overwritten.
+
+	  @param name     The name to give to the pattern
+	  @param pattern  The pattern to register
+	  @param mode     Any special flags to use when compiling pattern
+	  @return Success/Failure. Fails only if pattern has invalid
+	  syntax
+	  */
+	static bool                         registerWCPattern(const CMString & name,
+		const CMString & pattern,
+		const unsigned long mode = 0);
+
+	/**
+	  Clears the pattern registry
+	  */
+	static void                         unregisterWCPatterns();
+	/**
+	  Don't use
+	  */
+	static void                         clearWCPatternCache();
+
+	/**
+	  Searches through a string for the nth match of the
+	  given pattern in the string. Match indeces start at zero, not one.
+	  A typical invocation looks like this:
+	  

+	  
+	  std::pair<CMString, int> match = WCPattern::findNthMatch(L"\\d{1,3}", L"192.168.1.101:22", 1);

+	  wprintf(L"%s %i\n", match.first.c_str(), match.second);

+	  

+	  Output: 168 4

+	  

+
+	  @param pattern  The pattern for which to search
+	  @param str      The string to search
+	  @param matchNum Which match to find
+	  @param mode     Any special flags to use during the matching process
+	  @return A string and an integer. The string is the string matched. The
+	  integer is the starting location of the matched string in
+	  str. You can check for success/failure by making sure
+	  that the integer returned is greater than or equal to zero.
+	  */
+	static std::pair  findNthMatch(const CMString & pattern,
+		const CMString & str,
+		const int matchNum,
+		const unsigned long mode = 0);
+public:
+	/**
+	  Deletes all NFA nodes allocated during compilation
+	  */
+	~WCPattern();
+
+	CMString               replace(const CMString & str,
+		const CMString & replacementText);
+	std::vector  split(const CMString & str, const bool keepEmptys = 0,
+		const unsigned long limit = 0);
+	std::vector  findAll(const CMString & str);
+	bool                       matches(const CMString & str);
+	/**
+	  Returns the flags used during compilation of this pattern
+	  @return The flags used during compilation of this pattern
+	  */
+	unsigned long             getFlags() const;
+	/**
+	  Returns the regular expression this pattern represents
+	  @return The regular expression this pattern represents
+	  */
+	CMString               getWCPattern() const;
+	/**
+	  Creates a matcher object using the specified string and this pattern.
+	  @param str The string to match against
+	  @return A new matcher using object using this pattern and the specified
+	  string
+	  */
+	WCMatcher                 * createWCMatcher(const CMString & str);
 };
 
 class NFAUNode
 {
-  friend class WCMatcher;
-  public:
-    NFAUNode * next;
-    NFAUNode();
-    virtual ~NFAUNode();
-    virtual void findAllNodes(std::map & soFar);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const = 0;
-    inline virtual bool isGroupHeadNode()     const { return false; }
-    inline virtual bool isStartOfInputNode()  const { return false; }
+	friend class WCMatcher;
+public:
+	NFAUNode * next;
+	NFAUNode();
+	virtual ~NFAUNode();
+	virtual void findAllNodes(std::map & soFar);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const = 0;
+	inline virtual bool isGroupHeadNode()     const { return false; }
+	inline virtual bool isStartOfInputNode()  const { return false; }
 };
 class NFACharUNode : public NFAUNode
 {
-  protected:
-    wchar_t ch;
-  public:
-    NFACharUNode(const wchar_t c);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+protected:
+	wchar_t ch;
+public:
+	NFACharUNode(const wchar_t c);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFACICharUNode : public NFAUNode
 {
-  protected:
-    wchar_t ch;
-  public:
-    NFACICharUNode(const wchar_t c);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+protected:
+	wchar_t ch;
+public:
+	NFACICharUNode(const wchar_t c);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAStartUNode : public NFAUNode
 {
-  public:
-    NFAStartUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAStartUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAEndUNode : public NFAUNode
 {
-  public:
-    NFAEndUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAEndUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAQuantifierUNode : public NFAUNode
 {
-  public:
-    int min, max;
-    NFAUNode * inner;
-    virtual void findAllNodes(std::map & soFar);
-    NFAQuantifierUNode(WCPattern * pat, NFAUNode * internal,
-                      const int minMatch = WCPattern::MIN_QMATCH,
-                      const int maxMatch = WCPattern::MAX_QMATCH);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	int min, max;
+	NFAUNode * inner;
+	virtual void findAllNodes(std::map & soFar);
+	NFAQuantifierUNode(WCPattern * pat, NFAUNode * internal,
+		const int minMatch = WCPattern::MIN_QMATCH,
+		const int maxMatch = WCPattern::MAX_QMATCH);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAGreedyQuantifierUNode : public NFAQuantifierUNode
 {
-  public:
-    NFAGreedyQuantifierUNode(WCPattern * pat, NFAUNode * internal,
-                            const int minMatch = WCPattern::MIN_QMATCH,
-                            const int maxMatch = WCPattern::MAX_QMATCH);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
-    virtual int matchInternal(const bkstring & str, WCMatcher * matcher, const int curInd, const int soFar) const;
+public:
+	NFAGreedyQuantifierUNode(WCPattern * pat, NFAUNode * internal,
+		const int minMatch = WCPattern::MIN_QMATCH,
+		const int maxMatch = WCPattern::MAX_QMATCH);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
+	virtual int matchInternal(const CMString & str, WCMatcher * matcher, const int curInd, const int soFar) const;
 };
 class NFALazyQuantifierUNode : public NFAQuantifierUNode
 {
-  public:
-    NFALazyQuantifierUNode(WCPattern * pat, NFAUNode * internal,
-                          const int minMatch = WCPattern::MIN_QMATCH,
-                          const int maxMatch = WCPattern::MAX_QMATCH);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFALazyQuantifierUNode(WCPattern * pat, NFAUNode * internal,
+		const int minMatch = WCPattern::MIN_QMATCH,
+		const int maxMatch = WCPattern::MAX_QMATCH);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAPossessiveQuantifierUNode : public NFAQuantifierUNode
 {
-  public:
-    NFAPossessiveQuantifierUNode(WCPattern * pat, NFAUNode * internal,
-                                const int minMatch = WCPattern::MIN_QMATCH,
-                                const int maxMatch = WCPattern::MAX_QMATCH);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAPossessiveQuantifierUNode(WCPattern * pat, NFAUNode * internal,
+		const int minMatch = WCPattern::MIN_QMATCH,
+		const int maxMatch = WCPattern::MAX_QMATCH);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAAcceptUNode : public NFAUNode
 {
-  public:
-    NFAAcceptUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAAcceptUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAClassUNode : public NFAUNode
 {
-  public:
-    bool inv;
-    std::map vals;
-    NFAClassUNode(const bool invert = 0);
-    NFAClassUNode(const bkstring & clazz, const bool invert);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	bool inv;
+	std::map vals;
+	NFAClassUNode(const bool invert = 0);
+	NFAClassUNode(const CMString & clazz, const bool invert);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFACIClassUNode : public NFAUNode
 {
-  public:
-    bool inv;
-    std::map vals;
-    NFACIClassUNode(const bool invert = 0);
-    NFACIClassUNode(const bkstring & clazz, const bool invert);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	bool inv;
+	std::map vals;
+	NFACIClassUNode(const bool invert = 0);
+	NFACIClassUNode(const CMString & clazz, const bool invert);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFASubStartUNode : public NFAUNode
 {
-  public:
-    NFASubStartUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFASubStartUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAOrUNode : public NFAUNode
 {
-  public:
-    NFAUNode * one;
-    NFAUNode * two;
-    NFAOrUNode(NFAUNode * first, NFAUNode * second);
-    virtual void findAllNodes(std::map & soFar);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAUNode * one;
+	NFAUNode * two;
+	NFAOrUNode(NFAUNode * first, NFAUNode * second);
+	virtual void findAllNodes(std::map & soFar);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAQuoteUNode : public NFAUNode
 {
-  public:
-    bkstring qStr;
-    NFAQuoteUNode(const bkstring & quoted);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	CMString qStr;
+	NFAQuoteUNode(const CMString & quoted);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFACIQuoteUNode : public NFAUNode
 {
-  public:
-    bkstring qStr;
-    NFACIQuoteUNode(const bkstring & quoted);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	CMString qStr;
+	NFACIQuoteUNode(const CMString & quoted);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFALookAheadUNode : public NFAUNode
 {
-  public:
-    bool pos;
-    NFAUNode * inner;
-    NFALookAheadUNode(NFAUNode * internal, const bool positive);
-    virtual void findAllNodes(std::map & soFar);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	bool pos;
+	NFAUNode * inner;
+	NFALookAheadUNode(NFAUNode * internal, const bool positive);
+	virtual void findAllNodes(std::map & soFar);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFALookBehindUNode : public NFAUNode
 {
-  public:
-    bool pos;
-    bkstring mStr;
-    NFALookBehindUNode(const bkstring & str, const bool positive);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	bool pos;
+	CMString mStr;
+	NFALookBehindUNode(const CMString & str, const bool positive);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAStartOfLineUNode : public NFAUNode
 {
-  public:
-    NFAStartOfLineUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAStartOfLineUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAEndOfLineUNode : public NFAUNode
 {
-  public:
-    NFAEndOfLineUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAEndOfLineUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAReferenceUNode : public NFAUNode
 {
-  public:
-    int gi;
-    NFAReferenceUNode(const int groupIndex);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	int gi;
+	NFAReferenceUNode(const int groupIndex);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAStartOfInputUNode : public NFAUNode
 {
-  public:
-    NFAStartOfInputUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
-    inline virtual bool isStartOfInputNode()  const { return false; }
+public:
+	NFAStartOfInputUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
+	inline virtual bool isStartOfInputNode()  const { return false; }
 };
 class NFAEndOfInputUNode : public NFAUNode
 {
-  public:
-    bool term;
-    NFAEndOfInputUNode(const bool lookForTerm);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	bool term;
+	NFAEndOfInputUNode(const bool lookForTerm);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAWordBoundaryUNode : public NFAUNode
 {
-  public:
-    bool pos;
-    NFAWordBoundaryUNode(const bool positive);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	bool pos;
+	NFAWordBoundaryUNode(const bool positive);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAEndOfMatchUNode : public NFAUNode
 {
-  public:
-    NFAEndOfMatchUNode();
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	NFAEndOfMatchUNode();
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAGroupHeadUNode : public NFAUNode
 {
-  public:
-    int gi;
-    NFAGroupHeadUNode(const int groupIndex);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
-    inline virtual bool isGroupHeadNode()     const { return false; }
+public:
+	int gi;
+	NFAGroupHeadUNode(const int groupIndex);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
+	inline virtual bool isGroupHeadNode()     const { return false; }
 };
 class NFAGroupTailUNode : public NFAUNode
 {
-  public:
-    int gi;
-    NFAGroupTailUNode(const int groupIndex);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	int gi;
+	NFAGroupTailUNode(const int groupIndex);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAGroupLoopPrologueUNode : public NFAUNode
 {
-  public:
-    int gi;
-    NFAGroupLoopPrologueUNode(const int groupIndex);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	int gi;
+	NFAGroupLoopPrologueUNode(const int groupIndex);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 class NFAGroupLoopUNode : public NFAUNode
 {
-  public:
-    int gi, min, max, type;
-    NFAUNode * inner;
-    NFAGroupLoopUNode(NFAUNode * internal, const int minMatch,
-                     const int maxMatch, const int groupIndex, const int matchType);
-    virtual void findAllNodes(std::map & soFar);
-    virtual int match(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
-    int matchGreedy(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
-    int matchLazy(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
-    int matchPossessive(const bkstring & str, WCMatcher * matcher, const int curInd = 0) const;
+public:
+	int gi, min, max, type;
+	NFAUNode * inner;
+	NFAGroupLoopUNode(NFAUNode * internal, const int minMatch,
+		const int maxMatch, const int groupIndex, const int matchType);
+	virtual void findAllNodes(std::map & soFar);
+	virtual int match(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
+	int matchGreedy(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
+	int matchLazy(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
+	int matchPossessive(const CMString & str, WCMatcher * matcher, const int curInd = 0) const;
 };
 
 #endif
-- 
cgit v1.2.3