COXRegExpression
COXRegExpression - new class that implements regular expression functionality.

	Most of us had problems with searching some text in text files. Yes, we can use searching capabilities that are provided with	many programs. But, in case we have to do some generic search it is not the case. For such cases COXRegExpression class is exactly what we had to have. This class provided generic search regarding the rule you've supplied. To do search, you have to load regular expression that defines what do you want to search. There are different formats and different implementation for regular expression. This implementation is most close to that one described in MSDN that comes with Visual Studio 6.0

	The rules:

  Character				 Description

	\		 Marks the next character as special. All characters that are
			 special but you want to define it for search should be 
			 preceding by this character.
	^		 Matches the begining of input or line. In this implementation 			 it cannot be defined in charset.
	$		 Matches the end of input or line. In this implementation it 
			 cannot be defined in charset.
	*		 Matches preceding character zero or more times. In this 				 implementation cannot be defined if only one character 				 specified in the regular expression. That means that /zo*/ 			 matches z and zoo, but /z*/ will match nothing because only 			 one character has been specified.
	+		 Matches preceding character one or more times. 
	?		 Matches preceding character zero or one time. In this 				 implementation cannot be defined if only one character 				 specified in the regular expression.
	.		 Matches any single character except '\n'
 (pattern)	 	 Matches pattern and remembers the match. The matched 				 substring can be retrieved by using '\0'-'\9' in regular 				 expression, where '0'-'9' are number of the pattern. Example:
			 regular expression '(re).*\0s+ion' will match 'regular 				 expression' because first matches pattern 're' and remember 			 the pattern with index 0. '.*' will match 'gular exp' in 				 'regular expression'. Now we retrieve pattern with index 0, 			 that has been remembered with index 0, this is 're' that 				 matches 're' in 'regular expression' before 'ssion' and , 				 finally, 's+ion' matches 'ssion' 
	x|y		 Matches either character 'x' or 'y'. You can combine more 				 than two characters like 'x|y|z'
      {n}		 Means preceding character will match exactly n times 				 (nonnegative, of course)
     {n,}	 	 Means preseding character will match at least n times 				 (nonnegative)
    {n,m}		 Means preceding character will match at least n times and at 
			 most m times. (n,m - nonnegative)
    [xyz]		 A character set. Matches any one of enclosed characters
   [^xyz]	 A non-matching character set. Matches any character  
 that is not in the set.
	\b		 Matches word boundary, that is boundary between any character 
 excluding space characters (" \f\n\r\t\v") and space 
 characters
	\B		 Matches non-word boundary. Matches any boundary between space 
			 characters or between nonspace characters.
	\d		 Matches any digit /0-9/
	\D		 Matches any non-digit.
	\f		 Matches a formfeed.
	\n		 Matches a new-line character
	\r		 Matches a carridge return character.
	\s		 Matches any white space character
	\S		 Matches any non-white space character
	\t		 Matches a tab character
	\v		 Matches any vertical tab character
	\w		 Matches any word character including underscore. [A-Za-z0-9_]
\W	 Matches any non-word character (any character that does not 
 match \w)
\num	 Where num is number between 0 and 9. Matches 
 remembered pattern. (See description of pattern)
	/n/		 Where n is between 1 and 255. Matches supplied in n ASCII 
 code

Three easy steps to use:
1)	Create your own derived from COXRegExpression class and override function 
OnMatch() This virtual function is always called when a matched 
substring has been found. When this function is called you can return 
TRUE to continue search or FALSE if you do not want continue search.
	2) Load your regular expression by function LoadRule()
  	3) Call function Match() to do the search in supplied text.

Now how it works.
 There are two steps in the work -1)load regular expression and 2) search the 
 text

1)load regular expression
  When you are loading regular expression, LoadRule() calls function Parse() 
  that has a huge switch. This function do parsing of the rule and create tags 
  of different types for every sequences of special characters, depends on the 
  type of special characters. For some special characters founded it calls 
  appropriate functions like GetAsciiChar() or GetEither() to do this special 
  parsing. The tags are added to the collection of tags. Any tag can be 
  retrieved by GetTag(). The function Parse is virtual, so, if you need to 
  process some special characters, that are not specified here, you can override 
  it. Once Parse() or called subfunction found error, Parce stops parsing and 
  returns FALSE. You can retrieve error code by GetError() and translate it to 
  description by TranslateError()

2) search the text
  The search text makes function Match() that call recursive function 
  MatchNextTag() with start tag number=0. Match() does loop, every time 
  incrementing start position in the supplied text for the search untill end of 
  the text has been reached. MatchNextTag() does main job and once the tag 
  matches the text at the specified position does either, call OnMatch() if the 
  tag was last in the collection of the tags or calls MatchNextTag() to match 
  next tag from the collection. 

The function MatchNextTag() like Parse() is 
  virtual, so, it's up to you override it if you want to process some special 
  sequences.